Merge branch 'constraints-slices' of github.com:prysmaticlabs/prysm into constraints-slices

* cleaner rpc responses

* clean up unecessary stack trace

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

.buildkite-bazelrc

@@ -10,7 +10,7 @@
 
 # Prysm specific remote-cache properties.
 #build:remote-cache --disk_cache=
-build:remote-cache --remote_download_minimal
+build:remote-cache --remote_download_toplevel
 build:remote-cache --remote_cache=grpc://bazel-remote-cache:9092
 build:remote-cache --experimental_remote_downloader=grpc://bazel-remote-cache:9092
 build:remote-cache --remote_local_fallback

WORKSPACE

@@ -215,7 +215,7 @@ filegroup(
     url = "https://github.com/eth-clients/slashing-protection-interchange-tests/archive/b8413ca42dc92308019d0d4db52c87e9e125c4e9.tar.gz",
 )
 
-consensus_spec_version = "v1.1.10"
+consensus_spec_version = "v1.2.0-rc.1"
 
 bls_test_version = "v0.1.1"
 
@@ -231,7 +231,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "28043009cc2f6fc9804e73c8c1fc2cb27062f1591e6884f3015ae1dd7a276883",
+    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 = "bc1a283ca068f310f04d70c4f6a8eaa0b8f7e9318073a8bdc2ee233111b4e339",
+    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 = "bbabb482c229ff9d4e2c7b77c992edb452f9d0af7c6d8dd4f922f06a7b101e81",
+    sha256 = "022dcc0d6de7dd27b337a0d1b945077eaf5ee47000700395a693fc25e12f96df",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
 )
 
@@ -278,7 +278,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "408a5524548ad3fcf387f65ac7ec52781d9ee899499720bb12451b48a15818d4",
+    sha256 = "0a9c110305cbd6ebbe0d942f0f33e6ce22dd484ce4ceed277bf185a091941cde",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )

api/client/beacon/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

api/client/builder/BUILD.bazel

@@ -0,0 +1,41 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "client.go",
+        "errors.go",
+        "types.go",
+    ],
+    importpath = "github.com/prysmaticlabs/prysm/api/client/builder",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//consensus-types/primitives:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "client_test.go",
+        "types_test.go",
+    ],
+    data = glob(["testdata/**"]),
+    embed = [":go_default_library"],
+    deps = [
+        "//config/fieldparams:go_default_library",
+        "//consensus-types/primitives:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//testing/require:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
+    ],
+)

api/client/builder/client.go

@@ -0,0 +1,254 @@
+package builder
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"text/template"
+	"time"
+
+	v1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+
+	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	log "github.com/sirupsen/logrus"
+)
+
+const (
+	getExecHeaderPath          = "/eth/v1/builder/header/{{.Slot}}/{{.ParentHash}}/{{.Pubkey}}"
+	getStatus                  = "/eth/v1/builder/status"
+	postBlindedBeaconBlockPath = "/eth/v1/builder/blinded_blocks"
+	postRegisterValidatorPath  = "/eth/v1/builder/validators"
+)
+
+var errMalformedHostname = errors.New("hostname must include port, separated by one colon, like example.com:3500")
+
+// ClientOpt is a functional option for the Client type (http.Client wrapper)
+type ClientOpt func(*Client)
+
+// WithTimeout sets the .Timeout attribute of the wrapped http.Client.
+func WithTimeout(timeout time.Duration) ClientOpt {
+	return func(c *Client) {
+		c.hc.Timeout = timeout
+	}
+}
+
+type observer interface {
+	observe(r *http.Request) error
+}
+
+func WithObserver(m observer) ClientOpt {
+	return func(c *Client) {
+		c.obvs = append(c.obvs, m)
+	}
+}
+
+type requestLogger struct{}
+
+func (*requestLogger) observe(r *http.Request) (e error) {
+	b := bytes.NewBuffer(nil)
+	if r.Body == nil {
+		log.WithFields(log.Fields{
+			"body-base64": "(nil value)",
+			"url":         r.URL.String(),
+		}).Info("builder http request")
+		return nil
+	}
+	t := io.TeeReader(r.Body, b)
+	defer func() {
+		if r.Body != nil {
+			e = r.Body.Close()
+		}
+	}()
+	body, err := io.ReadAll(t)
+	if err != nil {
+		return err
+	}
+	r.Body = io.NopCloser(b)
+	log.WithFields(log.Fields{
+		"body-base64": string(body),
+		"url":         r.URL.String(),
+	}).Info("builder http request")
+
+	return nil
+}
+
+var _ observer = &requestLogger{}
+
+// Client provides a collection of helper methods for calling Builder API endpoints.
+type Client struct {
+	hc      *http.Client
+	baseURL *url.URL
+	obvs    []observer
+}
+
+// NewClient constructs a new client with the provided options (ex WithTimeout).
+// `host` is the base host + port used to construct request urls. This value can be
+// a URL string, or NewClient will assume an http endpoint if just `host:port` is used.
+func NewClient(host string, opts ...ClientOpt) (*Client, error) {
+	u, err := urlForHost(host)
+	if err != nil {
+		return nil, err
+	}
+	c := &Client{
+		hc:      &http.Client{},
+		baseURL: u,
+	}
+	for _, o := range opts {
+		o(c)
+	}
+	return c, nil
+}
+
+func urlForHost(h string) (*url.URL, error) {
+	// try to parse as url (being permissive)
+	u, err := url.Parse(h)
+	if err == nil && u.Host != "" {
+		return u, nil
+	}
+	// try to parse as host:port
+	host, port, err := net.SplitHostPort(h)
+	if err != nil {
+		return nil, errMalformedHostname
+	}
+	return &url.URL{Host: net.JoinHostPort(host, port), Scheme: "http"}, nil
+}
+
+// NodeURL returns a human-readable string representation of the beacon node base url.
+func (c *Client) NodeURL() string {
+	return c.baseURL.String()
+}
+
+type reqOption func(*http.Request)
+
+// do is a generic, opinionated GET function to reduce boilerplate amongst the getters in this packageapi/client/builder/types.go.
+func (c *Client) do(ctx context.Context, method string, path string, body io.Reader, opts ...reqOption) ([]byte, error) {
+	u := c.baseURL.ResolveReference(&url.URL{Path: path})
+	log.Printf("requesting %s", u.String())
+	req, err := http.NewRequestWithContext(ctx, method, u.String(), body)
+	if err != nil {
+		return nil, err
+	}
+	for _, o := range opts {
+		o(req)
+	}
+	for _, o := range c.obvs {
+		if err := o.observe(req); err != nil {
+			return nil, err
+		}
+	}
+	r, err := c.hc.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		err = r.Body.Close()
+	}()
+	if r.StatusCode != http.StatusOK {
+		return nil, non200Err(r)
+	}
+	b, err := io.ReadAll(r.Body)
+	if err != nil {
+		return nil, errors.Wrap(err, "error reading http response body from GetBlock")
+	}
+	return b, nil
+}
+
+var execHeaderTemplate = template.Must(template.New("").Parse(getExecHeaderPath))
+
+func execHeaderPath(slot types.Slot, parentHash [32]byte, pubkey [48]byte) (string, error) {
+	v := struct {
+		Slot       types.Slot
+		ParentHash string
+		Pubkey     string
+	}{
+		Slot:       slot,
+		ParentHash: fmt.Sprintf("%#x", parentHash),
+		Pubkey:     fmt.Sprintf("%#x", pubkey),
+	}
+	b := bytes.NewBuffer(nil)
+	err := execHeaderTemplate.Execute(b, v)
+	if err != nil {
+		return "", errors.Wrapf(err, "error rendering exec header template with slot=%d, parentHash=%#x, pubkey=%#x", slot, parentHash, pubkey)
+	}
+	return b.String(), nil
+}
+
+// GetHeader is used by a proposing validator to request an ExecutionPayloadHeader from the Builder node.
+func (c *Client) GetHeader(ctx context.Context, slot types.Slot, parentHash [32]byte, pubkey [48]byte) (*ethpb.SignedBuilderBid, error) {
+	path, err := execHeaderPath(slot, parentHash, pubkey)
+	if err != nil {
+		return nil, err
+	}
+	hb, err := c.do(ctx, http.MethodGet, path, nil)
+	if err != nil {
+		return nil, err
+	}
+	hr := &ExecHeaderResponse{}
+	if err := json.Unmarshal(hb, hr); err != nil {
+		return nil, errors.Wrapf(err, "error unmarshaling the builder GetHeader response, using slot=%d, parentHash=%#x, pubkey=%#x", slot, parentHash, pubkey)
+	}
+	return hr.ToProto()
+}
+
+// RegisterValidator encodes the SignedValidatorRegistrationV1 message to json (including hex-encoding the byte
+// fields with 0x prefixes) and posts to the builder validator registration endpoint.
+func (c *Client) RegisterValidator(ctx context.Context, svr *ethpb.SignedValidatorRegistrationV1) error {
+	v := &SignedValidatorRegistration{SignedValidatorRegistrationV1: svr}
+	body, err := json.Marshal(v)
+	if err != nil {
+		return errors.Wrap(err, "error encoding the SignedValidatorRegistration value body in RegisterValidator")
+	}
+	_, err = c.do(ctx, http.MethodPost, postRegisterValidatorPath, bytes.NewBuffer(body))
+	return err
+}
+
+// SubmitBlindedBlock calls the builder API endpoint that binds the validator to the builder and submits the block.
+// The response is the full ExecutionPayload used to create the blinded block.
+func (c *Client) SubmitBlindedBlock(ctx context.Context, sb *ethpb.SignedBlindedBeaconBlockBellatrix) (*v1.ExecutionPayload, error) {
+	v := &SignedBlindedBeaconBlockBellatrix{SignedBlindedBeaconBlockBellatrix: sb}
+	body, err := json.Marshal(v)
+	if err != nil {
+		return nil, errors.Wrap(err, "error encoding the SignedBlindedBeaconBlockBellatrix value body in SubmitBlindedBlock")
+	}
+	rb, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body))
+	if err != nil {
+		return nil, errors.Wrap(err, "error posting the SignedBlindedBeaconBlockBellatrix to the builder api")
+	}
+	ep := &ExecPayloadResponse{}
+	if err := json.Unmarshal(rb, ep); err != nil {
+		return nil, errors.Wrap(err, "error unmarshaling the builder SubmitBlindedBlock response")
+	}
+	return ep.ToProto()
+}
+
+// Status asks the remote builder server for a health check. A response of 200 with an empty body is the success/healthy
+// response, and an error response may have an error message. This method will return a nil value for error in the
+// happy path, and an error with information about the server response body for a non-200 response.
+func (c *Client) Status(ctx context.Context) error {
+	_, err := c.do(ctx, http.MethodGet, getStatus, nil)
+	return err
+}
+
+func non200Err(response *http.Response) error {
+	bodyBytes, err := io.ReadAll(response.Body)
+	var body string
+	if err != nil {
+		body = "(Unable to read response body.)"
+	} else {
+		body = "response body:\n" + string(bodyBytes)
+	}
+	msg := fmt.Sprintf("code=%d, url=%s, body=%s", response.StatusCode, response.Request.URL, body)
+	switch response.StatusCode {
+	case 404:
+		return errors.Wrap(ErrNotFound, msg)
+	default:
+		return errors.Wrap(ErrNotOK, msg)
+	}
+}

api/client/builder/client_test.go

@@ -0,0 +1,344 @@
+package builder
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strconv"
+	"testing"
+
+	"github.com/prysmaticlabs/go-bitfield"
+	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
+	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/testing/require"
+)
+
+type roundtrip func(*http.Request) (*http.Response, error)
+
+func (fn roundtrip) RoundTrip(r *http.Request) (*http.Response, error) {
+	return fn(r)
+}
+
+func TestClient_Status(t *testing.T) {
+	ctx := context.Background()
+	statusPath := "/eth/v1/builder/status"
+	hc := &http.Client{
+		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
+			defer func() {
+				if r.Body == nil {
+					return
+				}
+				require.NoError(t, r.Body.Close())
+			}()
+			require.Equal(t, statusPath, r.URL.Path)
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(bytes.NewBuffer(nil)),
+				Request:    r.Clone(ctx),
+			}, nil
+		}),
+	}
+	c := &Client{
+		hc:      hc,
+		baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
+	}
+	require.NoError(t, c.Status(ctx))
+	hc = &http.Client{
+		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
+			defer func() {
+				if r.Body == nil {
+					return
+				}
+				require.NoError(t, r.Body.Close())
+			}()
+			require.Equal(t, statusPath, r.URL.Path)
+			return &http.Response{
+				StatusCode: http.StatusInternalServerError,
+				Body:       io.NopCloser(bytes.NewBuffer(nil)),
+				Request:    r.Clone(ctx),
+			}, nil
+		}),
+	}
+	c = &Client{
+		hc:      hc,
+		baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
+	}
+	require.ErrorIs(t, c.Status(ctx), ErrNotOK)
+}
+
+func TestClient_RegisterValidator(t *testing.T) {
+	ctx := context.Background()
+	expectedBody := `{"message":{"fee_recipient":"0x0000000000000000000000000000000000000000","gas_limit":"23","timestamp":"42","pubkey":"0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"}}`
+	expectedPath := "/eth/v1/builder/validators"
+	hc := &http.Client{
+		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
+			body, err := io.ReadAll(r.Body)
+			defer func() {
+				require.NoError(t, r.Body.Close())
+			}()
+			require.NoError(t, err)
+			require.Equal(t, expectedBody, string(body))
+			require.Equal(t, expectedPath, r.URL.Path)
+			require.Equal(t, http.MethodPost, r.Method)
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(bytes.NewBuffer(nil)),
+				Request:    r.Clone(ctx),
+			}, nil
+		}),
+	}
+	c := &Client{
+		hc:      hc,
+		baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
+	}
+	reg := &eth.SignedValidatorRegistrationV1{
+		Message: &eth.ValidatorRegistrationV1{
+			FeeRecipient: ezDecode(t, fieldparams.EthBurnAddressHex),
+			GasLimit:     23,
+			Timestamp:    42,
+			Pubkey:       ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"),
+		},
+	}
+	require.NoError(t, c.RegisterValidator(ctx, reg))
+}
+
+func TestClient_GetHeader(t *testing.T) {
+	ctx := context.Background()
+	expectedPath := "/eth/v1/builder/header/23/0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2/0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
+	hc := &http.Client{
+		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
+			require.Equal(t, expectedPath, r.URL.Path)
+			return &http.Response{
+				StatusCode: http.StatusInternalServerError,
+				Body:       io.NopCloser(bytes.NewBuffer(nil)),
+				Request:    r.Clone(ctx),
+			}, nil
+		}),
+	}
+	c := &Client{
+		hc:      hc,
+		baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
+	}
+	var slot types.Slot = 23
+	parentHash := ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	pubkey := ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a")
+	_, err := c.GetHeader(ctx, slot, bytesutil.ToBytes32(parentHash), bytesutil.ToBytes48(pubkey))
+	require.ErrorIs(t, err, ErrNotOK)
+
+	hc = &http.Client{
+		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
+			require.Equal(t, expectedPath, r.URL.Path)
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(bytes.NewBufferString(testExampleHeaderResponse)),
+				Request:    r.Clone(ctx),
+			}, nil
+		}),
+	}
+	c = &Client{
+		hc:      hc,
+		baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
+	}
+	h, err := c.GetHeader(ctx, slot, bytesutil.ToBytes32(parentHash), bytesutil.ToBytes48(pubkey))
+	require.NoError(t, err)
+	expectedSig := ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505")
+	require.Equal(t, true, bytes.Equal(expectedSig, h.Signature))
+	expectedTxRoot := ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.Equal(t, true, bytes.Equal(expectedTxRoot, h.Message.Header.TransactionsRoot))
+	require.Equal(t, uint64(1), h.Message.Header.GasUsed)
+	value := stringToUint256("652312848583266388373324160190187140051835877600158453279131187530910662656")
+	require.Equal(t, fmt.Sprintf("%#x", value.SSZBytes()), fmt.Sprintf("%#x", h.Message.Value))
+}
+
+func TestSubmitBlindedBlock(t *testing.T) {
+	ctx := context.Background()
+	hc := &http.Client{
+		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
+			require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(bytes.NewBufferString(testExampleExecutionPayload)),
+				Request:    r.Clone(ctx),
+			}, nil
+		}),
+	}
+	c := &Client{
+		hc:      hc,
+		baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
+	}
+	sbbb := testSignedBlindedBeaconBlockBellatrix(t)
+	ep, err := c.SubmitBlindedBlock(ctx, sbbb)
+	require.NoError(t, err)
+	require.Equal(t, true, bytes.Equal(ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"), ep.ParentHash))
+	bfpg := stringToUint256("452312848583266388373324160190187140051835877600158453279131187530910662656")
+	require.Equal(t, fmt.Sprintf("%#x", bfpg.SSZBytes()), fmt.Sprintf("%#x", ep.BaseFeePerGas))
+	require.Equal(t, uint64(1), ep.GasLimit)
+}
+
+func testSignedBlindedBeaconBlockBellatrix(t *testing.T) *eth.SignedBlindedBeaconBlockBellatrix {
+	return &eth.SignedBlindedBeaconBlockBellatrix{
+		Block: &eth.BlindedBeaconBlockBellatrix{
+			Slot:          1,
+			ProposerIndex: 1,
+			ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+			StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+			Body: &eth.BlindedBeaconBlockBodyBellatrix{
+				RandaoReveal: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+				Eth1Data: &eth.Eth1Data{
+					DepositRoot:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+					DepositCount: 1,
+					BlockHash:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+				},
+				Graffiti: ezDecode(t, "0xdeadbeefc0ffee"),
+				ProposerSlashings: []*eth.ProposerSlashing{
+					{
+						Header_1: &eth.SignedBeaconBlockHeader{
+							Header: &eth.BeaconBlockHeader{
+								Slot:          1,
+								ProposerIndex: 1,
+								ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+								StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+								BodyRoot:      ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+							},
+							Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+						},
+						Header_2: &eth.SignedBeaconBlockHeader{
+							Header: &eth.BeaconBlockHeader{
+								Slot:          1,
+								ProposerIndex: 1,
+								ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+								StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+								BodyRoot:      ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+							},
+							Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+						},
+					},
+				},
+				AttesterSlashings: []*eth.AttesterSlashing{
+					{
+						Attestation_1: &eth.IndexedAttestation{
+							AttestingIndices: []uint64{1},
+							Data: &eth.AttestationData{
+								Slot:            1,
+								CommitteeIndex:  1,
+								BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+								Source: &eth.Checkpoint{
+									Epoch: 1,
+									Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+								},
+								Target: &eth.Checkpoint{
+									Epoch: 1,
+									Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+								},
+							},
+							Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+						},
+						Attestation_2: &eth.IndexedAttestation{
+							AttestingIndices: []uint64{1},
+							Data: &eth.AttestationData{
+								Slot:            1,
+								CommitteeIndex:  1,
+								BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+								Source: &eth.Checkpoint{
+									Epoch: 1,
+									Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+								},
+								Target: &eth.Checkpoint{
+									Epoch: 1,
+									Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+								},
+							},
+							Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+						},
+					},
+				},
+				Attestations: []*eth.Attestation{
+					{
+						AggregationBits: bitfield.Bitlist{0x01},
+						Data: &eth.AttestationData{
+							Slot:            1,
+							CommitteeIndex:  1,
+							BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+							Source: &eth.Checkpoint{
+								Epoch: 1,
+								Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+							},
+							Target: &eth.Checkpoint{
+								Epoch: 1,
+								Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+							},
+						},
+						Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+					},
+				},
+				Deposits: []*eth.Deposit{
+					{
+						Proof: [][]byte{ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")},
+						Data: &eth.Deposit_Data{
+							PublicKey:             ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"),
+							WithdrawalCredentials: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+							Amount:                1,
+							Signature:             ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+						},
+					},
+				},
+				VoluntaryExits: []*eth.SignedVoluntaryExit{
+					{
+						Exit: &eth.VoluntaryExit{
+							Epoch:          1,
+							ValidatorIndex: 1,
+						},
+						Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+					},
+				},
+				SyncAggregate: &eth.SyncAggregate{
+					SyncCommitteeSignature: make([]byte, 48),
+					SyncCommitteeBits:      bitfield.Bitvector512{0x01},
+				},
+				ExecutionPayloadHeader: &eth.ExecutionPayloadHeader{
+					ParentHash:       ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+					FeeRecipient:     ezDecode(t, "0xabcf8e0d4e9587369b2301d0790347320302cc09"),
+					StateRoot:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+					ReceiptsRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+					LogsBloom:        ezDecode(t, "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+					PrevRandao:       ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+					BlockNumber:      1,
+					GasLimit:         1,
+					GasUsed:          1,
+					Timestamp:        1,
+					ExtraData:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+					BaseFeePerGas:    []byte(strconv.FormatUint(1, 10)),
+					BlockHash:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+					TransactionsRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+				},
+			},
+		},
+		Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+	}
+}
+
+func TestRequestLogger(t *testing.T) {
+	wo := WithObserver(&requestLogger{})
+	c, err := NewClient("localhost:3500", wo)
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	hc := &http.Client{
+		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
+			require.Equal(t, getStatus, r.URL.Path)
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(bytes.NewBufferString(testExampleExecutionPayload)),
+				Request:    r.Clone(ctx),
+			}, nil
+		}),
+	}
+	c.hc = hc
+	err = c.Status(ctx)
+	require.NoError(t, err)
+}

api/client/builder/errors.go

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

api/client/builder/testdata/execution-payload.json

@@ -0,0 +1 @@
+{"parent_hash":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","fee_recipient":"0xabcf8e0d4e9587369b2301d0790347320302cc09","state_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","receipts_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","logs_bloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","prev_randao":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","block_number":"1","gas_limit":"1","gas_used":"1","timestamp":"1","extra_data":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","base_fee_per_gas":"14074904626401341155369551180448584754667373453244490859944217516317499064576","block_hash":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","transactions_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"}

api/client/builder/types.go

@@ -0,0 +1,585 @@
+package builder
+
+import (
+	"encoding/json"
+	"fmt"
+	"math/big"
+	"strconv"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	v1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
+	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+)
+
+type SignedValidatorRegistration struct {
+	*eth.SignedValidatorRegistrationV1
+}
+
+type ValidatorRegistration struct {
+	*eth.ValidatorRegistrationV1
+}
+
+func (r *SignedValidatorRegistration) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		Message   *ValidatorRegistration `json:"message,omitempty"`
+		Signature hexutil.Bytes          `json:"signature,omitempty"`
+	}{
+		Message:   &ValidatorRegistration{r.Message},
+		Signature: r.SignedValidatorRegistrationV1.Signature,
+	})
+}
+
+func (r *ValidatorRegistration) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		FeeRecipient hexutil.Bytes `json:"fee_recipient,omitempty"`
+		GasLimit     string        `json:"gas_limit,omitempty"`
+		Timestamp    string        `json:"timestamp,omitempty"`
+		Pubkey       hexutil.Bytes `json:"pubkey,omitempty"`
+	}{
+		FeeRecipient: r.FeeRecipient,
+		GasLimit:     fmt.Sprintf("%d", r.GasLimit),
+		Timestamp:    fmt.Sprintf("%d", r.Timestamp),
+		Pubkey:       r.Pubkey,
+	})
+}
+
+type Uint256 struct {
+	*big.Int
+}
+
+func stringToUint256(s string) Uint256 {
+	bi := new(big.Int)
+	bi.SetString(s, 10)
+	return Uint256{Int: bi}
+}
+
+// sszBytesToUint256 creates a Uint256 from a ssz-style (little-endian byte slice) representation.
+func sszBytesToUint256(b []byte) Uint256 {
+	bi := new(big.Int)
+	return Uint256{Int: bi.SetBytes(bytesutil.ReverseByteOrder(b))}
+}
+
+// SSZBytes creates an ssz-style (little-endian byte slice) representation of the Uint256
+func (s Uint256) SSZBytes() []byte {
+	return bytesutil.ReverseByteOrder(s.Int.Bytes())
+}
+
+var errUnmarshalUint256Failed = errors.New("unable to UnmarshalText into a Uint256 value")
+
+func (s *Uint256) UnmarshalJSON(t []byte) error {
+	start := 0
+	end := len(t)
+	if t[0] == '"' {
+		start += 1
+	}
+	if t[end-1] == '"' {
+		end -= 1
+	}
+	return s.UnmarshalText(t[start:end])
+}
+
+func (s *Uint256) UnmarshalText(t []byte) error {
+	if s.Int == nil {
+		s.Int = big.NewInt(0)
+	}
+	z, ok := s.SetString(string(t), 10)
+	if !ok {
+		return errors.Wrapf(errUnmarshalUint256Failed, "value=%s", string(t))
+	}
+	s.Int = z
+	return nil
+}
+
+func (s Uint256) MarshalJSON() ([]byte, error) {
+	t, err := s.MarshalText()
+	if err != nil {
+		return nil, err
+	}
+	t = append([]byte{'"'}, t...)
+	t = append(t, '"')
+	return t, nil
+}
+
+func (s Uint256) MarshalText() ([]byte, error) {
+	return []byte(s.String()), nil
+}
+
+type Uint64String uint64
+
+func (s *Uint64String) UnmarshalText(t []byte) error {
+	u, err := strconv.ParseUint(string(t), 10, 64)
+	*s = Uint64String(u)
+	return err
+}
+
+func (s Uint64String) MarshalText() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", s)), nil
+}
+
+type ExecHeaderResponse struct {
+	Version string `json:"version,omitempty"`
+	Data    struct {
+		Signature hexutil.Bytes `json:"signature,omitempty"`
+		Message   *BuilderBid   `json:"message,omitempty"`
+	} `json:"data,omitempty"`
+}
+
+func (ehr *ExecHeaderResponse) ToProto() (*eth.SignedBuilderBid, error) {
+	bb, err := ehr.Data.Message.ToProto()
+	if err != nil {
+		return nil, err
+	}
+	return &eth.SignedBuilderBid{
+		Message:   bb,
+		Signature: ehr.Data.Signature,
+	}, nil
+}
+
+func (bb *BuilderBid) ToProto() (*eth.BuilderBid, error) {
+	header, err := bb.Header.ToProto()
+	if err != nil {
+		return nil, err
+	}
+	return &eth.BuilderBid{
+		Header: header,
+		Value:  bb.Value.SSZBytes(),
+		Pubkey: bb.Pubkey,
+	}, nil
+}
+
+func (h *ExecutionPayloadHeader) ToProto() (*eth.ExecutionPayloadHeader, error) {
+	return &eth.ExecutionPayloadHeader{
+		ParentHash:       h.ParentHash,
+		FeeRecipient:     h.FeeRecipient,
+		StateRoot:        h.StateRoot,
+		ReceiptsRoot:     h.ReceiptsRoot,
+		LogsBloom:        h.LogsBloom,
+		PrevRandao:       h.PrevRandao,
+		BlockNumber:      uint64(h.BlockNumber),
+		GasLimit:         uint64(h.GasLimit),
+		GasUsed:          uint64(h.GasUsed),
+		Timestamp:        uint64(h.Timestamp),
+		ExtraData:        h.ExtraData,
+		BaseFeePerGas:    h.BaseFeePerGas.SSZBytes(),
+		BlockHash:        h.BlockHash,
+		TransactionsRoot: h.TransactionsRoot,
+	}, nil
+}
+
+type BuilderBid struct {
+	Header *ExecutionPayloadHeader `json:"header,omitempty"`
+	Value  Uint256                 `json:"value,omitempty"`
+	Pubkey hexutil.Bytes           `json:"pubkey,omitempty"`
+}
+
+type ExecutionPayloadHeader struct {
+	ParentHash       hexutil.Bytes `json:"parent_hash,omitempty"`
+	FeeRecipient     hexutil.Bytes `json:"fee_recipient,omitempty"`
+	StateRoot        hexutil.Bytes `json:"state_root,omitempty"`
+	ReceiptsRoot     hexutil.Bytes `json:"receipts_root,omitempty"`
+	LogsBloom        hexutil.Bytes `json:"logs_bloom,omitempty"`
+	PrevRandao       hexutil.Bytes `json:"prev_randao,omitempty"`
+	BlockNumber      Uint64String  `json:"block_number,omitempty"`
+	GasLimit         Uint64String  `json:"gas_limit,omitempty"`
+	GasUsed          Uint64String  `json:"gas_used,omitempty"`
+	Timestamp        Uint64String  `json:"timestamp,omitempty"`
+	ExtraData        hexutil.Bytes `json:"extra_data,omitempty"`
+	BaseFeePerGas    Uint256       `json:"base_fee_per_gas,omitempty"`
+	BlockHash        hexutil.Bytes `json:"block_hash,omitempty"`
+	TransactionsRoot hexutil.Bytes `json:"transactions_root,omitempty"`
+	*eth.ExecutionPayloadHeader
+}
+
+func (h *ExecutionPayloadHeader) MarshalJSON() ([]byte, error) {
+	type MarshalCaller ExecutionPayloadHeader
+	return json.Marshal(&MarshalCaller{
+		ParentHash:       h.ExecutionPayloadHeader.ParentHash,
+		FeeRecipient:     h.ExecutionPayloadHeader.FeeRecipient,
+		StateRoot:        h.ExecutionPayloadHeader.StateRoot,
+		ReceiptsRoot:     h.ExecutionPayloadHeader.ReceiptsRoot,
+		LogsBloom:        h.ExecutionPayloadHeader.LogsBloom,
+		PrevRandao:       h.ExecutionPayloadHeader.PrevRandao,
+		BlockNumber:      Uint64String(h.ExecutionPayloadHeader.BlockNumber),
+		GasLimit:         Uint64String(h.ExecutionPayloadHeader.GasLimit),
+		GasUsed:          Uint64String(h.ExecutionPayloadHeader.GasUsed),
+		Timestamp:        Uint64String(h.ExecutionPayloadHeader.Timestamp),
+		ExtraData:        h.ExecutionPayloadHeader.ExtraData,
+		BaseFeePerGas:    sszBytesToUint256(h.ExecutionPayloadHeader.BaseFeePerGas),
+		BlockHash:        h.ExecutionPayloadHeader.BlockHash,
+		TransactionsRoot: h.ExecutionPayloadHeader.TransactionsRoot,
+	})
+}
+
+func (h *ExecutionPayloadHeader) UnmarshalJSON(b []byte) error {
+	type UnmarshalCaller ExecutionPayloadHeader
+	uc := &UnmarshalCaller{}
+	if err := json.Unmarshal(b, uc); err != nil {
+		return err
+	}
+	ep := ExecutionPayloadHeader(*uc)
+	*h = ep
+	var err error
+	h.ExecutionPayloadHeader, err = h.ToProto()
+	return err
+}
+
+type ExecPayloadResponse struct {
+	Version string           `json:"version,omitempty"`
+	Data    ExecutionPayload `json:"data,omitempty"`
+}
+
+type ExecutionPayload struct {
+	ParentHash    hexutil.Bytes   `json:"parent_hash,omitempty"`
+	FeeRecipient  hexutil.Bytes   `json:"fee_recipient,omitempty"`
+	StateRoot     hexutil.Bytes   `json:"state_root,omitempty"`
+	ReceiptsRoot  hexutil.Bytes   `json:"receipts_root,omitempty"`
+	LogsBloom     hexutil.Bytes   `json:"logs_bloom,omitempty"`
+	PrevRandao    hexutil.Bytes   `json:"prev_randao,omitempty"`
+	BlockNumber   Uint64String    `json:"block_number,omitempty"`
+	GasLimit      Uint64String    `json:"gas_limit,omitempty"`
+	GasUsed       Uint64String    `json:"gas_used,omitempty"`
+	Timestamp     Uint64String    `json:"timestamp,omitempty"`
+	ExtraData     hexutil.Bytes   `json:"extra_data,omitempty"`
+	BaseFeePerGas Uint256         `json:"base_fee_per_gas,omitempty"`
+	BlockHash     hexutil.Bytes   `json:"block_hash,omitempty"`
+	Transactions  []hexutil.Bytes `json:"transactions,omitempty"`
+}
+
+func (r *ExecPayloadResponse) ToProto() (*v1.ExecutionPayload, error) {
+	return r.Data.ToProto()
+}
+
+func (p *ExecutionPayload) ToProto() (*v1.ExecutionPayload, error) {
+	txs := make([][]byte, len(p.Transactions))
+	for i := range p.Transactions {
+		txs[i] = p.Transactions[i]
+	}
+	return &v1.ExecutionPayload{
+		ParentHash:    p.ParentHash,
+		FeeRecipient:  p.FeeRecipient,
+		StateRoot:     p.StateRoot,
+		ReceiptsRoot:  p.ReceiptsRoot,
+		LogsBloom:     p.LogsBloom,
+		PrevRandao:    p.PrevRandao,
+		BlockNumber:   uint64(p.BlockNumber),
+		GasLimit:      uint64(p.GasLimit),
+		GasUsed:       uint64(p.GasUsed),
+		Timestamp:     uint64(p.Timestamp),
+		ExtraData:     p.ExtraData,
+		BaseFeePerGas: p.BaseFeePerGas.SSZBytes(),
+		BlockHash:     p.BlockHash,
+		Transactions:  txs,
+	}, nil
+}
+
+type SignedBlindedBeaconBlockBellatrix struct {
+	*eth.SignedBlindedBeaconBlockBellatrix
+}
+
+type BlindedBeaconBlockBellatrix struct {
+	*eth.BlindedBeaconBlockBellatrix
+}
+
+type BlindedBeaconBlockBodyBellatrix struct {
+	*eth.BlindedBeaconBlockBodyBellatrix
+}
+
+func (r *SignedBlindedBeaconBlockBellatrix) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		Message   *BlindedBeaconBlockBellatrix `json:"message,omitempty"`
+		Signature hexutil.Bytes                `json:"signature,omitempty"`
+	}{
+		Message:   &BlindedBeaconBlockBellatrix{r.SignedBlindedBeaconBlockBellatrix.Block},
+		Signature: r.SignedBlindedBeaconBlockBellatrix.Signature,
+	})
+}
+
+func (b *BlindedBeaconBlockBellatrix) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		Slot          string                           `json:"slot"`
+		ProposerIndex string                           `json:"proposer_index,omitempty"`
+		ParentRoot    hexutil.Bytes                    `json:"parent_root,omitempty"`
+		StateRoot     hexutil.Bytes                    `json:"state_root,omitempty"`
+		Body          *BlindedBeaconBlockBodyBellatrix `json:"body,omitempty"`
+	}{
+		Slot:          fmt.Sprintf("%d", b.Slot),
+		ProposerIndex: fmt.Sprintf("%d", b.ProposerIndex),
+		ParentRoot:    b.ParentRoot,
+		StateRoot:     b.StateRoot,
+		Body:          &BlindedBeaconBlockBodyBellatrix{b.BlindedBeaconBlockBellatrix.Body},
+	})
+}
+
+type ProposerSlashing struct {
+	*eth.ProposerSlashing
+}
+
+func (s *ProposerSlashing) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		SignedHeader1 *SignedBeaconBlockHeader `json:"signed_header_1,omitempty"`
+		SignedHeader2 *SignedBeaconBlockHeader `json:"signed_header_2,omitempty"`
+	}{
+		SignedHeader1: &SignedBeaconBlockHeader{s.ProposerSlashing.Header_1},
+		SignedHeader2: &SignedBeaconBlockHeader{s.ProposerSlashing.Header_2},
+	})
+}
+
+type SignedBeaconBlockHeader struct {
+	*eth.SignedBeaconBlockHeader
+}
+
+func (h *SignedBeaconBlockHeader) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		Header    *BeaconBlockHeader `json:"message,omitempty"`
+		Signature hexutil.Bytes      `json:"signature,omitempty"`
+	}{
+		Header:    &BeaconBlockHeader{h.SignedBeaconBlockHeader.Header},
+		Signature: h.SignedBeaconBlockHeader.Signature,
+	})
+}
+
+type BeaconBlockHeader struct {
+	*eth.BeaconBlockHeader
+}
+
+func (h *BeaconBlockHeader) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		Slot          string        `json:"slot,omitempty"`
+		ProposerIndex string        `json:"proposer_index,omitempty"`
+		ParentRoot    hexutil.Bytes `json:"parent_root,omitempty"`
+		StateRoot     hexutil.Bytes `json:"state_root,omitempty"`
+		BodyRoot      hexutil.Bytes `json:"body_root,omitempty"`
+	}{
+		Slot:          fmt.Sprintf("%d", h.BeaconBlockHeader.Slot),
+		ProposerIndex: fmt.Sprintf("%d", h.BeaconBlockHeader.ProposerIndex),
+		ParentRoot:    h.BeaconBlockHeader.ParentRoot,
+		StateRoot:     h.BeaconBlockHeader.StateRoot,
+		BodyRoot:      h.BeaconBlockHeader.BodyRoot,
+	})
+}
+
+type IndexedAttestation struct {
+	*eth.IndexedAttestation
+}
+
+func (a *IndexedAttestation) MarshalJSON() ([]byte, error) {
+	indices := make([]string, len(a.IndexedAttestation.AttestingIndices))
+	for i := range a.IndexedAttestation.AttestingIndices {
+		indices[i] = fmt.Sprintf("%d", a.AttestingIndices[i])
+	}
+	return json.Marshal(struct {
+		AttestingIndices []string         `json:"attesting_indices,omitempty"`
+		Data             *AttestationData `json:"data,omitempty"`
+		Signature        hexutil.Bytes    `json:"signature,omitempty"`
+	}{
+		AttestingIndices: indices,
+		Data:             &AttestationData{a.IndexedAttestation.Data},
+		Signature:        a.IndexedAttestation.Signature,
+	})
+}
+
+type AttesterSlashing struct {
+	*eth.AttesterSlashing
+}
+
+func (s *AttesterSlashing) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		Attestation1 *IndexedAttestation `json:"attestation_1,omitempty"`
+		Attestation2 *IndexedAttestation `json:"attestation_2,omitempty"`
+	}{
+		Attestation1: &IndexedAttestation{s.Attestation_1},
+		Attestation2: &IndexedAttestation{s.Attestation_2},
+	})
+}
+
+type Checkpoint struct {
+	*eth.Checkpoint
+}
+
+func (c *Checkpoint) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		Epoch string        `json:"epoch,omitempty"`
+		Root  hexutil.Bytes `json:"root,omitempty"`
+	}{
+		Epoch: fmt.Sprintf("%d", c.Checkpoint.Epoch),
+		Root:  c.Checkpoint.Root,
+	})
+}
+
+type AttestationData struct {
+	*eth.AttestationData
+}
+
+func (a *AttestationData) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		Slot            string        `json:"slot,omitempty"`
+		Index           string        `json:"index,omitempty"`
+		BeaconBlockRoot hexutil.Bytes `json:"beacon_block_root,omitempty"`
+		Source          *Checkpoint   `json:"source,omitempty"`
+		Target          *Checkpoint   `json:"target,omitempty"`
+	}{
+		Slot:            fmt.Sprintf("%d", a.AttestationData.Slot),
+		Index:           fmt.Sprintf("%d", a.AttestationData.CommitteeIndex),
+		BeaconBlockRoot: a.AttestationData.BeaconBlockRoot,
+		Source:          &Checkpoint{a.AttestationData.Source},
+		Target:          &Checkpoint{a.AttestationData.Target},
+	})
+}
+
+type Attestation struct {
+	*eth.Attestation
+}
+
+func (a *Attestation) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		AggregationBits hexutil.Bytes    `json:"aggregation_bits,omitempty"`
+		Data            *AttestationData `json:"data,omitempty"`
+		Signature       hexutil.Bytes    `json:"signature,omitempty" ssz-size:"96"`
+	}{
+		AggregationBits: hexutil.Bytes(a.Attestation.AggregationBits),
+		Data:            &AttestationData{a.Attestation.Data},
+		Signature:       a.Attestation.Signature,
+	})
+}
+
+type DepositData struct {
+	*eth.Deposit_Data
+}
+
+func (d *DepositData) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		PublicKey             hexutil.Bytes `json:"pubkey,omitempty"`
+		WithdrawalCredentials hexutil.Bytes `json:"withdrawal_credentials,omitempty"`
+		Amount                string        `json:"amount,omitempty"`
+		Signature             hexutil.Bytes `json:"signature,omitempty"`
+	}{
+		PublicKey:             d.PublicKey,
+		WithdrawalCredentials: d.WithdrawalCredentials,
+		Amount:                fmt.Sprintf("%d", d.Amount),
+		Signature:             d.Signature,
+	})
+}
+
+type Deposit struct {
+	*eth.Deposit
+}
+
+func (d *Deposit) MarshalJSON() ([]byte, error) {
+	proof := make([]hexutil.Bytes, len(d.Proof))
+	for i := range d.Proof {
+		proof[i] = d.Proof[i]
+	}
+	return json.Marshal(struct {
+		Proof []hexutil.Bytes `json:"proof"`
+		Data  *DepositData    `json:"data"`
+	}{
+		Proof: proof,
+		Data:  &DepositData{Deposit_Data: d.Deposit.Data},
+	})
+}
+
+type SignedVoluntaryExit struct {
+	*eth.SignedVoluntaryExit
+}
+
+func (sve *SignedVoluntaryExit) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		Message   *VoluntaryExit `json:"message,omitempty"`
+		Signature hexutil.Bytes  `json:"signature,omitempty"`
+	}{
+		Signature: sve.SignedVoluntaryExit.Signature,
+		Message:   &VoluntaryExit{sve.SignedVoluntaryExit.Exit},
+	})
+}
+
+type VoluntaryExit struct {
+	*eth.VoluntaryExit
+}
+
+func (ve *VoluntaryExit) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		Epoch          string `json:"epoch,omitempty"`
+		ValidatorIndex string `json:"validator_index,omitempty"`
+	}{
+		Epoch:          fmt.Sprintf("%d", ve.Epoch),
+		ValidatorIndex: fmt.Sprintf("%d", ve.ValidatorIndex),
+	})
+}
+
+type SyncAggregate struct {
+	*eth.SyncAggregate
+}
+
+func (s *SyncAggregate) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		SyncCommitteeBits      hexutil.Bytes `json:"sync_committee_bits,omitempty"`
+		SyncCommitteeSignature hexutil.Bytes `json:"sync_committee_signature,omitempty"`
+	}{
+		SyncCommitteeBits:      hexutil.Bytes(s.SyncAggregate.SyncCommitteeBits),
+		SyncCommitteeSignature: s.SyncAggregate.SyncCommitteeSignature,
+	})
+}
+
+type Eth1Data struct {
+	*eth.Eth1Data
+}
+
+func (e *Eth1Data) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		DepositRoot  hexutil.Bytes `json:"deposit_root,omitempty"`
+		DepositCount string        `json:"deposit_count,omitempty"`
+		BlockHash    hexutil.Bytes `json:"block_hash,omitempty"`
+	}{
+		DepositRoot:  e.DepositRoot,
+		DepositCount: fmt.Sprintf("%d", e.DepositCount),
+		BlockHash:    e.BlockHash,
+	})
+}
+
+func (b *BlindedBeaconBlockBodyBellatrix) MarshalJSON() ([]byte, error) {
+	sve := make([]*SignedVoluntaryExit, len(b.BlindedBeaconBlockBodyBellatrix.VoluntaryExits))
+	for i := range b.BlindedBeaconBlockBodyBellatrix.VoluntaryExits {
+		sve[i] = &SignedVoluntaryExit{SignedVoluntaryExit: b.BlindedBeaconBlockBodyBellatrix.VoluntaryExits[i]}
+	}
+	deps := make([]*Deposit, len(b.BlindedBeaconBlockBodyBellatrix.Deposits))
+	for i := range b.BlindedBeaconBlockBodyBellatrix.Deposits {
+		deps[i] = &Deposit{Deposit: b.BlindedBeaconBlockBodyBellatrix.Deposits[i]}
+	}
+	atts := make([]*Attestation, len(b.BlindedBeaconBlockBodyBellatrix.Attestations))
+	for i := range b.BlindedBeaconBlockBodyBellatrix.Attestations {
+		atts[i] = &Attestation{Attestation: b.BlindedBeaconBlockBodyBellatrix.Attestations[i]}
+	}
+	atsl := make([]*AttesterSlashing, len(b.BlindedBeaconBlockBodyBellatrix.AttesterSlashings))
+	for i := range b.BlindedBeaconBlockBodyBellatrix.AttesterSlashings {
+		atsl[i] = &AttesterSlashing{AttesterSlashing: b.BlindedBeaconBlockBodyBellatrix.AttesterSlashings[i]}
+	}
+	pros := make([]*ProposerSlashing, len(b.BlindedBeaconBlockBodyBellatrix.ProposerSlashings))
+	for i := range b.BlindedBeaconBlockBodyBellatrix.ProposerSlashings {
+		pros[i] = &ProposerSlashing{ProposerSlashing: b.BlindedBeaconBlockBodyBellatrix.ProposerSlashings[i]}
+	}
+	return json.Marshal(struct {
+		RandaoReveal           hexutil.Bytes           `json:"randao_reveal,omitempty"`
+		Eth1Data               *Eth1Data               `json:"eth1_data,omitempty"`
+		Graffiti               hexutil.Bytes           `json:"graffiti,omitempty"`
+		ProposerSlashings      []*ProposerSlashing     `json:"proposer_slashings,omitempty"`
+		AttesterSlashings      []*AttesterSlashing     `json:"attester_slashings,omitempty"`
+		Attestations           []*Attestation          `json:"attestations,omitempty"`
+		Deposits               []*Deposit              `json:"deposits,omitempty"`
+		VoluntaryExits         []*SignedVoluntaryExit  `json:"voluntary_exits,omitempty"`
+		SyncAggregate          *SyncAggregate          `json:"sync_aggregate,omitempty"`
+		ExecutionPayloadHeader *ExecutionPayloadHeader `json:"execution_payload_header,omitempty"`
+	}{
+		RandaoReveal:           b.RandaoReveal,
+		Eth1Data:               &Eth1Data{b.BlindedBeaconBlockBodyBellatrix.Eth1Data},
+		Graffiti:               b.BlindedBeaconBlockBodyBellatrix.Graffiti,
+		ProposerSlashings:      pros,
+		AttesterSlashings:      atsl,
+		Attestations:           atts,
+		Deposits:               deps,
+		VoluntaryExits:         sve,
+		SyncAggregate:          &SyncAggregate{b.BlindedBeaconBlockBodyBellatrix.SyncAggregate},
+		ExecutionPayloadHeader: &ExecutionPayloadHeader{ExecutionPayloadHeader: b.BlindedBeaconBlockBodyBellatrix.ExecutionPayloadHeader},
+	})
+}

api/client/builder/types_test.go

@@ -0,0 +1,726 @@
+package builder
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"math/big"
+	"os"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/prysmaticlabs/go-bitfield"
+	v1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
+	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/testing/require"
+)
+
+func ezDecode(t *testing.T, s string) []byte {
+	v, err := hexutil.Decode(s)
+	require.NoError(t, err)
+	return v
+}
+
+func TestSignedValidatorRegistration_MarshalJSON(t *testing.T) {
+	svr := &eth.SignedValidatorRegistrationV1{
+		Message: &eth.ValidatorRegistrationV1{
+			FeeRecipient: make([]byte, 20),
+			GasLimit:     0,
+			Timestamp:    0,
+			Pubkey:       make([]byte, 48),
+		},
+		Signature: make([]byte, 96),
+	}
+	je, err := json.Marshal(&SignedValidatorRegistration{SignedValidatorRegistrationV1: svr})
+	require.NoError(t, err)
+	// decode with a struct w/ plain strings so we can check the string encoding of the hex fields
+	un := struct {
+		Message struct {
+			FeeRecipient string `json:"fee_recipient"`
+			Pubkey       string `json:"pubkey"`
+		} `json:"message"`
+		Signature string `json:"signature"`
+	}{}
+	require.NoError(t, json.Unmarshal(je, &un))
+	require.Equal(t, "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", un.Signature)
+	require.Equal(t, "0x0000000000000000000000000000000000000000", un.Message.FeeRecipient)
+	require.Equal(t, "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", un.Message.Pubkey)
+}
+
+var testExampleHeaderResponse = `{
+  "version": "bellatrix",
+  "data": {
+    "message": {
+      "header": {
+        "parent_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "fee_recipient": "0xabcf8e0d4e9587369b2301d0790347320302cc09",
+        "state_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "receipts_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "logs_bloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "prev_randao": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "block_number": "1",
+        "gas_limit": "1",
+        "gas_used": "1",
+        "timestamp": "1",
+        "extra_data": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "base_fee_per_gas": "452312848583266388373324160190187140051835877600158453279131187530910662656",
+        "block_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        "transactions_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"
+      },
+      "value": "652312848583266388373324160190187140051835877600158453279131187530910662656",
+      "pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
+    },
+    "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"
+  }
+}`
+
+func TestExecutionHeaderResponseUnmarshal(t *testing.T) {
+	hr := &ExecHeaderResponse{}
+	require.NoError(t, json.Unmarshal([]byte(testExampleHeaderResponse), hr))
+	cases := []struct {
+		expected string
+		actual   string
+		name     string
+	}{
+		{
+			expected: "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505",
+			actual:   hexutil.Encode(hr.Data.Signature),
+			name:     "Signature",
+		},
+		{
+			expected: "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a",
+			actual:   hexutil.Encode(hr.Data.Message.Pubkey),
+			name:     "ExecHeaderResponse.Pubkey",
+		},
+		{
+			expected: "652312848583266388373324160190187140051835877600158453279131187530910662656",
+			actual:   hr.Data.Message.Value.String(),
+			name:     "ExecHeaderResponse.Value",
+		},
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(hr.Data.Message.Header.ParentHash),
+			name:     "ExecHeaderResponse.ExecutionPayloadHeader.ParentHash",
+		},
+		{
+			expected: "0xabcf8e0d4e9587369b2301d0790347320302cc09",
+			actual:   hexutil.Encode(hr.Data.Message.Header.FeeRecipient),
+			name:     "ExecHeaderResponse.ExecutionPayloadHeader.FeeRecipient",
+		},
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(hr.Data.Message.Header.StateRoot),
+			name:     "ExecHeaderResponse.ExecutionPayloadHeader.StateRoot",
+		},
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(hr.Data.Message.Header.ReceiptsRoot),
+			name:     "ExecHeaderResponse.ExecutionPayloadHeader.ReceiptsRoot",
+		},
+		{
+			expected: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+			actual:   hexutil.Encode(hr.Data.Message.Header.LogsBloom),
+			name:     "ExecHeaderResponse.ExecutionPayloadHeader.LogsBloom",
+		},
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(hr.Data.Message.Header.PrevRandao),
+			name:     "ExecHeaderResponse.ExecutionPayloadHeader.PrevRandao",
+		},
+		{
+			expected: "1",
+			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.BlockNumber),
+			name:     "ExecHeaderResponse.ExecutionPayloadHeader.BlockNumber",
+		},
+		{
+			expected: "1",
+			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.GasLimit),
+			name:     "ExecHeaderResponse.ExecutionPayloadHeader.GasLimit",
+		},
+		{
+			expected: "1",
+			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.GasUsed),
+			name:     "ExecHeaderResponse.ExecutionPayloadHeader.GasUsed",
+		},
+		{
+			expected: "1",
+			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.Timestamp),
+			name:     "ExecHeaderResponse.ExecutionPayloadHeader.Timestamp",
+		},
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(hr.Data.Message.Header.ExtraData),
+			name:     "ExecHeaderResponse.ExecutionPayloadHeader.ExtraData",
+		},
+		{
+			expected: "452312848583266388373324160190187140051835877600158453279131187530910662656",
+			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.BaseFeePerGas),
+			name:     "ExecHeaderResponse.ExecutionPayloadHeader.BaseFeePerGas",
+		},
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(hr.Data.Message.Header.BlockHash),
+			name:     "ExecHeaderResponse.ExecutionPayloadHeader.BlockHash",
+		},
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(hr.Data.Message.Header.TransactionsRoot),
+			name:     "ExecHeaderResponse.ExecutionPayloadHeader.TransactionsRoot",
+		},
+	}
+	for _, c := range cases {
+		require.Equal(t, c.expected, c.actual, fmt.Sprintf("unexpected value for field %s", c.name))
+	}
+}
+
+func TestExecutionHeaderResponseToProto(t *testing.T) {
+	bfpg := stringToUint256("452312848583266388373324160190187140051835877600158453279131187530910662656")
+	v := stringToUint256("652312848583266388373324160190187140051835877600158453279131187530910662656")
+	hr := &ExecHeaderResponse{}
+	require.NoError(t, json.Unmarshal([]byte(testExampleHeaderResponse), hr))
+	p, err := hr.ToProto()
+	require.NoError(t, err)
+	signature, err := hexutil.Decode("0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505")
+	require.NoError(t, err)
+	pubkey, err := hexutil.Decode("0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a")
+	require.NoError(t, err)
+	parentHash, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+	feeRecipient, err := hexutil.Decode("0xabcf8e0d4e9587369b2301d0790347320302cc09")
+	require.NoError(t, err)
+	stateRoot, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+	receiptsRoot, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+	logsBloom, err := hexutil.Decode("0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
+	require.NoError(t, err)
+	prevRandao, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+	extraData, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+	blockHash, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+	txRoot, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+
+	expected := &eth.SignedBuilderBid{
+		Message: &eth.BuilderBid{
+			Header: &eth.ExecutionPayloadHeader{
+				ParentHash:       parentHash,
+				FeeRecipient:     feeRecipient,
+				StateRoot:        stateRoot,
+				ReceiptsRoot:     receiptsRoot,
+				LogsBloom:        logsBloom,
+				PrevRandao:       prevRandao,
+				BlockNumber:      1,
+				GasLimit:         1,
+				GasUsed:          1,
+				Timestamp:        1,
+				ExtraData:        extraData,
+				BaseFeePerGas:    bfpg.SSZBytes(),
+				BlockHash:        blockHash,
+				TransactionsRoot: txRoot,
+			},
+			Value:  v.SSZBytes(),
+			Pubkey: pubkey,
+		},
+		Signature: signature,
+	}
+	require.DeepEqual(t, expected, p)
+}
+
+var testExampleExecutionPayload = `{
+  "version": "bellatrix",
+  "data": {
+    "parent_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+    "fee_recipient": "0xabcf8e0d4e9587369b2301d0790347320302cc09",
+    "state_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+    "receipts_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+    "logs_bloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "prev_randao": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+    "block_number": "1",
+    "gas_limit": "1",
+    "gas_used": "1",
+    "timestamp": "1",
+    "extra_data": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+    "base_fee_per_gas": "452312848583266388373324160190187140051835877600158453279131187530910662656",
+    "block_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+    "transactions": [
+      "0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86"
+    ]
+  }
+}`
+
+func TestExecutionPayloadResponseUnmarshal(t *testing.T) {
+	epr := &ExecPayloadResponse{}
+	require.NoError(t, json.Unmarshal([]byte(testExampleExecutionPayload), epr))
+	cases := []struct {
+		expected string
+		actual   string
+		name     string
+	}{
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(epr.Data.ParentHash),
+			name:     "ExecPayloadResponse.ExecutionPayload.ParentHash",
+		},
+		{
+			expected: "0xabcf8e0d4e9587369b2301d0790347320302cc09",
+			actual:   hexutil.Encode(epr.Data.FeeRecipient),
+			name:     "ExecPayloadResponse.ExecutionPayload.FeeRecipient",
+		},
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(epr.Data.StateRoot),
+			name:     "ExecPayloadResponse.ExecutionPayload.StateRoot",
+		},
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(epr.Data.ReceiptsRoot),
+			name:     "ExecPayloadResponse.ExecutionPayload.ReceiptsRoot",
+		},
+		{
+			expected: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+			actual:   hexutil.Encode(epr.Data.LogsBloom),
+			name:     "ExecPayloadResponse.ExecutionPayload.LogsBloom",
+		},
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(epr.Data.PrevRandao),
+			name:     "ExecPayloadResponse.ExecutionPayload.PrevRandao",
+		},
+		{
+			expected: "1",
+			actual:   fmt.Sprintf("%d", epr.Data.BlockNumber),
+			name:     "ExecPayloadResponse.ExecutionPayload.BlockNumber",
+		},
+		{
+			expected: "1",
+			actual:   fmt.Sprintf("%d", epr.Data.GasLimit),
+			name:     "ExecPayloadResponse.ExecutionPayload.GasLimit",
+		},
+		{
+			expected: "1",
+			actual:   fmt.Sprintf("%d", epr.Data.GasUsed),
+			name:     "ExecPayloadResponse.ExecutionPayload.GasUsed",
+		},
+		{
+			expected: "1",
+			actual:   fmt.Sprintf("%d", epr.Data.Timestamp),
+			name:     "ExecPayloadResponse.ExecutionPayload.Timestamp",
+		},
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(epr.Data.ExtraData),
+			name:     "ExecPayloadResponse.ExecutionPayload.ExtraData",
+		},
+		{
+			expected: "452312848583266388373324160190187140051835877600158453279131187530910662656",
+			actual:   fmt.Sprintf("%d", epr.Data.BaseFeePerGas),
+			name:     "ExecPayloadResponse.ExecutionPayload.BaseFeePerGas",
+		},
+		{
+			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+			actual:   hexutil.Encode(epr.Data.BlockHash),
+			name:     "ExecPayloadResponse.ExecutionPayload.BlockHash",
+		},
+	}
+	for _, c := range cases {
+		require.Equal(t, c.expected, c.actual, fmt.Sprintf("unexpected value for field %s", c.name))
+	}
+	require.Equal(t, 1, len(epr.Data.Transactions))
+	txHash := "0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86"
+	require.Equal(t, txHash, hexutil.Encode(epr.Data.Transactions[0]))
+}
+
+func TestExecutionPayloadResponseToProto(t *testing.T) {
+	hr := &ExecPayloadResponse{}
+	require.NoError(t, json.Unmarshal([]byte(testExampleExecutionPayload), hr))
+	p, err := hr.ToProto()
+	require.NoError(t, err)
+
+	parentHash, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+	feeRecipient, err := hexutil.Decode("0xabcf8e0d4e9587369b2301d0790347320302cc09")
+	require.NoError(t, err)
+	stateRoot, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+	receiptsRoot, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+	logsBloom, err := hexutil.Decode("0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
+	require.NoError(t, err)
+	prevRandao, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+	extraData, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+	blockHash, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
+	require.NoError(t, err)
+
+	tx, err := hexutil.Decode("0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86")
+	require.NoError(t, err)
+	txList := [][]byte{tx}
+
+	bfpg := stringToUint256("452312848583266388373324160190187140051835877600158453279131187530910662656")
+	expected := &v1.ExecutionPayload{
+		ParentHash:    parentHash,
+		FeeRecipient:  feeRecipient,
+		StateRoot:     stateRoot,
+		ReceiptsRoot:  receiptsRoot,
+		LogsBloom:     logsBloom,
+		PrevRandao:    prevRandao,
+		BlockNumber:   1,
+		GasLimit:      1,
+		GasUsed:       1,
+		Timestamp:     1,
+		ExtraData:     extraData,
+		BaseFeePerGas: bfpg.SSZBytes(),
+		BlockHash:     blockHash,
+		Transactions:  txList,
+	}
+	require.DeepEqual(t, expected, p)
+}
+
+func pbEth1Data() *eth.Eth1Data {
+	return &eth.Eth1Data{
+		DepositRoot:  make([]byte, 32),
+		DepositCount: 23,
+		BlockHash:    make([]byte, 32),
+	}
+}
+
+func TestEth1DataMarshal(t *testing.T) {
+	ed := &Eth1Data{
+		Eth1Data: pbEth1Data(),
+	}
+	b, err := json.Marshal(ed)
+	require.NoError(t, err)
+	expected := `{"deposit_root":"0x0000000000000000000000000000000000000000000000000000000000000000","deposit_count":"23","block_hash":"0x0000000000000000000000000000000000000000000000000000000000000000"}`
+	require.Equal(t, expected, string(b))
+}
+
+func pbSyncAggregate() *eth.SyncAggregate {
+	return &eth.SyncAggregate{
+		SyncCommitteeSignature: make([]byte, 48),
+		SyncCommitteeBits:      bitfield.Bitvector512{0x01},
+	}
+}
+
+func TestSyncAggregate_MarshalJSON(t *testing.T) {
+	sa := &SyncAggregate{pbSyncAggregate()}
+	b, err := json.Marshal(sa)
+	require.NoError(t, err)
+	expected := `{"sync_committee_bits":"0x01","sync_committee_signature":"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"}`
+	require.Equal(t, expected, string(b))
+}
+
+func pbDeposit(t *testing.T) *eth.Deposit {
+	return &eth.Deposit{
+		Proof: [][]byte{ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")},
+		Data: &eth.Deposit_Data{
+			PublicKey:             ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"),
+			WithdrawalCredentials: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+			Amount:                1,
+			Signature:             ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+		},
+	}
+}
+
+func TestDeposit_MarshalJSON(t *testing.T) {
+	d := &Deposit{
+		Deposit: pbDeposit(t),
+	}
+	b, err := json.Marshal(d)
+	require.NoError(t, err)
+	expected := `{"proof":["0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"],"data":{"pubkey":"0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a","withdrawal_credentials":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","amount":"1","signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"}}`
+	require.Equal(t, expected, string(b))
+}
+
+func pbSignedVoluntaryExit(t *testing.T) *eth.SignedVoluntaryExit {
+	return &eth.SignedVoluntaryExit{
+		Exit: &eth.VoluntaryExit{
+			Epoch:          1,
+			ValidatorIndex: 1,
+		},
+		Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+	}
+}
+
+func TestVoluntaryExit(t *testing.T) {
+	ve := &SignedVoluntaryExit{
+		SignedVoluntaryExit: pbSignedVoluntaryExit(t),
+	}
+	b, err := json.Marshal(ve)
+	require.NoError(t, err)
+	expected := `{"message":{"epoch":"1","validator_index":"1"},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"}`
+	require.Equal(t, expected, string(b))
+}
+
+func pbAttestation(t *testing.T) *eth.Attestation {
+	return &eth.Attestation{
+		AggregationBits: bitfield.Bitlist{0x01},
+		Data: &eth.AttestationData{
+			Slot:            1,
+			CommitteeIndex:  1,
+			BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+			Source: &eth.Checkpoint{
+				Epoch: 1,
+				Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+			},
+			Target: &eth.Checkpoint{
+				Epoch: 1,
+				Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+			},
+		},
+		Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+	}
+}
+
+func TestAttestationMarshal(t *testing.T) {
+	a := &Attestation{
+		Attestation: pbAttestation(t),
+	}
+	b, err := json.Marshal(a)
+	require.NoError(t, err)
+	expected := `{"aggregation_bits":"0x01","data":{"slot":"1","index":"1","beacon_block_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","source":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},"target":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"}},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"}`
+	require.Equal(t, expected, string(b))
+}
+
+func pbAttesterSlashing(t *testing.T) *eth.AttesterSlashing {
+	return &eth.AttesterSlashing{
+		Attestation_1: &eth.IndexedAttestation{
+			AttestingIndices: []uint64{1},
+			Signature:        ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+			Data: &eth.AttestationData{
+				Slot:            1,
+				CommitteeIndex:  1,
+				BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+				Source: &eth.Checkpoint{
+					Epoch: 1,
+					Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+				},
+				Target: &eth.Checkpoint{
+					Epoch: 1,
+					Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+				},
+			},
+		},
+		Attestation_2: &eth.IndexedAttestation{
+			AttestingIndices: []uint64{1},
+			Signature:        ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+			Data: &eth.AttestationData{
+				Slot:            1,
+				CommitteeIndex:  1,
+				BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+				Source: &eth.Checkpoint{
+					Epoch: 1,
+					Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+				},
+				Target: &eth.Checkpoint{
+					Epoch: 1,
+					Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+				},
+			},
+		},
+	}
+}
+
+func TestAttesterSlashing_MarshalJSON(t *testing.T) {
+	as := &AttesterSlashing{
+		AttesterSlashing: pbAttesterSlashing(t),
+	}
+	b, err := json.Marshal(as)
+	require.NoError(t, err)
+	expected := `{"attestation_1":{"attesting_indices":["1"],"data":{"slot":"1","index":"1","beacon_block_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","source":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},"target":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"}},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"},"attestation_2":{"attesting_indices":["1"],"data":{"slot":"1","index":"1","beacon_block_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","source":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},"target":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"}},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"}}`
+	require.Equal(t, expected, string(b))
+}
+
+func pbProposerSlashing(t *testing.T) *eth.ProposerSlashing {
+	return &eth.ProposerSlashing{
+		Header_1: &eth.SignedBeaconBlockHeader{
+			Header: &eth.BeaconBlockHeader{
+				Slot:          1,
+				ProposerIndex: 1,
+				ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+				StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+				BodyRoot:      ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+			},
+			Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+		},
+		Header_2: &eth.SignedBeaconBlockHeader{
+			Header: &eth.BeaconBlockHeader{
+				Slot:          1,
+				ProposerIndex: 1,
+				ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+				StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+				BodyRoot:      ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+			},
+			Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+		},
+	}
+}
+
+func TestProposerSlashings(t *testing.T) {
+	ps := &ProposerSlashing{ProposerSlashing: pbProposerSlashing(t)}
+	b, err := json.Marshal(ps)
+	require.NoError(t, err)
+	expected := `{"signed_header_1":{"message":{"slot":"1","proposer_index":"1","parent_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","state_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","body_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"},"signed_header_2":{"message":{"slot":"1","proposer_index":"1","parent_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","state_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","body_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"}}`
+	require.Equal(t, expected, string(b))
+}
+
+func pbExecutionPayloadHeader(t *testing.T) *eth.ExecutionPayloadHeader {
+	bfpg := stringToUint256("452312848583266388373324160190187140051835877600158453279131187530910662656")
+	return &eth.ExecutionPayloadHeader{
+		ParentHash:       ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+		FeeRecipient:     ezDecode(t, "0xabcf8e0d4e9587369b2301d0790347320302cc09"),
+		StateRoot:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+		ReceiptsRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+		LogsBloom:        ezDecode(t, "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+		PrevRandao:       ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+		BlockNumber:      1,
+		GasLimit:         1,
+		GasUsed:          1,
+		Timestamp:        1,
+		ExtraData:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+		BaseFeePerGas:    bfpg.SSZBytes(),
+		BlockHash:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+		TransactionsRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+	}
+}
+
+func TestExecutionPayloadHeader_MarshalJSON(t *testing.T) {
+	h := &ExecutionPayloadHeader{
+		ExecutionPayloadHeader: pbExecutionPayloadHeader(t),
+	}
+	b, err := json.Marshal(h)
+	require.NoError(t, err)
+	expected := `{"parent_hash":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","fee_recipient":"0xabcf8e0d4e9587369b2301d0790347320302cc09","state_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","receipts_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","logs_bloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","prev_randao":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","block_number":"1","gas_limit":"1","gas_used":"1","timestamp":"1","extra_data":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","base_fee_per_gas":"452312848583266388373324160190187140051835877600158453279131187530910662656","block_hash":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","transactions_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"}`
+	require.Equal(t, expected, string(b))
+}
+
+var testBuilderBid = `{
+    "version":"bellatrix",
+	"data":{
+		"message":{
+			"header":{
+				"parent_hash":"0xa0513a503d5bd6e89a144c3268e5b7e9da9dbf63df125a360e3950a7d0d67131",
+				"fee_recipient":"0xdfb434922631787e43725c6b926e989875125751",
+				"state_root":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45",
+				"receipts_root":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+				"logs_bloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+				"prev_randao":"0xc2fa210081542a87f334b7b14a2da3275e4b281dd77b007bcfcb10e34c42052e",
+				"block_number":"1",
+				"gas_limit":"10000000",
+				"gas_used":"0",
+				"timestamp":"4660",
+				"extra_data":"0x",
+				"base_fee_per_gas":"7",
+				"block_hash":"0x10746fa06c248e7eacd4ff8ad8b48a826c227387ee31a6aa5eb4d83ddad34f07",
+				"transactions_root":"0x7ffe241ea60187fdb0187bfa22de35d1f9bed7ab061d9401fd47e34a54fbede1"
+			},
+			"value":"452312848583266388373324160190187140051835877600158453279131187530910662656",
+			"pubkey":"0x8645866c95cbc2e08bc77ccad473540eddf4a1f51a2a8edc8d7a673824218f7f68fe565f1ab38dadd5c855b45bbcec95"
+		},
+		"signature":"0x9183ebc1edf9c3ab2bbd7abdc3b59c6b249d6647b5289a97eea36d9d61c47f12e283f64d928b1e7f5b8a5182b714fa921954678ea28ca574f5f232b2f78cf8900915a2993b396e3471e0655291fec143a300d41408f66478c8208e0f9be851dc"
+	}
+}`
+
+func TestBuilderBidUnmarshalUint256(t *testing.T) {
+	base10 := "452312848583266388373324160190187140051835877600158453279131187530910662656"
+	var expectedValue big.Int
+	require.NoError(t, expectedValue.UnmarshalText([]byte(base10)))
+	r := &ExecHeaderResponse{}
+	require.NoError(t, json.Unmarshal([]byte(testBuilderBid), r))
+	//require.Equal(t, expectedValue, r.Data.Message.Value)
+	marshaled := r.Data.Message.Value.String()
+	require.Equal(t, base10, marshaled)
+	require.Equal(t, 0, expectedValue.Cmp(r.Data.Message.Value.Int))
+}
+
+func TestMathBigUnmarshal(t *testing.T) {
+	base10 := "452312848583266388373324160190187140051835877600158453279131187530910662656"
+	var expectedValue big.Int
+	require.NoError(t, expectedValue.UnmarshalText([]byte(base10)))
+	marshaled, err := expectedValue.MarshalText()
+	require.NoError(t, err)
+	require.Equal(t, base10, string(marshaled))
+
+	var u256 Uint256
+	require.NoError(t, u256.UnmarshalText([]byte("452312848583266388373324160190187140051835877600158453279131187530910662656")))
+}
+
+func TestUint256Unmarshal(t *testing.T) {
+	base10 := "452312848583266388373324160190187140051835877600158453279131187530910662656"
+	bi := new(big.Int)
+	bi, ok := bi.SetString(base10, 10)
+	require.Equal(t, true, ok)
+	s := struct {
+		BigNumber Uint256 `json:"big_number"`
+	}{
+		BigNumber: Uint256{Int: bi},
+	}
+	m, err := json.Marshal(s)
+	require.NoError(t, err)
+	expected := `{"big_number":"452312848583266388373324160190187140051835877600158453279131187530910662656"}`
+	require.Equal(t, expected, string(m))
+}
+
+func TestMarshalBlindedBeaconBlockBodyBellatrix(t *testing.T) {
+	expected, err := os.ReadFile("testdata/blinded-block.json")
+	require.NoError(t, err)
+	b := &BlindedBeaconBlockBellatrix{BlindedBeaconBlockBellatrix: &eth.BlindedBeaconBlockBellatrix{
+		Slot:          1,
+		ProposerIndex: 1,
+		ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+		StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
+		Body: &eth.BlindedBeaconBlockBodyBellatrix{
+			RandaoReveal:           ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+			Eth1Data:               pbEth1Data(),
+			Graffiti:               ezDecode(t, "0xdeadbeefc0ffee"),
+			ProposerSlashings:      []*eth.ProposerSlashing{pbProposerSlashing(t)},
+			AttesterSlashings:      []*eth.AttesterSlashing{pbAttesterSlashing(t)},
+			Attestations:           []*eth.Attestation{pbAttestation(t)},
+			Deposits:               []*eth.Deposit{pbDeposit(t)},
+			VoluntaryExits:         []*eth.SignedVoluntaryExit{pbSignedVoluntaryExit(t)},
+			SyncAggregate:          pbSyncAggregate(),
+			ExecutionPayloadHeader: pbExecutionPayloadHeader(t),
+		},
+	}}
+	m, err := json.Marshal(b)
+	require.NoError(t, err)
+	// string error output is easier to deal with
+	// -1 end slice index on expected is to get rid of trailing newline
+	// if you update this fixture and this test breaks, you probably removed the trailing newline
+	require.Equal(t, string(expected[0:len(expected)-1]), string(m))
+}
+
+func TestRoundTripUint256(t *testing.T) {
+	vs := "452312848583266388373324160190187140051835877600158453279131187530910662656"
+	u := stringToUint256(vs)
+	sb := u.SSZBytes()
+	uu := sszBytesToUint256(sb)
+	require.Equal(t, true, bytes.Equal(u.SSZBytes(), uu.SSZBytes()))
+	require.Equal(t, vs, uu.String())
+}
+
+func TestRoundTripProtoUint256(t *testing.T) {
+	h := pbExecutionPayloadHeader(t)
+	h.BaseFeePerGas = []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}
+	hm := &ExecutionPayloadHeader{ExecutionPayloadHeader: h}
+	m, err := json.Marshal(hm)
+	require.NoError(t, err)
+	hu := &ExecutionPayloadHeader{}
+	require.NoError(t, json.Unmarshal(m, hu))
+	hp, err := hu.ToProto()
+	require.NoError(t, err)
+	require.DeepEqual(t, h.BaseFeePerGas, hp.BaseFeePerGas)
+}
+
+func TestExecutionPayloadHeaderRoundtrip(t *testing.T) {
+	expected, err := os.ReadFile("testdata/execution-payload.json")
+	require.NoError(t, err)
+	hu := &ExecutionPayloadHeader{}
+	require.NoError(t, json.Unmarshal(expected, hu))
+	m, err := json.Marshal(hu)
+	require.NoError(t, err)
+	require.DeepEqual(t, string(expected[0:len(expected)-1]), string(m))
+}

beacon-chain/blockchain/BUILD.bazel

@@ -64,6 +64,7 @@ go_library(
         "//config/features: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",

beacon-chain/blockchain/process_block.go

@@ -16,6 +16,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/consensus-types/forks/bellatrix"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
@@ -117,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 {
@@ -130,7 +131,7 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 	if err := s.insertBlockAndAttestationsToForkChoiceStore(ctx, signed.Block(), blockRoot, postState); err != nil {
 		return errors.Wrapf(err, "could not insert block %d to fork choice store", signed.Block().Slot())
 	}
-	s.insertSlashingsToForkChoiceStore(ctx, signed.Block().Body().AttesterSlashings())
+	s.InsertSlashingsToForkChoiceStore(ctx, signed.Block().Body().AttesterSlashings())
 	if isValidPayload {
 		if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, blockRoot); err != nil {
 			return errors.Wrap(err, "could not set optimistic block to valid")
@@ -611,7 +612,7 @@ func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk interfac
 
 // Inserts attester slashing indices to fork choice store.
 // To call this function, it's caller's responsibility to ensure the slashing object is valid.
-func (s *Service) insertSlashingsToForkChoiceStore(ctx context.Context, slashings []*ethpb.AttesterSlashing) {
+func (s *Service) InsertSlashingsToForkChoiceStore(ctx context.Context, slashings []*ethpb.AttesterSlashing) {
 	for _, slashing := range slashings {
 		indices := blocks.SlashableAttesterIndices(slashing)
 		for _, index := range indices {
@@ -688,7 +689,7 @@ func (s *Service) validateMergeTransitionBlock(ctx context.Context, stateVersion
 	if err != nil {
 		return invalidBlock{err}
 	}
-	if blocks.IsEmptyPayload(payload) {
+	if bellatrix.IsEmptyPayload(payload) {
 		return nil
 	}
 

beacon-chain/blockchain/process_block_test.go

@@ -1965,7 +1965,7 @@ func TestService_insertSlashingsToForkChoiceStore(t *testing.T) {
 	b.Block.Body.AttesterSlashings = slashings
 	wb, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
-	service.insertSlashingsToForkChoiceStore(ctx, wb.Block().Body().AttesterSlashings())
+	service.InsertSlashingsToForkChoiceStore(ctx, wb.Block().Body().AttesterSlashings())
 }
 
 func TestOnBlock_ProcessBlocksParallel(t *testing.T) {

beacon-chain/blockchain/receive_block.go

@@ -144,7 +144,7 @@ func (s *Service) HasBlock(ctx context.Context, root [32]byte) bool {
 
 // ReceiveAttesterSlashing receives an attester slashing and inserts it to forkchoice
 func (s *Service) ReceiveAttesterSlashing(ctx context.Context, slashing *ethpb.AttesterSlashing) {
-	s.insertSlashingsToForkChoiceStore(ctx, []*ethpb.AttesterSlashing{slashing})
+	s.InsertSlashingsToForkChoiceStore(ctx, []*ethpb.AttesterSlashing{slashing})
 }
 
 func (s *Service) handlePostBlockOperations(b interfaces.BeaconBlock) error {

beacon-chain/blockchain/service.go

@@ -188,10 +188,16 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 	if err != nil {
 		return errors.Wrap(err, "could not get justified checkpoint")
 	}
+	if justified == nil {
+		return errNilJustifiedCheckpoint
+	}
 	finalized, err := s.cfg.BeaconDB.FinalizedCheckpoint(s.ctx)
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized checkpoint")
 	}
+	if finalized == nil {
+		return errNilFinalizedCheckpoint
+	}
 	s.store = store.New(justified, finalized)
 
 	var forkChoicer f.ForkChoicer

beacon-chain/core/blocks/BUILD.bazel

@@ -31,6 +31,7 @@ go_library(
         "//beacon-chain/state: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",
@@ -40,7 +41,6 @@ go_library(
         "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//encoding/ssz:go_default_library",
         "//math:go_default_library",
         "//network/forks:go_default_library",
         "//proto/engine/v1:go_default_library",
@@ -89,6 +89,7 @@ go_test(
         "//beacon-chain/state/v1: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/core/blocks/payload.go

@@ -7,11 +7,9 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/consensus-types/forks/bellatrix"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/encoding/ssz"
 	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/runtime/version"
@@ -41,7 +39,7 @@ func IsMergeTransitionComplete(st state.BeaconState) (bool, error) {
 	if err != nil {
 		return false, err
 	}
-	return !isEmptyHeader(h), nil
+	return !bellatrix.IsEmptyHeader(h), nil
 }
 
 // IsMergeTransitionBlockUsingPreStatePayloadHeader returns true if the input block is the terminal merge block.
@@ -51,7 +49,7 @@ func IsMergeTransitionBlockUsingPreStatePayloadHeader(h *ethpb.ExecutionPayloadH
 	if h == nil || body == nil {
 		return false, errors.New("nil header or block body")
 	}
-	if !isEmptyHeader(h) {
+	if !bellatrix.IsEmptyHeader(h) {
 		return false, nil
 	}
 	return IsExecutionBlock(body)
@@ -74,7 +72,7 @@ func IsExecutionBlock(body interfaces.BeaconBlockBody) (bool, error) {
 		return false, err
 	default:
 	}
-	return !IsEmptyPayload(payload), nil
+	return !bellatrix.IsEmptyPayload(payload), nil
 }
 
 // IsExecutionEnabled returns true if the beacon chain can begin executing.
@@ -100,7 +98,7 @@ func IsExecutionEnabled(st state.BeaconState, body interfaces.BeaconBlockBody) (
 // IsExecutionEnabledUsingHeader returns true if the execution is enabled using post processed payload header and block body.
 // This is an optimized version of IsExecutionEnabled where beacon state is not required as an argument.
 func IsExecutionEnabledUsingHeader(header *ethpb.ExecutionPayloadHeader, body interfaces.BeaconBlockBody) (bool, error) {
-	if !isEmptyHeader(header) {
+	if !bellatrix.IsEmptyHeader(header) {
 		return true, nil
 	}
 	return IsExecutionBlock(body)
@@ -205,7 +203,7 @@ func ProcessPayload(st state.BeaconState, payload *enginev1.ExecutionPayload) (s
 		return nil, err
 	}
 
-	header, err := PayloadToHeader(payload)
+	header, err := bellatrix.PayloadToHeader(payload)
 	if err != nil {
 		return nil, err
 	}
@@ -215,126 +213,6 @@ func ProcessPayload(st state.BeaconState, payload *enginev1.ExecutionPayload) (s
 	return st, nil
 }
 
-// PayloadToHeader converts `payload` into execution payload header format.
-func PayloadToHeader(payload *enginev1.ExecutionPayload) (*ethpb.ExecutionPayloadHeader, error) {
-	txRoot, err := ssz.TransactionsRoot(payload.Transactions)
-	if err != nil {
-		return nil, err
-	}
-
-	return &ethpb.ExecutionPayloadHeader{
-		ParentHash:       bytesutil.SafeCopyBytes(payload.ParentHash),
-		FeeRecipient:     bytesutil.SafeCopyBytes(payload.FeeRecipient),
-		StateRoot:        bytesutil.SafeCopyBytes(payload.StateRoot),
-		ReceiptsRoot:     bytesutil.SafeCopyBytes(payload.ReceiptsRoot),
-		LogsBloom:        bytesutil.SafeCopyBytes(payload.LogsBloom),
-		PrevRandao:       bytesutil.SafeCopyBytes(payload.PrevRandao),
-		BlockNumber:      payload.BlockNumber,
-		GasLimit:         payload.GasLimit,
-		GasUsed:          payload.GasUsed,
-		Timestamp:        payload.Timestamp,
-		ExtraData:        bytesutil.SafeCopyBytes(payload.ExtraData),
-		BaseFeePerGas:    bytesutil.SafeCopyBytes(payload.BaseFeePerGas),
-		BlockHash:        bytesutil.SafeCopyBytes(payload.BlockHash),
-		TransactionsRoot: txRoot[:],
-	}, nil
-}
-
-func IsEmptyPayload(p *enginev1.ExecutionPayload) bool {
-	if p == nil {
-		return true
-	}
-	if !bytes.Equal(p.ParentHash, make([]byte, fieldparams.RootLength)) {
-		return false
-	}
-	if !bytes.Equal(p.FeeRecipient, make([]byte, fieldparams.FeeRecipientLength)) {
-		return false
-	}
-	if !bytes.Equal(p.StateRoot, make([]byte, fieldparams.RootLength)) {
-		return false
-	}
-	if !bytes.Equal(p.ReceiptsRoot, make([]byte, fieldparams.RootLength)) {
-		return false
-	}
-	if !bytes.Equal(p.LogsBloom, make([]byte, fieldparams.LogsBloomLength)) {
-		return false
-	}
-	if !bytes.Equal(p.PrevRandao, make([]byte, fieldparams.RootLength)) {
-		return false
-	}
-	if !bytes.Equal(p.BaseFeePerGas, make([]byte, fieldparams.RootLength)) {
-		return false
-	}
-	if !bytes.Equal(p.BlockHash, make([]byte, fieldparams.RootLength)) {
-		return false
-	}
-	if len(p.Transactions) != 0 {
-		return false
-	}
-	if len(p.ExtraData) != 0 {
-		return false
-	}
-	if p.BlockNumber != 0 {
-		return false
-	}
-	if p.GasLimit != 0 {
-		return false
-	}
-	if p.GasUsed != 0 {
-		return false
-	}
-	if p.Timestamp != 0 {
-		return false
-	}
-	return true
-}
-
-func isEmptyHeader(h *ethpb.ExecutionPayloadHeader) bool {
-	if !bytes.Equal(h.ParentHash, make([]byte, fieldparams.RootLength)) {
-		return false
-	}
-	if !bytes.Equal(h.FeeRecipient, make([]byte, fieldparams.FeeRecipientLength)) {
-		return false
-	}
-	if !bytes.Equal(h.StateRoot, make([]byte, fieldparams.RootLength)) {
-		return false
-	}
-	if !bytes.Equal(h.ReceiptsRoot, make([]byte, fieldparams.RootLength)) {
-		return false
-	}
-	if !bytes.Equal(h.LogsBloom, make([]byte, fieldparams.LogsBloomLength)) {
-		return false
-	}
-	if !bytes.Equal(h.PrevRandao, make([]byte, fieldparams.RootLength)) {
-		return false
-	}
-	if !bytes.Equal(h.BaseFeePerGas, make([]byte, fieldparams.RootLength)) {
-		return false
-	}
-	if !bytes.Equal(h.BlockHash, make([]byte, fieldparams.RootLength)) {
-		return false
-	}
-	if !bytes.Equal(h.TransactionsRoot, make([]byte, fieldparams.RootLength)) {
-		return false
-	}
-	if len(h.ExtraData) != 0 {
-		return false
-	}
-	if h.BlockNumber != 0 {
-		return false
-	}
-	if h.GasLimit != 0 {
-		return false
-	}
-	if h.GasUsed != 0 {
-		return false
-	}
-	if h.Timestamp != 0 {
-		return false
-	}
-	return true
-}
-
 // ValidatePayloadHeaderWhenMergeCompletes validates the payload header when the merge completes.
 func ValidatePayloadHeaderWhenMergeCompletes(st state.BeaconState, header *ethpb.ExecutionPayloadHeader) error {
 	// Skip validation if the state is not merge compatible.

beacon-chain/core/blocks/payload_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/consensus-types/forks/bellatrix"
 	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/encoding/ssz"
@@ -669,7 +670,7 @@ func Test_ProcessPayload(t *testing.T) {
 				require.Equal(t, tt.err.Error(), err.Error())
 			} else {
 				require.Equal(t, tt.err, err)
-				want, err := blocks.PayloadToHeader(tt.payload)
+				want, err := bellatrix.PayloadToHeader(tt.payload)
 				require.Equal(t, tt.err, err)
 				got, err := st.LatestExecutionPayloadHeader()
 				require.NoError(t, err)
@@ -824,7 +825,7 @@ func Test_ValidatePayloadHeaderWhenMergeCompletes(t *testing.T) {
 
 func Test_PayloadToHeader(t *testing.T) {
 	p := emptyPayload()
-	h, err := blocks.PayloadToHeader(p)
+	h, err := bellatrix.PayloadToHeader(p)
 	require.NoError(t, err)
 	txRoot, err := ssz.TransactionsRoot(p.Transactions)
 	require.NoError(t, err)

beacon-chain/core/validators/BUILD.bazel

@@ -14,6 +14,7 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

beacon-chain/core/validators/validator.go

@@ -13,6 +13,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/params"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	mathutil "github.com/prysmaticlabs/prysm/math"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
@@ -72,7 +73,11 @@ func InitiateValidatorExit(ctx context.Context, s state.BeaconState, idx types.V
 	exitQueueChurn := uint64(0)
 	err = s.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
 		if val.ExitEpoch() == exitQueueEpoch {
-			exitQueueChurn++
+			var mErr error
+			exitQueueChurn, mErr = mathutil.Add64(exitQueueChurn, 1)
+			if mErr != nil {
+				return mErr
+			}
 		}
 		return nil
 	})
@@ -89,10 +94,16 @@ func InitiateValidatorExit(ctx context.Context, s state.BeaconState, idx types.V
 	}
 
 	if exitQueueChurn >= churn {
-		exitQueueEpoch++
+		exitQueueEpoch, err = exitQueueEpoch.SafeAdd(1)
+		if err != nil {
+			return nil, err
+		}
 	}
 	validator.ExitEpoch = exitQueueEpoch
-	validator.WithdrawableEpoch = exitQueueEpoch + params.BeaconConfig().MinValidatorWithdrawabilityDelay
+	validator.WithdrawableEpoch, err = exitQueueEpoch.SafeAddEpoch(params.BeaconConfig().MinValidatorWithdrawabilityDelay)
+	if err != nil {
+		return nil, err
+	}
 	if err := s.UpdateValidatorAtIndex(idx, validator); err != nil {
 		return nil, err
 	}

beacon-chain/core/validators/validator_test.go

@@ -99,6 +99,17 @@ func TestInitiateValidatorExit_ChurnOverflow(t *testing.T) {
 	assert.Equal(t, wantedEpoch, v.ExitEpoch, "Exit epoch did not cover overflow case")
 }
 
+func TestInitiateValidatorExit_WithdrawalOverflows(t *testing.T) {
+	base := &ethpb.BeaconState{Validators: []*ethpb.Validator{
+		{ExitEpoch: params.BeaconConfig().FarFutureEpoch - 1},
+		{EffectiveBalance: params.BeaconConfig().EjectionBalance, ExitEpoch: params.BeaconConfig().FarFutureEpoch},
+	}}
+	state, err := v1.InitializeFromProto(base)
+	require.NoError(t, err)
+	_, err = InitiateValidatorExit(context.Background(), state, 1)
+	require.ErrorContains(t, "addition overflows", err)
+}
+
 func TestSlashValidator_OK(t *testing.T) {
 	validatorCount := 100
 	registry := make([]*ethpb.Validator, 0, validatorCount)

beacon-chain/db/kv/BUILD.bazel

@@ -66,6 +66,7 @@ go_library(
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_prysmaticlabs_prombbolt//:go_default_library",
+        "@com_github_schollz_progressbar_v3//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_etcd_go_bbolt//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",

beacon-chain/db/kv/migration_state_validators.go

@@ -7,10 +7,11 @@ import (
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/golang/snappy"
-	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/config/features"
+	"github.com/prysmaticlabs/prysm/encoding/ssz/detect"
 	"github.com/prysmaticlabs/prysm/monitoring/progress"
 	v1alpha1 "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/schollz/progressbar/v3"
 	bolt "go.etcd.io/bbolt"
 )
 
@@ -83,104 +84,10 @@ func migrateStateValidators(ctx context.Context, db *bolt.DB) error {
 	// prepare the progress bar with the total count of the keys to migrate
 	bar := progress.InitializeProgressBar(len(keys), "Migrating state validators to new schema.")
 
-	batchNo := 0
 	for batchIndex := 0; batchIndex < len(keys); batchIndex += batchSize {
-		if err := db.Update(func(tx *bolt.Tx) error {
-			//create the source and destination buckets
-			stateBkt := tx.Bucket(stateBucket)
-			if stateBkt == nil {
-				return nil
-			}
-			valBkt := tx.Bucket(stateValidatorsBucket)
-			if valBkt == nil {
-				return nil
-			}
-			indexBkt := tx.Bucket(blockRootValidatorHashesBucket)
-			if indexBkt == nil {
-				return nil
-			}
-
-			// migrate the key values for this batch
-			cursor := stateBkt.Cursor()
-			count := 0
-			index := batchIndex
-			for _, v := cursor.Seek(keys[index]); count < batchSize && index < len(keys); _, v = cursor.Next() {
-				enc, err := snappy.Decode(nil, v)
-				if err != nil {
-					return err
-				}
-				switch {
-				case hasAltairKey(enc):
-					protoState := &v1alpha1.BeaconStateAltair{}
-					if err := protoState.UnmarshalSSZ(enc[len(altairKey):]); err != nil {
-						return errors.Wrap(err, "failed to unmarshal encoding for altair")
-					}
-					// no validators in state to migrate
-					if len(protoState.Validators) == 0 {
-						return fmt.Errorf("no validator entries in state key 0x%s", hexutil.Encode(keys[index]))
-					}
-					validatorKeys, insertErr := insertValidatorHashes(ctx, protoState.Validators, valBkt)
-					if insertErr != nil {
-						return insertErr
-					}
-					// add the validator entry keys for a given block root.
-					compValidatorKeys := snappy.Encode(nil, validatorKeys)
-					idxErr := indexBkt.Put(keys[index], compValidatorKeys)
-					if idxErr != nil {
-						return idxErr
-					}
-					// zero the validator entries in BeaconState object .
-					protoState.Validators = make([]*v1alpha1.Validator, 0)
-					rawObj, err := protoState.MarshalSSZ()
-					if err != nil {
-						return err
-					}
-					stateBytes := snappy.Encode(nil, append(altairKey, rawObj...))
-					if stateErr := stateBkt.Put(keys[index], stateBytes); stateErr != nil {
-						return stateErr
-					}
-				default:
-					protoState := &v1alpha1.BeaconState{}
-					if err := protoState.UnmarshalSSZ(enc); err != nil {
-						return errors.Wrap(err, "failed to unmarshal encoding for phase0")
-					}
-					// no validators in state to migrate
-					if len(protoState.Validators) == 0 {
-						return fmt.Errorf("no validator entries in state key 0x%s", hexutil.Encode(keys[index]))
-					}
-					validatorKeys, insertErr := insertValidatorHashes(ctx, protoState.Validators, valBkt)
-					if insertErr != nil {
-						return insertErr
-					}
-					// add the validator entry keys for a given block root.
-					compValidatorKeys := snappy.Encode(nil, validatorKeys)
-					idxErr := indexBkt.Put(keys[index], compValidatorKeys)
-					if idxErr != nil {
-						return idxErr
-					}
-					// zero the validator entries in BeaconState object .
-					protoState.Validators = make([]*v1alpha1.Validator, 0)
-					stateBytes, err := encode(ctx, protoState)
-					if err != nil {
-						return err
-					}
-					if stateErr := stateBkt.Put(keys[index], stateBytes); stateErr != nil {
-						return stateErr
-					}
-				}
-				count++
-				index++
-
-				if barErr := bar.Add(1); barErr != nil {
-					return barErr
-				}
-			}
-
-			return nil
-		}); err != nil {
+		if err := db.Update(performValidatorStateMigration(ctx, bar, batchIndex, keys)); err != nil {
 			return err
 		}
-		batchNo++
 	}
 
 	// set the migration entry to done
@@ -197,6 +104,87 @@ func migrateStateValidators(ctx context.Context, db *bolt.DB) error {
 	return nil
 }
 
+func performValidatorStateMigration(ctx context.Context, bar *progressbar.ProgressBar, batchIndex int, keys [][]byte) func(tx *bolt.Tx) error {
+	return func(tx *bolt.Tx) error {
+		//create the source and destination buckets
+		stateBkt := tx.Bucket(stateBucket)
+		if stateBkt == nil {
+			return nil
+		}
+		valBkt := tx.Bucket(stateValidatorsBucket)
+		if valBkt == nil {
+			return nil
+		}
+		indexBkt := tx.Bucket(blockRootValidatorHashesBucket)
+		if indexBkt == nil {
+			return nil
+		}
+
+		// migrate the key values for this batch
+		cursor := stateBkt.Cursor()
+		count := 0
+		index := batchIndex
+		for _, v := cursor.Seek(keys[index]); count < batchSize && index < len(keys); _, v = cursor.Next() {
+			enc, err := snappy.Decode(nil, v)
+			if err != nil {
+				return err
+			}
+			item := enc
+			if hasAltairKey(item) {
+				item = item[len(altairKey):]
+			}
+			detector, err := detect.FromState(item)
+			if err != nil {
+				return err
+			}
+			beaconState, err := detector.UnmarshalBeaconState(item)
+			if err != nil {
+				return err
+			}
+			// no validators in state to migrate
+			if beaconState.NumValidators() == 0 {
+				return fmt.Errorf("no validator entries in state key 0x%s", hexutil.Encode(keys[index]))
+			}
+			vals := beaconState.Validators()
+			validatorKeys, insertErr := insertValidatorHashes(ctx, vals, valBkt)
+			if insertErr != nil {
+				return insertErr
+			}
+			// add the validator entry keys for a given block root.
+			compValidatorKeys := snappy.Encode(nil, validatorKeys)
+			idxErr := indexBkt.Put(keys[index], compValidatorKeys)
+			if idxErr != nil {
+				return idxErr
+			}
+			// zero the validator entries in BeaconState object .
+			if err := beaconState.SetValidators(make([]*v1alpha1.Validator, 0)); err != nil {
+				return err
+			}
+			rawObj, err := beaconState.MarshalSSZ()
+			if err != nil {
+				return err
+			}
+			var stateBytes []byte
+			if hasAltairKey(enc) {
+				stateBytes = snappy.Encode(nil, append(altairKey, rawObj...))
+			} else {
+				stateBytes = snappy.Encode(nil, rawObj)
+			}
+			if stateErr := stateBkt.Put(keys[index], stateBytes); stateErr != nil {
+				return stateErr
+			}
+			count++
+			index++
+
+			if barErr := bar.Add(1); barErr != nil {
+				return barErr
+			}
+		}
+
+		return nil
+	}
+}
+
 func stateBucketKeys(stateBucket *bolt.Bucket) ([][]byte, error) {
 	var keys [][]byte
 	if err := stateBucket.ForEach(func(pubKey, v []byte) error {

beacon-chain/db/kv/migration_state_validators_test.go

@@ -10,6 +10,7 @@ import (
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	v2 "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
 	"github.com/prysmaticlabs/prysm/config/features"
+	"github.com/prysmaticlabs/prysm/config/params"
 	v1alpha1 "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -291,6 +292,12 @@ func Test_migrateAltairStateValidators(t *testing.T) {
 			vals := validators(10)
 			blockRoot := [32]byte{'A'}
 			st, _ := util.DeterministicGenesisStateAltair(t, 20)
+			err := st.SetFork(&v1alpha1.Fork{
+				PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+				CurrentVersion:  params.BeaconConfig().AltairForkVersion,
+				Epoch:           0,
+			})
+			require.NoError(t, err)
 			assert.NoError(t, st.SetSlot(100))
 			assert.NoError(t, st.SetValidators(vals))
 			assert.NoError(t, dbStore.SaveState(context.Background(), st, blockRoot))

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

@@ -162,25 +162,25 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		//
 		// (A: 30) -> (B: 20) -> (C: 10)
 		//
-		// The boost adds 14 to the weight, so if C is boosted, we would have
+		// The boost adds 8 to the weight, so if C is boosted, we would have
 		//
-		// (A: 44) -> (B: 34) -> (C: 24)
+		// (A: 38) -> (B: 28) -> (C: 18)
 		//
 		// In this case, we have a small fork:
 		//
-		// (A: 54) -> (B: 44) -> (C: 10)
-		//                   \_->(D: 24)
+		// (A: 48) -> (B: 38) -> (C: 10)
+		//                   \_->(D: 18)
 		//
 		// So B has its own weight, 10, and the sum of both C and D. That's why we see weight 54 in the
 		// middle instead of the normal progression of (54 -> 44 -> 24).
 		node1 := f.store.nodeByRoot[indexToHash(1)]
-		require.Equal(t, node1.weight, uint64(54))
+		require.Equal(t, node1.weight, uint64(48))
 		node2 := f.store.nodeByRoot[indexToHash(2)]
-		require.Equal(t, node2.weight, uint64(44))
+		require.Equal(t, node2.weight, uint64(38))
 		node3 := f.store.nodeByRoot[indexToHash(3)]
 		require.Equal(t, node3.weight, uint64(10))
 		node4 := f.store.nodeByRoot[indexToHash(4)]
-		require.Equal(t, node4.weight, uint64(24))
+		require.Equal(t, node4.weight, uint64(18))
 
 		// Regression: process attestations for C, check that it
 		// becomes head, we need two attestations to have C.weight = 30 > 24 = D.weight
@@ -254,6 +254,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		// The maliciously withheld block has one vote.
 		votes := []uint64{1}
 		f.ProcessAttestation(ctx, votes, maliciouslyWithheldBlock, fEpoch)
+		// The honest block has one vote.
+		votes = []uint64{2}
+		f.ProcessAttestation(ctx, votes, honestBlock, fEpoch)
 
 		// Ensure the head is STILL C, the honest block, as the honest block had proposer boost.
 		r, err = f.Head(ctx, zeroHash, balances)
@@ -427,6 +430,8 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, c, r, "Expected C to remain the head")
 
 		// Block D receives the boost.
+		votes = []uint64{2}
+		f.ProcessAttestation(ctx, votes, d, fEpoch)
 		args = &forkchoicetypes.ProposerBoostRootArgs{
 			BlockRoot:       d,
 			BlockSlot:       dSlot,
@@ -536,9 +541,9 @@ func TestForkChoice_computeProposerBoostScore(t *testing.T) {
 		// With a committee size of num validators (64) / slots per epoch (32) == 2.
 		// we then have a committee weight of avg balance * committee size = 10 * 2 = 20.
 		// The score then becomes 10 * PROPOSER_SCORE_BOOST // 100, which is
-		// 20 * 70 / 100 = 14.
+		// 20 * 40 / 100 = 8.
 		score, err := computeProposerBoostScore(validatorBalances)
 		require.NoError(t, err)
-		require.Equal(t, uint64(14), score)
+		require.Equal(t, uint64(8), score)
 	})
 }

beacon-chain/forkchoice/protoarray/proposer_boost_test.go

@@ -163,19 +163,19 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		//
 		// The boost adds 14 to the weight, so if C is boosted, we would have
 		//
-		// (A: 44) -> (B: 34) -> (C: 24)
+		// (A: 38) -> (B: 28) -> (C: 18)
 		//
 		// In this case, we have a small fork:
 		//
-		// (A: 54) -> (B: 44) -> (C: 10)
-		//				    \_->(D: 24)
+		// (A: 48) -> (B: 38) -> (C: 10)
+		//				    \_->(D: 18)
 		//
 		// So B has its own weight, 10, and the sum of both C and D. That's why we see weight 54 in the
-		// middle instead of the normal progression of (54 -> 44 -> 24).
-		require.Equal(t, f.store.nodes[1].weight, uint64(54))
-		require.Equal(t, f.store.nodes[2].weight, uint64(44))
+		// middle instead of the normal progression of (48 -> 38 -> 18).
+		require.Equal(t, f.store.nodes[1].weight, uint64(48))
+		require.Equal(t, f.store.nodes[2].weight, uint64(38))
 		require.Equal(t, f.store.nodes[3].weight, uint64(10))
-		require.Equal(t, f.store.nodes[4].weight, uint64(24))
+		require.Equal(t, f.store.nodes[4].weight, uint64(18))
 
 		// Regression: process attestations for C, check that it
 		// becomes head, we need two attestations to have C.weight = 30 > 24 = D.weight
@@ -248,6 +248,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		// The maliciously withheld block has one vote.
 		votes := []uint64{1}
 		f.ProcessAttestation(ctx, votes, maliciouslyWithheldBlock, fEpoch)
+		// The honest block has one vote.
+		votes = []uint64{2}
+		f.ProcessAttestation(ctx, votes, honestBlock, fEpoch)
 
 		// Ensure the head is STILL C, the honest block, as the honest block had proposer boost.
 		r, err = f.Head(ctx, zeroHash, balances)
@@ -421,6 +424,8 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, c, r, "Expected C to remain the head")
 
 		// Block D receives the boost.
+		votes = []uint64{2}
+		f.ProcessAttestation(ctx, votes, d, fEpoch)
 		args = &forkchoicetypes.ProposerBoostRootArgs{
 			BlockRoot:       d,
 			BlockSlot:       dSlot,
@@ -530,9 +535,9 @@ func TestForkChoice_computeProposerBoostScore(t *testing.T) {
 		// With a committee size of num validators (64) / slots per epoch (32) == 2.
 		// we then have a committee weight of avg balance * committee size = 10 * 2 = 20.
 		// The score then becomes 10 * PROPOSER_SCORE_BOOST // 100, which is
-		// 20 * 70 / 100 = 14.
+		// 20 * 40 / 100 = 8.
 		score, err := computeProposerBoostScore(validatorBalances)
 		require.NoError(t, err)
-		require.Equal(t, uint64(14), score)
+		require.Equal(t, uint64(8), score)
 	})
 }

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/powchain/engine_client.go

@@ -296,7 +296,7 @@ func handleRPCError(err error) error {
 		return nil
 	}
 	if isTimeout(err) {
-		return errors.Wrapf(ErrHTTPTimeout, "%s", err)
+		return ErrHTTPTimeout
 	}
 	e, ok := err.(rpc.Error)
 	if !ok {
@@ -307,7 +307,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 +330,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/metrics.go

@@ -16,14 +16,14 @@ 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},
 		},
 	)

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":
@@ -338,7 +343,7 @@ func TestGetSpec(t *testing.T) {
 		case "INACTIVITY_PENALTY_QUOTIENT_BELLATRIX":
 			assert.Equal(t, "16777216", v)
 		case "PROPOSER_SCORE_BOOST":
-			assert.Equal(t, "70", v)
+			assert.Equal(t, "40", v)
 		case "INTERVALS_PER_SLOT":
 			assert.Equal(t, "3", v)
 		case "SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY":

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/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/service.go

@@ -132,6 +132,8 @@ type Service struct {
 	seenSyncContributionCache        *lru.Cache
 	badBlockCache                    *lru.Cache
 	badBlockLock                     sync.RWMutex
+	syncContributionBitsOverlapLock  sync.RWMutex
+	syncContributionBitsOverlapCache *lru.Cache
 	signatureChan                    chan *signatureVerifier
 }
 
@@ -221,6 +223,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/loader_test.go

@@ -18,7 +18,7 @@ import (
 	"gopkg.in/yaml.v2"
 )
 
-var placeholderFields = []string{"UPDATE_TIMEOUT", "INTERVALS_PER_SLOT"}
+var placeholderFields = []string{"UPDATE_TIMEOUT", "INTERVALS_PER_SLOT", "CAPELLA_FORK_VERSION", "CAPELLA_FORK_EPOCH"}
 
 func TestLoadConfigFile(t *testing.T) {
 	// See https://media.githubusercontent.com/media/ethereum/consensus-spec-tests/master/tests/minimal/config/phase0.yaml

config/params/mainnet_config.go

@@ -113,7 +113,7 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	SafeSlotsToUpdateJustified:       8,
 
 	// Fork choice algorithm constants.
-	ProposerScoreBoost: 70,
+	ProposerScoreBoost: 40,
 	IntervalsPerSlot:   3,
 
 	// Ethereum PoW parameters.
@@ -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,
@@ -200,7 +201,7 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	AltairForkEpoch:      mainnetAltairForkEpoch,
 	BellatrixForkVersion: []byte{2, 0, 0, 0},
 	BellatrixForkEpoch:   mainnetBellatrixForkEpoch,
-	ShardingForkVersion:  []byte{3, 0, 0, 0},
+	ShardingForkVersion:  []byte{4, 0, 0, 0},
 	ShardingForkEpoch:    math.MaxUint64,
 
 	// New values introduced in Altair hard fork 1.

config/params/minimal_config.go

@@ -84,7 +84,7 @@ func MinimalSpecConfig() *BeaconChainConfig {
 	minimalConfig.AltairForkEpoch = math.MaxUint64
 	minimalConfig.BellatrixForkVersion = []byte{2, 0, 0, 1}
 	minimalConfig.BellatrixForkEpoch = math.MaxUint64
-	minimalConfig.ShardingForkVersion = []byte{3, 0, 0, 1}
+	minimalConfig.ShardingForkVersion = []byte{4, 0, 0, 1}
 	minimalConfig.ShardingForkEpoch = math.MaxUint64
 
 	minimalConfig.SyncCommitteeSize = 32

config/params/testdata/e2e_config.yaml

@@ -73,8 +73,8 @@ CHURN_LIMIT_QUOTIENT: 65536
 
 # Fork choice
 # ---------------------------------------------------------------
-# 70%
-PROPOSER_SCORE_BOOST: 70
+# 40%
+PROPOSER_SCORE_BOOST: 40
 
 
 # Deposit contract

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/forks/bellatrix/BUILD.bazel

@@ -0,0 +1,15 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["execution_payload.go"],
+    importpath = "github.com/prysmaticlabs/prysm/consensus-types/forks/bellatrix",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//config/fieldparams:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//encoding/ssz:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+    ],
+)

consensus-types/forks/bellatrix/execution_payload.go

@@ -0,0 +1,131 @@
+package bellatrix
+
+import (
+	"bytes"
+
+	"github.com/prysmaticlabs/prysm/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/encoding/ssz"
+	"github.com/prysmaticlabs/prysm/proto/engine/v1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+)
+
+// PayloadToHeader converts `payload` into execution payload header format.
+func PayloadToHeader(payload *enginev1.ExecutionPayload) (*eth.ExecutionPayloadHeader, error) {
+	txRoot, err := ssz.TransactionsRoot(payload.Transactions)
+	if err != nil {
+		return nil, err
+	}
+
+	return &eth.ExecutionPayloadHeader{
+		ParentHash:       bytesutil.SafeCopyBytes(payload.ParentHash),
+		FeeRecipient:     bytesutil.SafeCopyBytes(payload.FeeRecipient),
+		StateRoot:        bytesutil.SafeCopyBytes(payload.StateRoot),
+		ReceiptsRoot:     bytesutil.SafeCopyBytes(payload.ReceiptsRoot),
+		LogsBloom:        bytesutil.SafeCopyBytes(payload.LogsBloom),
+		PrevRandao:       bytesutil.SafeCopyBytes(payload.PrevRandao),
+		BlockNumber:      payload.BlockNumber,
+		GasLimit:         payload.GasLimit,
+		GasUsed:          payload.GasUsed,
+		Timestamp:        payload.Timestamp,
+		ExtraData:        bytesutil.SafeCopyBytes(payload.ExtraData),
+		BaseFeePerGas:    bytesutil.SafeCopyBytes(payload.BaseFeePerGas),
+		BlockHash:        bytesutil.SafeCopyBytes(payload.BlockHash),
+		TransactionsRoot: txRoot[:],
+	}, nil
+}
+
+func IsEmptyPayload(p *enginev1.ExecutionPayload) bool {
+	if p == nil {
+		return true
+	}
+	if !bytes.Equal(p.ParentHash, make([]byte, field_params.RootLength)) {
+		return false
+	}
+	if !bytes.Equal(p.FeeRecipient, make([]byte, field_params.FeeRecipientLength)) {
+		return false
+	}
+	if !bytes.Equal(p.StateRoot, make([]byte, field_params.RootLength)) {
+		return false
+	}
+	if !bytes.Equal(p.ReceiptsRoot, make([]byte, field_params.RootLength)) {
+		return false
+	}
+	if !bytes.Equal(p.LogsBloom, make([]byte, field_params.LogsBloomLength)) {
+		return false
+	}
+	if !bytes.Equal(p.PrevRandao, make([]byte, field_params.RootLength)) {
+		return false
+	}
+	if !bytes.Equal(p.BaseFeePerGas, make([]byte, field_params.RootLength)) {
+		return false
+	}
+	if !bytes.Equal(p.BlockHash, make([]byte, field_params.RootLength)) {
+		return false
+	}
+	if len(p.Transactions) != 0 {
+		return false
+	}
+	if len(p.ExtraData) != 0 {
+		return false
+	}
+	if p.BlockNumber != 0 {
+		return false
+	}
+	if p.GasLimit != 0 {
+		return false
+	}
+	if p.GasUsed != 0 {
+		return false
+	}
+	if p.Timestamp != 0 {
+		return false
+	}
+	return true
+}
+
+func IsEmptyHeader(h *eth.ExecutionPayloadHeader) bool {
+	if !bytes.Equal(h.ParentHash, make([]byte, field_params.RootLength)) {
+		return false
+	}
+	if !bytes.Equal(h.FeeRecipient, make([]byte, field_params.FeeRecipientLength)) {
+		return false
+	}
+	if !bytes.Equal(h.StateRoot, make([]byte, field_params.RootLength)) {
+		return false
+	}
+	if !bytes.Equal(h.ReceiptsRoot, make([]byte, field_params.RootLength)) {
+		return false
+	}
+	if !bytes.Equal(h.LogsBloom, make([]byte, field_params.LogsBloomLength)) {
+		return false
+	}
+	if !bytes.Equal(h.PrevRandao, make([]byte, field_params.RootLength)) {
+		return false
+	}
+	if !bytes.Equal(h.BaseFeePerGas, make([]byte, field_params.RootLength)) {
+		return false
+	}
+	if !bytes.Equal(h.BlockHash, make([]byte, field_params.RootLength)) {
+		return false
+	}
+	if !bytes.Equal(h.TransactionsRoot, make([]byte, field_params.RootLength)) {
+		return false
+	}
+	if len(h.ExtraData) != 0 {
+		return false
+	}
+	if h.BlockNumber != 0 {
+		return false
+	}
+	if h.GasLimit != 0 {
+		return false
+	}
+	if h.GasUsed != 0 {
+		return false
+	}
+	if h.Timestamp != 0 {
+		return false
+	}
+	return true
+}

container/constraints/BUILD.bazel

@@ -0,0 +1,8 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["constraints.go"],
+    importpath = "github.com/prysmaticlabs/prysm/container/constraints",
+    visibility = ["//visibility:public"],
+)

container/constraints/constraints.go

@@ -0,0 +1,46 @@
+// Package constraints defines a set of useful constraints to be used
+// with type parameters.
+package constraints
+
+// Signed is a constraint that permits any signed integer type.
+// If future releases of Go add new predeclared signed integer types,
+// this constraint will be modified to include them.
+type Signed interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64
+}
+
+// Unsigned is a constraint that permits any unsigned integer type.
+// If future releases of Go add new predeclared unsigned integer types,
+// this constraint will be modified to include them.
+type Unsigned interface {
+	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
+}
+
+// Integer is a constraint that permits any integer type.
+// If future releases of Go add new predeclared integer types,
+// this constraint will be modified to include them.
+type Integer interface {
+	Signed | Unsigned
+}
+
+// Float is a constraint that permits any floating-point type.
+// If future releases of Go add new predeclared floating-point types,
+// this constraint will be modified to include them.
+type Float interface {
+	~float32 | ~float64
+}
+
+// Complex is a constraint that permits any complex numeric type.
+// If future releases of Go add new predeclared complex numeric types,
+// this constraint will be modified to include them.
+type Complex interface {
+	~complex64 | ~complex128
+}
+
+// Ordered is a constraint that permits any ordered type: any type
+// that supports the operators < <= >= >.
+// If future releases of Go add new ordered types,
+// this constraint will be modified to include them.
+type Ordered interface {
+	Integer | Float | ~string
+}

container/slice/BUILD.bazel

@@ -8,7 +8,10 @@ go_library(
     ],
     importpath = "github.com/prysmaticlabs/prysm/container/slice",
     visibility = ["//visibility:public"],
-    deps = ["//consensus-types/primitives:go_default_library"],
+    deps = [
+        "//consensus-types/primitives:go_default_library",
+        "//container/constraints:go_default_library",
+    ],
 )
 
 go_test(
@@ -18,5 +21,6 @@ go_test(
     deps = [
         ":go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//crypto/rand:go_default_library",
     ],
 )

container/slice/slice.go

@@ -4,8 +4,150 @@ import (
 	"strings"
 
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/container/constraints"
 )
 
+// Subset returns true if the first slice is
+// completely contained in the second slice with time
+// complexity of approximately o(n).
+func Subset[T constraints.Ordered](a, b []T) bool {
+	if len(a) > len(b) {
+		return false
+	}
+
+	set := make(map[T]uint64, len(b))
+	for _, v := range b {
+		set[v]++
+	}
+
+	for _, v := range a {
+		if count, found := set[v]; !found {
+			return false
+		} else if count < 1 {
+			return false
+		} else {
+			set[v] = count - 1
+		}
+	}
+	return true
+}
+
+// Intersection of any number of slices with time
+// complexity of approximately O(n) leveraging a map to
+// check for element existence off by a constant factor
+// of underlying map efficiency.
+func Intersection[T constraints.Ordered](s ...[]T) []T {
+	if len(s) == 0 {
+		return []T{}
+	}
+	if len(s) == 1 {
+		return s[0]
+	}
+	intersect := make([]T, 0)
+	m := make(map[T]int)
+	for _, k := range s[0] {
+		m[k] = 1
+	}
+	for i, num := 1, len(s); i < num; i++ {
+		for _, k := range s[i] {
+			// Increment and check only if item is present in both, and no increment has happened yet.
+			if _, found := m[k]; found && i == m[k] {
+				m[k]++
+				if m[k] == num {
+					intersect = append(intersect, k)
+				}
+			}
+		}
+	}
+	return intersect
+}
+
+// Union of any number of uint64 slices with time
+// complexity of approximately O(n) leveraging a map to
+// check for element existence off by a constant factor
+// of underlying map efficiency.
+func Union[T constraints.Ordered](s ...[]T) []T {
+	if len(s) == 0 {
+		return []T{}
+	}
+	if len(s) == 1 {
+		return s[0]
+	}
+	set := s[0]
+	m := make(map[T]bool)
+	for i := 1; i < len(s); i++ {
+		a := s[i-1]
+		b := s[i]
+		for j := 0; j < len(a); j++ {
+			m[a[j]] = true
+		}
+		for j := 0; j < len(b); j++ {
+			if _, found := m[b[j]]; !found {
+				set = append(set, b[j])
+			}
+		}
+	}
+	return set
+}
+
+// Uniq returns a slice with only unique
+// values from the provided list of indices.
+func Uniq[T constraints.Ordered](a []T) []T {
+	// Remove duplicates indices.
+	intMap := map[T]bool{}
+	cleanedIndices := make([]T, 0, len(a))
+	for _, idx := range a {
+		if intMap[idx] {
+			continue
+		}
+		intMap[idx] = true
+		cleanedIndices = append(cleanedIndices, idx)
+	}
+	return cleanedIndices
+}
+
+// IsSorted verifies if a slice is sorted in ascending order.
+func IsSorted[T constraints.Ordered](a []T) bool {
+	if len(a) == 0 || len(a) == 1 {
+		return true
+	}
+	for i := 1; i < len(a); i++ {
+		if a[i-1] > a[i] {
+			return false
+		}
+	}
+	return true
+}
+
+// NotIn returns the items in slice b that are
+// not in slice a with time complexity of approximately
+// O(n) leveraging a map to check for element existence
+// off by a constant factor of underlying map efficiency.
+func NotIn[T constraints.Ordered](a, b []T) []T {
+	set := make([]T, 0)
+	m := make(map[T]bool)
+
+	for i := 0; i < len(a); i++ {
+		m[a[i]] = true
+	}
+	for i := 0; i < len(b); i++ {
+		if _, found := m[b[i]]; !found {
+			set = append(set, b[i])
+		}
+	}
+	return set
+}
+
+// IsIn returns true if a is in b and False otherwise.
+func IsIn[T constraints.Ordered](a T, b []T) bool {
+	for _, v := range b {
+		if a == v {
+			return true
+		}
+	}
+	return false
+}
+
 // SubsetUint64 returns true if the first array is
 // completely contained in the second array with time
 // complexity of approximately o(n).

container/slice/slice_test.go

@@ -7,9 +7,10 @@ import (
 
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/container/slice"
+	"github.com/prysmaticlabs/prysm/crypto/rand"
 )
 
-func TestSubsetUint64(t *testing.T) {
+func TestSubset(t *testing.T) {
 	testCases := []struct {
 		setA []uint64
 		setB []uint64
@@ -30,7 +31,28 @@ func TestSubsetUint64(t *testing.T) {
 	}
 }
 
-func TestIntersectionUint64(t *testing.T) {
+func TestSubset_Generic(t *testing.T) {
+	testCases := []struct {
+		setA []uint64
+		setB []uint64
+		out  bool
+	}{
+		{[]uint64{1}, []uint64{1, 2, 3, 4}, true},
+		{[]uint64{1, 2, 3, 4}, []uint64{1, 2, 3, 4}, true},
+		{[]uint64{1, 1}, []uint64{1, 2, 3, 4}, false},
+		{[]uint64{}, []uint64{1}, true},
+		{[]uint64{1}, []uint64{}, false},
+		{[]uint64{1, 2, 3, 4, 5}, []uint64{1, 2, 3, 4}, false},
+	}
+	for _, tt := range testCases {
+		result := slice.Subset[uint64](tt.setA, tt.setB)
+		if result != tt.out {
+			t.Errorf("%v, got %v, want %v", tt.setA, result, tt.out)
+		}
+	}
+}
+
+func TestIntersection(t *testing.T) {
 	testCases := []struct {
 		setA []uint64
 		setB []uint64
@@ -76,7 +98,53 @@ func TestIntersectionUint64(t *testing.T) {
 	}
 }
 
-func TestIsSortedUint64(t *testing.T) {
+func TestIntersection_Generic(t *testing.T) {
+	testCases := []struct {
+		setA []uint64
+		setB []uint64
+		setC []uint64
+		out  []uint64
+	}{
+		{[]uint64{2, 3, 5}, []uint64{3}, []uint64{3}, []uint64{3}},
+		{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{5}, []uint64{5}},
+		{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{3, 5}, []uint64{3, 5}},
+		{[]uint64{2, 3, 5}, []uint64{5, 3, 2}, []uint64{3, 2, 5}, []uint64{2, 3, 5}},
+		{[]uint64{3, 2, 5}, []uint64{5, 3, 2}, []uint64{3, 2, 5}, []uint64{2, 3, 5}},
+		{[]uint64{3, 3, 5}, []uint64{5, 3, 2}, []uint64{3, 2, 5}, []uint64{3, 5}},
+		{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
+		{[]uint64{2, 3, 5}, []uint64{}, []uint64{}, []uint64{}},
+		{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{}, []uint64{}},
+		{[]uint64{2, 3}, []uint64{2, 3, 5}, []uint64{5}, []uint64{}},
+		{[]uint64{2, 2, 2}, []uint64{2, 2, 2}, []uint64{}, []uint64{}},
+		{[]uint64{}, []uint64{2, 3, 5}, []uint64{}, []uint64{}},
+		{[]uint64{}, []uint64{}, []uint64{}, []uint64{}},
+		{[]uint64{1}, []uint64{1}, []uint64{}, []uint64{}},
+		{[]uint64{1, 1, 1}, []uint64{1, 1}, []uint64{1, 2, 3}, []uint64{1}},
+	}
+	for _, tt := range testCases {
+		setA := append([]uint64{}, tt.setA...)
+		setB := append([]uint64{}, tt.setB...)
+		setC := append([]uint64{}, tt.setC...)
+		result := slice.Intersection[uint64](setA, setB, setC)
+		sort.Slice(result, func(i, j int) bool {
+			return result[i] < result[j]
+		})
+		if !reflect.DeepEqual(result, tt.out) {
+			t.Errorf("got %d, want %d", result, tt.out)
+		}
+		if !reflect.DeepEqual(setA, tt.setA) {
+			t.Errorf("slice modified, got %v, want %v", setA, tt.setA)
+		}
+		if !reflect.DeepEqual(setB, tt.setB) {
+			t.Errorf("slice modified, got %v, want %v", setB, tt.setB)
+		}
+		if !reflect.DeepEqual(setC, tt.setC) {
+			t.Errorf("slice modified, got %v, want %v", setC, tt.setC)
+		}
+	}
+}
+
+func TestIsSorted(t *testing.T) {
 	testCases := []struct {
 		setA []uint64
 		out  bool
@@ -94,6 +162,24 @@ func TestIsSortedUint64(t *testing.T) {
 	}
 }
 
+func TestIsSorted_Generic(t *testing.T) {
+	testCases := []struct {
+		setA []uint64
+		out  bool
+	}{
+		{[]uint64{1, 2, 3}, true},
+		{[]uint64{3, 1, 3}, false},
+		{[]uint64{1}, true},
+		{[]uint64{}, true},
+	}
+	for _, tt := range testCases {
+		result := slice.IsSorted[uint64](tt.setA)
+		if result != tt.out {
+			t.Errorf("got %v, want %v", result, tt.out)
+		}
+	}
+}
+
 func TestIntersectionInt64(t *testing.T) {
 	testCases := []struct {
 		setA []int64
@@ -205,6 +291,39 @@ func TestUnionInt64(t *testing.T) {
 	}
 }
 
+func TestUnion_Generic(t *testing.T) {
+	testCases := []struct {
+		setA []uint64
+		setB []uint64
+		out  []uint64
+	}{
+		{[]uint64{2, 3, 5}, []uint64{4, 6}, []uint64{2, 3, 5, 4, 6}},
+		{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{2, 3, 5}},
+		{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
+		{[]uint64{2, 3, 5}, []uint64{}, []uint64{2, 3, 5}},
+		{[]uint64{}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
+		{[]uint64{}, []uint64{}, []uint64{}},
+		{[]uint64{1}, []uint64{1}, []uint64{1}},
+	}
+	for _, tt := range testCases {
+		result := slice.Union[uint64](tt.setA, tt.setB)
+		if !reflect.DeepEqual(result, tt.out) {
+			t.Errorf("got %d, want %d", result, tt.out)
+		}
+
+	}
+	items := [][]uint64{
+		{3, 4, 5},
+		{6, 7, 8},
+		{9, 10, 11},
+	}
+	variadicResult := slice.Union[uint64](items...)
+	want := []uint64{3, 4, 5, 6, 7, 8, 9, 10, 11}
+	if !reflect.DeepEqual(want, variadicResult) {
+		t.Errorf("Received %v, wanted %v", variadicResult, want)
+	}
+}
+
 func TestCleanUint64(t *testing.T) {
 	testCases := []struct {
 		in  []uint64
@@ -225,6 +344,26 @@ func TestCleanUint64(t *testing.T) {
 	}
 }
 
+func TestUniq_Generic(t *testing.T) {
+	testCases := []struct {
+		in  []uint64
+		out []uint64
+	}{
+		{[]uint64{2, 4, 4, 6, 6}, []uint64{2, 4, 6}},
+		{[]uint64{3, 5, 5}, []uint64{3, 5}},
+		{[]uint64{2, 2, 2}, []uint64{2}},
+		{[]uint64{1, 4, 5, 9, 9}, []uint64{1, 4, 5, 9}},
+		{[]uint64{}, []uint64{}},
+		{[]uint64{1}, []uint64{1}},
+	}
+	for _, tt := range testCases {
+		result := slice.Uniq[uint64](tt.in)
+		if !reflect.DeepEqual(result, tt.out) {
+			t.Errorf("got %d, want %d", result, tt.out)
+		}
+	}
+}
+
 func TestNotUint64(t *testing.T) {
 	testCases := []struct {
 		setA []uint64
@@ -247,6 +386,28 @@ func TestNotUint64(t *testing.T) {
 	}
 }
 
+func TestNotIn_Generic(t *testing.T) {
+	testCases := []struct {
+		setA []uint64
+		setB []uint64
+		out  []uint64
+	}{
+		{[]uint64{4, 6}, []uint64{2, 3, 5, 4, 6}, []uint64{2, 3, 5}},
+		{[]uint64{3, 5}, []uint64{2, 3, 5}, []uint64{2}},
+		{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{}},
+		{[]uint64{2}, []uint64{2, 3, 5}, []uint64{3, 5}},
+		{[]uint64{}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
+		{[]uint64{}, []uint64{}, []uint64{}},
+		{[]uint64{1}, []uint64{1}, []uint64{}},
+	}
+	for _, tt := range testCases {
+		result := slice.NotIn[uint64](tt.setA, tt.setB)
+		if !reflect.DeepEqual(result, tt.out) {
+			t.Errorf("got %d, want %d", result, tt.out)
+		}
+	}
+}
+
 func TestNotInt64(t *testing.T) {
 	testCases := []struct {
 		setA []int64
@@ -309,6 +470,26 @@ func TestIsInInt64(t *testing.T) {
 	}
 }
 
+func TestIsIn_Generic(t *testing.T) {
+	testCases := []struct {
+		a      uint64
+		b      []uint64
+		result bool
+	}{
+		{0, []uint64{}, false},
+		{0, []uint64{0}, true},
+		{4, []uint64{2, 3, 5, 4, 6}, true},
+		{100, []uint64{2, 3, 5, 4, 6}, false},
+	}
+	for _, tt := range testCases {
+		result := slice.IsIn[uint64](tt.a, tt.b)
+		if result != tt.result {
+			t.Errorf("IsIn(%d, %v)=%v, wanted: %v",
+				tt.a, tt.b, result, tt.result)
+		}
+	}
+}
+
 func TestUnionByteSlices(t *testing.T) {
 	testCases := []struct {
 		setA [][]byte
@@ -587,3 +768,81 @@ func TestIsInSlots(t *testing.T) {
 		}
 	}
 }
+
+func BenchmarkIntersection_Specific(b *testing.B) {
+	b.StopTimer()
+	sets := setupSlices()
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		slice.IntersectionUint64(sets...)
+	}
+}
+
+func BenchmarkIntersection_Generic(b *testing.B) {
+	b.StopTimer()
+	sets := setupSlices()
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		slice.Intersection[uint64](sets...)
+	}
+}
+
+func BenchmarkUnion_Specific(b *testing.B) {
+	b.StopTimer()
+	sets := setupSlices()
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		slice.UnionUint64(sets...)
+	}
+}
+
+func BenchmarkUnion_Generic(b *testing.B) {
+	b.StopTimer()
+	sets := setupSlices()
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		slice.Union[uint64](sets...)
+	}
+}
+
+func BenchmarkUniq_Specific(b *testing.B) {
+	b.StopTimer()
+	input := make([]uint64, 0, 1000)
+	gen := rand.NewGenerator()
+	for i := 0; i < 1000; i++ {
+		n := gen.Uint64()
+		input = append(input, n, n)
+	}
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		slice.SetUint64(input)
+	}
+}
+
+func BenchmarkUniq_Generic(b *testing.B) {
+	b.StopTimer()
+	input := make([]uint64, 0, 1000)
+	gen := rand.NewGenerator()
+	for i := 0; i < 1000; i++ {
+		n := gen.Uint64()
+		input = append(input, n, n)
+	}
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		slice.Uniq[uint64](input)
+	}
+}
+
+func setupSlices() [][]uint64 {
+	sets := make([][]uint64, 1000)
+	gen := rand.NewGenerator()
+	for i := 0; i < len(sets); i++ {
+		setSize := gen.Intn(100)
+		set := make([]uint64, setSize)
+		for j := 0; j < setSize; j++ {
+			set[j] = uint64(j)
+		}
+		sets[i] = set
+	}
+	return sets
+}

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/prysm/v1alpha1/beacon_block.pb.go

@@ -1970,6 +1970,250 @@ func (x *ExecutionPayloadHeader) GetTransactionsRoot() []byte {
 	return nil
 }
 
+type ValidatorRegistrationV1 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	FeeRecipient []byte `protobuf:"bytes,1,opt,name=fee_recipient,json=feeRecipient,proto3" json:"fee_recipient,omitempty" ssz-size:"20"`
+	GasLimit     uint64 `protobuf:"varint,2,opt,name=gas_limit,json=gasLimit,proto3" json:"gas_limit,omitempty"`
+	Timestamp    uint64 `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
+	Pubkey       []byte `protobuf:"bytes,4,opt,name=pubkey,proto3" json:"pubkey,omitempty" ssz-size:"48"`
+}
+
+func (x *ValidatorRegistrationV1) Reset() {
+	*x = ValidatorRegistrationV1{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ValidatorRegistrationV1) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ValidatorRegistrationV1) ProtoMessage() {}
+
+func (x *ValidatorRegistrationV1) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[25]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ValidatorRegistrationV1.ProtoReflect.Descriptor instead.
+func (*ValidatorRegistrationV1) Descriptor() ([]byte, []int) {
+	return file_proto_prysm_v1alpha1_beacon_block_proto_rawDescGZIP(), []int{25}
+}
+
+func (x *ValidatorRegistrationV1) GetFeeRecipient() []byte {
+	if x != nil {
+		return x.FeeRecipient
+	}
+	return nil
+}
+
+func (x *ValidatorRegistrationV1) GetGasLimit() uint64 {
+	if x != nil {
+		return x.GasLimit
+	}
+	return 0
+}
+
+func (x *ValidatorRegistrationV1) GetTimestamp() uint64 {
+	if x != nil {
+		return x.Timestamp
+	}
+	return 0
+}
+
+func (x *ValidatorRegistrationV1) GetPubkey() []byte {
+	if x != nil {
+		return x.Pubkey
+	}
+	return nil
+}
+
+type SignedValidatorRegistrationV1 struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Message   *ValidatorRegistrationV1 `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
+	Signature []byte                   `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty" ssz-size:"96"`
+}
+
+func (x *SignedValidatorRegistrationV1) Reset() {
+	*x = SignedValidatorRegistrationV1{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[26]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SignedValidatorRegistrationV1) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SignedValidatorRegistrationV1) ProtoMessage() {}
+
+func (x *SignedValidatorRegistrationV1) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[26]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SignedValidatorRegistrationV1.ProtoReflect.Descriptor instead.
+func (*SignedValidatorRegistrationV1) Descriptor() ([]byte, []int) {
+	return file_proto_prysm_v1alpha1_beacon_block_proto_rawDescGZIP(), []int{26}
+}
+
+func (x *SignedValidatorRegistrationV1) GetMessage() *ValidatorRegistrationV1 {
+	if x != nil {
+		return x.Message
+	}
+	return nil
+}
+
+func (x *SignedValidatorRegistrationV1) GetSignature() []byte {
+	if x != nil {
+		return x.Signature
+	}
+	return nil
+}
+
+type BuilderBid struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Header *ExecutionPayloadHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
+	Value  []byte                  `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty" ssz-size:"32"`
+	Pubkey []byte                  `protobuf:"bytes,3,opt,name=pubkey,proto3" json:"pubkey,omitempty" ssz-size:"48"`
+}
+
+func (x *BuilderBid) Reset() {
+	*x = BuilderBid{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[27]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *BuilderBid) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BuilderBid) ProtoMessage() {}
+
+func (x *BuilderBid) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[27]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use BuilderBid.ProtoReflect.Descriptor instead.
+func (*BuilderBid) Descriptor() ([]byte, []int) {
+	return file_proto_prysm_v1alpha1_beacon_block_proto_rawDescGZIP(), []int{27}
+}
+
+func (x *BuilderBid) GetHeader() *ExecutionPayloadHeader {
+	if x != nil {
+		return x.Header
+	}
+	return nil
+}
+
+func (x *BuilderBid) GetValue() []byte {
+	if x != nil {
+		return x.Value
+	}
+	return nil
+}
+
+func (x *BuilderBid) GetPubkey() []byte {
+	if x != nil {
+		return x.Pubkey
+	}
+	return nil
+}
+
+type SignedBuilderBid struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Message   *BuilderBid `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
+	Signature []byte      `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty" ssz-size:"96"`
+}
+
+func (x *SignedBuilderBid) Reset() {
+	*x = SignedBuilderBid{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[28]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SignedBuilderBid) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SignedBuilderBid) ProtoMessage() {}
+
+func (x *SignedBuilderBid) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[28]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SignedBuilderBid.ProtoReflect.Descriptor instead.
+func (*SignedBuilderBid) Descriptor() ([]byte, []int) {
+	return file_proto_prysm_v1alpha1_beacon_block_proto_rawDescGZIP(), []int{28}
+}
+
+func (x *SignedBuilderBid) GetMessage() *BuilderBid {
+	if x != nil {
+		return x.Message
+	}
+	return nil
+}
+
+func (x *SignedBuilderBid) GetSignature() []byte {
+	if x != nil {
+		return x.Signature
+	}
+	return nil
+}
+
 type Deposit_Data struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -1984,7 +2228,7 @@ type Deposit_Data struct {
 func (x *Deposit_Data) Reset() {
 	*x = Deposit_Data{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[25]
+		mi := &file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[29]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1997,7 +2241,7 @@ func (x *Deposit_Data) String() string {
 func (*Deposit_Data) ProtoMessage() {}
 
 func (x *Deposit_Data) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[25]
+	mi := &file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[29]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2562,17 +2806,53 @@ var file_proto_prysm_v1alpha1_beacon_block_proto_rawDesc = []byte{
 	0x0a, 0x11, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x72,
 	0x6f, 0x6f, 0x74, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33,
 	0x32, 0x52, 0x10, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52,
-	0x6f, 0x6f, 0x74, 0x42, 0x98, 0x01, 0x0a, 0x19, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65,
-	0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
-	0x31, 0x42, 0x10, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x50, 0x72,
-	0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x37, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f,
-	0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f,
-	0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x72, 0x79, 0x73,
-	0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x3b, 0x65, 0x74, 0x68, 0xaa, 0x02,
-	0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e, 0x76, 0x31,
-	0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xca, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75,
-	0x6d, 0x5c, 0x45, 0x74, 0x68, 0x5c, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62, 0x06,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x6f, 0x6f, 0x74, 0x22, 0xa1, 0x01, 0x0a, 0x17, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f,
+	0x72, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x31, 0x12,
+	0x2b, 0x0a, 0x0d, 0x66, 0x65, 0x65, 0x5f, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x32, 0x30, 0x52, 0x0c,
+	0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x09,
+	0x67, 0x61, 0x73, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52,
+	0x08, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d,
+	0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x74, 0x69,
+	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x1e, 0x0a, 0x06, 0x70, 0x75, 0x62, 0x6b, 0x65,
+	0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x34, 0x38, 0x52,
+	0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x8f, 0x01, 0x0a, 0x1d, 0x53, 0x69, 0x67, 0x6e,
+	0x65, 0x64, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x67, 0x69, 0x73,
+	0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x31, 0x12, 0x48, 0x0a, 0x07, 0x6d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x65, 0x74, 0x68,
+	0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
+	0x61, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x67, 0x69,
+	0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x31, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x12, 0x24, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x39, 0x36, 0x52, 0x09,
+	0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x91, 0x01, 0x0a, 0x0a, 0x42, 0x75,
+	0x69, 0x6c, 0x64, 0x65, 0x72, 0x42, 0x69, 0x64, 0x12, 0x45, 0x0a, 0x06, 0x68, 0x65, 0x61, 0x64,
+	0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72,
+	0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
+	0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61,
+	0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12,
+	0x1c, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06,
+	0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1e, 0x0a,
+	0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a,
+	0xb5, 0x18, 0x02, 0x34, 0x38, 0x52, 0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x75, 0x0a,
+	0x10, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x42, 0x69,
+	0x64, 0x12, 0x3b, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x21, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74,
+	0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x42, 0x75, 0x69, 0x6c, 0x64,
+	0x65, 0x72, 0x42, 0x69, 0x64, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x24,
+	0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x39, 0x36, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61,
+	0x74, 0x75, 0x72, 0x65, 0x42, 0x98, 0x01, 0x0a, 0x19, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68,
+	0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
+	0x61, 0x31, 0x42, 0x10, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x50,
+	0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x37, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63,
+	0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73,
+	0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x72, 0x79,
+	0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x3b, 0x65, 0x74, 0x68, 0xaa,
+	0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e, 0x76,
+	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xca, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65,
+	0x75, 0x6d, 0x5c, 0x45, 0x74, 0x68, 0x5c, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62,
+	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -2587,7 +2867,7 @@ func file_proto_prysm_v1alpha1_beacon_block_proto_rawDescGZIP() []byte {
 	return file_proto_prysm_v1alpha1_beacon_block_proto_rawDescData
 }
 
-var file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes = make([]protoimpl.MessageInfo, 26)
+var file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes = make([]protoimpl.MessageInfo, 30)
 var file_proto_prysm_v1alpha1_beacon_block_proto_goTypes = []interface{}{
 	(*GenericSignedBeaconBlock)(nil),          // 0: ethereum.eth.v1alpha1.GenericSignedBeaconBlock
 	(*GenericBeaconBlock)(nil),                // 1: ethereum.eth.v1alpha1.GenericBeaconBlock
@@ -2614,10 +2894,14 @@ var file_proto_prysm_v1alpha1_beacon_block_proto_goTypes = []interface{}{
 	(*BlindedBeaconBlockBellatrix)(nil),       // 22: ethereum.eth.v1alpha1.BlindedBeaconBlockBellatrix
 	(*BlindedBeaconBlockBodyBellatrix)(nil),   // 23: ethereum.eth.v1alpha1.BlindedBeaconBlockBodyBellatrix
 	(*ExecutionPayloadHeader)(nil),            // 24: ethereum.eth.v1alpha1.ExecutionPayloadHeader
-	(*Deposit_Data)(nil),                      // 25: ethereum.eth.v1alpha1.Deposit.Data
-	(*Attestation)(nil),                       // 26: ethereum.eth.v1alpha1.Attestation
-	(*AttestationData)(nil),                   // 27: ethereum.eth.v1alpha1.AttestationData
-	(*v1.ExecutionPayload)(nil),               // 28: ethereum.engine.v1.ExecutionPayload
+	(*ValidatorRegistrationV1)(nil),           // 25: ethereum.eth.v1alpha1.ValidatorRegistrationV1
+	(*SignedValidatorRegistrationV1)(nil),     // 26: ethereum.eth.v1alpha1.SignedValidatorRegistrationV1
+	(*BuilderBid)(nil),                        // 27: ethereum.eth.v1alpha1.BuilderBid
+	(*SignedBuilderBid)(nil),                  // 28: ethereum.eth.v1alpha1.SignedBuilderBid
+	(*Deposit_Data)(nil),                      // 29: ethereum.eth.v1alpha1.Deposit.Data
+	(*Attestation)(nil),                       // 30: ethereum.eth.v1alpha1.Attestation
+	(*AttestationData)(nil),                   // 31: ethereum.eth.v1alpha1.AttestationData
+	(*v1.ExecutionPayload)(nil),               // 32: ethereum.engine.v1.ExecutionPayload
 }
 var file_proto_prysm_v1alpha1_beacon_block_proto_depIdxs = []int32{
 	3,  // 0: ethereum.eth.v1alpha1.GenericSignedBeaconBlock.phase0:type_name -> ethereum.eth.v1alpha1.SignedBeaconBlock
@@ -2635,13 +2919,13 @@ var file_proto_prysm_v1alpha1_beacon_block_proto_depIdxs = []int32{
 	13, // 12: ethereum.eth.v1alpha1.BeaconBlockBody.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
 	8,  // 13: ethereum.eth.v1alpha1.BeaconBlockBody.proposer_slashings:type_name -> ethereum.eth.v1alpha1.ProposerSlashing
 	9,  // 14: ethereum.eth.v1alpha1.BeaconBlockBody.attester_slashings:type_name -> ethereum.eth.v1alpha1.AttesterSlashing
-	26, // 15: ethereum.eth.v1alpha1.BeaconBlockBody.attestations:type_name -> ethereum.eth.v1alpha1.Attestation
+	30, // 15: ethereum.eth.v1alpha1.BeaconBlockBody.attestations:type_name -> ethereum.eth.v1alpha1.Attestation
 	10, // 16: ethereum.eth.v1alpha1.BeaconBlockBody.deposits:type_name -> ethereum.eth.v1alpha1.Deposit
 	12, // 17: ethereum.eth.v1alpha1.BeaconBlockBody.voluntary_exits:type_name -> ethereum.eth.v1alpha1.SignedVoluntaryExit
 	13, // 18: ethereum.eth.v1alpha1.BeaconBlockBodyAltair.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
 	8,  // 19: ethereum.eth.v1alpha1.BeaconBlockBodyAltair.proposer_slashings:type_name -> ethereum.eth.v1alpha1.ProposerSlashing
 	9,  // 20: ethereum.eth.v1alpha1.BeaconBlockBodyAltair.attester_slashings:type_name -> ethereum.eth.v1alpha1.AttesterSlashing
-	26, // 21: ethereum.eth.v1alpha1.BeaconBlockBodyAltair.attestations:type_name -> ethereum.eth.v1alpha1.Attestation
+	30, // 21: ethereum.eth.v1alpha1.BeaconBlockBodyAltair.attestations:type_name -> ethereum.eth.v1alpha1.Attestation
 	10, // 22: ethereum.eth.v1alpha1.BeaconBlockBodyAltair.deposits:type_name -> ethereum.eth.v1alpha1.Deposit
 	12, // 23: ethereum.eth.v1alpha1.BeaconBlockBodyAltair.voluntary_exits:type_name -> ethereum.eth.v1alpha1.SignedVoluntaryExit
 	17, // 24: ethereum.eth.v1alpha1.BeaconBlockBodyAltair.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
@@ -2649,35 +2933,38 @@ var file_proto_prysm_v1alpha1_beacon_block_proto_depIdxs = []int32{
 	15, // 26: ethereum.eth.v1alpha1.ProposerSlashing.header_2:type_name -> ethereum.eth.v1alpha1.SignedBeaconBlockHeader
 	16, // 27: ethereum.eth.v1alpha1.AttesterSlashing.attestation_1:type_name -> ethereum.eth.v1alpha1.IndexedAttestation
 	16, // 28: ethereum.eth.v1alpha1.AttesterSlashing.attestation_2:type_name -> ethereum.eth.v1alpha1.IndexedAttestation
-	25, // 29: ethereum.eth.v1alpha1.Deposit.data:type_name -> ethereum.eth.v1alpha1.Deposit.Data
+	29, // 29: ethereum.eth.v1alpha1.Deposit.data:type_name -> ethereum.eth.v1alpha1.Deposit.Data
 	11, // 30: ethereum.eth.v1alpha1.SignedVoluntaryExit.exit:type_name -> ethereum.eth.v1alpha1.VoluntaryExit
 	14, // 31: ethereum.eth.v1alpha1.SignedBeaconBlockHeader.header:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
-	27, // 32: ethereum.eth.v1alpha1.IndexedAttestation.data:type_name -> ethereum.eth.v1alpha1.AttestationData
+	31, // 32: ethereum.eth.v1alpha1.IndexedAttestation.data:type_name -> ethereum.eth.v1alpha1.AttestationData
 	19, // 33: ethereum.eth.v1alpha1.SignedBeaconBlockBellatrix.block:type_name -> ethereum.eth.v1alpha1.BeaconBlockBellatrix
 	20, // 34: ethereum.eth.v1alpha1.BeaconBlockBellatrix.body:type_name -> ethereum.eth.v1alpha1.BeaconBlockBodyBellatrix
 	13, // 35: ethereum.eth.v1alpha1.BeaconBlockBodyBellatrix.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
 	8,  // 36: ethereum.eth.v1alpha1.BeaconBlockBodyBellatrix.proposer_slashings:type_name -> ethereum.eth.v1alpha1.ProposerSlashing
 	9,  // 37: ethereum.eth.v1alpha1.BeaconBlockBodyBellatrix.attester_slashings:type_name -> ethereum.eth.v1alpha1.AttesterSlashing
-	26, // 38: ethereum.eth.v1alpha1.BeaconBlockBodyBellatrix.attestations:type_name -> ethereum.eth.v1alpha1.Attestation
+	30, // 38: ethereum.eth.v1alpha1.BeaconBlockBodyBellatrix.attestations:type_name -> ethereum.eth.v1alpha1.Attestation
 	10, // 39: ethereum.eth.v1alpha1.BeaconBlockBodyBellatrix.deposits:type_name -> ethereum.eth.v1alpha1.Deposit
 	12, // 40: ethereum.eth.v1alpha1.BeaconBlockBodyBellatrix.voluntary_exits:type_name -> ethereum.eth.v1alpha1.SignedVoluntaryExit
 	17, // 41: ethereum.eth.v1alpha1.BeaconBlockBodyBellatrix.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
-	28, // 42: ethereum.eth.v1alpha1.BeaconBlockBodyBellatrix.execution_payload:type_name -> ethereum.engine.v1.ExecutionPayload
+	32, // 42: ethereum.eth.v1alpha1.BeaconBlockBodyBellatrix.execution_payload:type_name -> ethereum.engine.v1.ExecutionPayload
 	22, // 43: ethereum.eth.v1alpha1.SignedBlindedBeaconBlockBellatrix.block:type_name -> ethereum.eth.v1alpha1.BlindedBeaconBlockBellatrix
 	23, // 44: ethereum.eth.v1alpha1.BlindedBeaconBlockBellatrix.body:type_name -> ethereum.eth.v1alpha1.BlindedBeaconBlockBodyBellatrix
 	13, // 45: ethereum.eth.v1alpha1.BlindedBeaconBlockBodyBellatrix.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
 	8,  // 46: ethereum.eth.v1alpha1.BlindedBeaconBlockBodyBellatrix.proposer_slashings:type_name -> ethereum.eth.v1alpha1.ProposerSlashing
 	9,  // 47: ethereum.eth.v1alpha1.BlindedBeaconBlockBodyBellatrix.attester_slashings:type_name -> ethereum.eth.v1alpha1.AttesterSlashing
-	26, // 48: ethereum.eth.v1alpha1.BlindedBeaconBlockBodyBellatrix.attestations:type_name -> ethereum.eth.v1alpha1.Attestation
+	30, // 48: ethereum.eth.v1alpha1.BlindedBeaconBlockBodyBellatrix.attestations:type_name -> ethereum.eth.v1alpha1.Attestation
 	10, // 49: ethereum.eth.v1alpha1.BlindedBeaconBlockBodyBellatrix.deposits:type_name -> ethereum.eth.v1alpha1.Deposit
 	12, // 50: ethereum.eth.v1alpha1.BlindedBeaconBlockBodyBellatrix.voluntary_exits:type_name -> ethereum.eth.v1alpha1.SignedVoluntaryExit
 	17, // 51: ethereum.eth.v1alpha1.BlindedBeaconBlockBodyBellatrix.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
 	24, // 52: ethereum.eth.v1alpha1.BlindedBeaconBlockBodyBellatrix.execution_payload_header:type_name -> ethereum.eth.v1alpha1.ExecutionPayloadHeader
-	53, // [53:53] is the sub-list for method output_type
-	53, // [53:53] is the sub-list for method input_type
-	53, // [53:53] is the sub-list for extension type_name
-	53, // [53:53] is the sub-list for extension extendee
-	0,  // [0:53] is the sub-list for field type_name
+	25, // 53: ethereum.eth.v1alpha1.SignedValidatorRegistrationV1.message:type_name -> ethereum.eth.v1alpha1.ValidatorRegistrationV1
+	24, // 54: ethereum.eth.v1alpha1.BuilderBid.header:type_name -> ethereum.eth.v1alpha1.ExecutionPayloadHeader
+	27, // 55: ethereum.eth.v1alpha1.SignedBuilderBid.message:type_name -> ethereum.eth.v1alpha1.BuilderBid
+	56, // [56:56] is the sub-list for method output_type
+	56, // [56:56] is the sub-list for method input_type
+	56, // [56:56] is the sub-list for extension type_name
+	56, // [56:56] is the sub-list for extension extendee
+	0,  // [0:56] is the sub-list for field type_name
 }
 
 func init() { file_proto_prysm_v1alpha1_beacon_block_proto_init() }
@@ -2988,6 +3275,54 @@ func file_proto_prysm_v1alpha1_beacon_block_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ValidatorRegistrationV1); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*SignedValidatorRegistrationV1); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*BuilderBid); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*SignedBuilderBid); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*Deposit_Data); i {
 			case 0:
 				return &v.state
@@ -3018,7 +3353,7 @@ func file_proto_prysm_v1alpha1_beacon_block_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_proto_prysm_v1alpha1_beacon_block_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   26,
+			NumMessages:   30,
 			NumExtensions: 0,
 			NumServices:   0,
 		},

proto/prysm/v1alpha1/beacon_block.proto

@@ -439,3 +439,26 @@ message ExecutionPayloadHeader {
     bytes block_hash = 13 [(ethereum.eth.ext.ssz_size) = "32"];
     bytes transactions_root = 14 [(ethereum.eth.ext.ssz_size) = "32"];
 }
+
+message ValidatorRegistrationV1 {
+    bytes fee_recipient         = 1 [(ethereum.eth.ext.ssz_size) = "20"];
+    uint64 gas_limit             = 2;
+    uint64 timestamp            = 3;
+    bytes pubkey      = 4 [(ethereum.eth.ext.ssz_size) = "48"];
+}
+
+message SignedValidatorRegistrationV1 {
+    ValidatorRegistrationV1 message         = 1 ;
+    bytes signature      = 2 [(ethereum.eth.ext.ssz_size) = "96"];
+}
+
+message BuilderBid {
+    ExecutionPayloadHeader header         = 1 ;
+    bytes value = 2 [(ethereum.eth.ext.ssz_size) = "32"];
+    bytes pubkey      = 3 [(ethereum.eth.ext.ssz_size) = "48"];
+}
+
+message SignedBuilderBid {
+    BuilderBid message         = 1 ;
+    bytes signature      = 2 [(ethereum.eth.ext.ssz_size) = "96"];
+}

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/altair/epoch_processing/registry_updates.go

@@ -27,8 +27,6 @@ func RunRegistryUpdatesTests(t *testing.T, config string) {
 	}
 }
 
-func processRegistryUpdatesWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) {
-	state, err := epoch.ProcessRegistryUpdates(context.Background(), state)
-	require.NoError(t, err, "Could not process registry updates")
-	return state, nil
+func processRegistryUpdatesWrapper(_ *testing.T, state state.BeaconState) (state.BeaconState, error) {
+	return epoch.ProcessRegistryUpdates(context.Background(), state)
 }

testing/spectest/shared/bellatrix/epoch_processing/registry_updates.go

@@ -27,8 +27,6 @@ func RunRegistryUpdatesTests(t *testing.T, config string) {
 	}
 }
 
-func processRegistryUpdatesWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) {
-	state, err := epoch.ProcessRegistryUpdates(context.Background(), state)
-	require.NoError(t, err, "Could not process registry updates")
-	return state, nil
+func processRegistryUpdatesWrapper(_ *testing.T, state state.BeaconState) (state.BeaconState, error) {
+	return epoch.ProcessRegistryUpdates(context.Background(), state)
 }

testing/spectest/shared/common/forkchoice/BUILD.bazel

@@ -17,6 +17,7 @@ go_library(
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/cache/depositcache:go_default_library",
         "//beacon-chain/core/time:go_default_library",
+        "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/forkchoice/protoarray:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",

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

@@ -84,6 +84,12 @@ func (bb *Builder) Attestation(t testing.TB, a *ethpb.Attestation) {
 	require.NoError(t, bb.service.OnAttestation(context.TODO(), a))
 }
 
+// AttesterSlashing receives an attester slashing and feeds it to forkchoice.
+func (bb *Builder) AttesterSlashing(s *ethpb.AttesterSlashing) {
+	slashings := []*ethpb.AttesterSlashing{s}
+	bb.service.InsertSlashingsToForkChoiceStore(context.TODO(), slashings)
+}
+
 // Check evaluates the fork choice results and compares them to the expected values.
 func (bb *Builder) Check(t testing.TB, c *Check) {
 	if c == nil {

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

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/golang/snappy"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	v2 "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
@@ -20,6 +21,10 @@ import (
 	"github.com/prysmaticlabs/prysm/testing/util"
 )
 
+func init() {
+	transition.SkipSlotCache.Disable()
+}
+
 // Run executes "forkchoice" test.
 func Run(t *testing.T, config string, fork int) {
 	require.NoError(t, utils.SetConfig(t, config))
@@ -90,6 +95,15 @@ func Run(t *testing.T, config string, fork int) {
 							builder.ValidBlock(t, beaconBlock)
 						}
 					}
+					if step.AttesterSlashing != nil {
+						slashingFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), fmt.Sprint(*step.AttesterSlashing, ".ssz_snappy"))
+						require.NoError(t, err)
+						slashingSSZ, err := snappy.Decode(nil /* dst */, slashingFile)
+						require.NoError(t, err)
+						slashing := &ethpb.AttesterSlashing{}
+						require.NoError(t, slashing.UnmarshalSSZ(slashingSSZ), "Failed to unmarshal")
+						builder.AttesterSlashing(slashing)
+					}
 					if step.Attestation != nil {
 						attFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), fmt.Sprint(*step.Attestation, ".ssz_snappy"))
 						require.NoError(t, err)

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

@@ -1,12 +1,13 @@
 package forkchoice
 
 type Step struct {
-	Tick        *int    `json:"tick"`
-	Block       *string `json:"block"`
-	Valid       *bool   `json:"valid"`
-	Attestation *string `json:"attestation"`
-	PowBlock    *string `json:"pow_block"`
-	Check       *Check  `json:"checks"`
+	Tick             *int    `json:"tick"`
+	Block            *string `json:"block"`
+	Valid            *bool   `json:"valid"`
+	Attestation      *string `json:"attestation"`
+	AttesterSlashing *string `json:"attester_slashing"`
+	PowBlock         *string `json:"pow_block"`
+	Check            *Check  `json:"checks"`
 }
 
 type Check struct {

testing/spectest/shared/phase0/epoch_processing/registry_updates.go

@@ -27,8 +27,6 @@ func RunRegistryUpdatesTests(t *testing.T, config string) {
 	}
 }
 
-func processRegistryUpdatesWrapper(t *testing.T, state state.BeaconState) (state.BeaconState, error) {
-	state, err := epoch.ProcessRegistryUpdates(context.Background(), state)
-	require.NoError(t, err, "Could not process registry updates")
-	return state, nil
+func processRegistryUpdatesWrapper(_ *testing.T, state state.BeaconState) (state.BeaconState, error) {
+	return epoch.ProcessRegistryUpdates(context.Background(), state)
 }

time/slots/BUILD.bazel

@@ -12,8 +12,8 @@ go_library(
     deps = [
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//math:go_default_library",
         "//time:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/math:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],

time/slots/slottime.go

@@ -5,10 +5,10 @@ import (
 	"math"
 	"time"
 
-	commonMath "github.com/ethereum/go-ethereum/common/math"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/config/params"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	mathutil "github.com/prysmaticlabs/prysm/math"
 	prysmTime "github.com/prysmaticlabs/prysm/time"
 )
 
@@ -222,9 +222,9 @@ func SyncCommitteePeriod(e types.Epoch) uint64 {
 // SyncCommitteePeriodStartEpoch returns the start epoch of a sync committee period.
 func SyncCommitteePeriodStartEpoch(e types.Epoch) (types.Epoch, error) {
 	// Overflow is impossible here because of division of `EPOCHS_PER_SYNC_COMMITTEE_PERIOD`.
-	startEpoch, overflow := commonMath.SafeMul(SyncCommitteePeriod(e), uint64(params.BeaconConfig().EpochsPerSyncCommitteePeriod))
-	if overflow {
-		return 0, errors.New("start epoch calculation overflow")
+	startEpoch, err := mathutil.Mul64(SyncCommitteePeriod(e), uint64(params.BeaconConfig().EpochsPerSyncCommitteePeriod))
+	if err != nil {
+		return 0, err
 	}
 	return types.Epoch(startEpoch), 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 {