move stuff to blinded_blocks.go

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

@@ -4,14 +4,20 @@ import (
 	"context"
 
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v3/encoding/ssz/detect"
+	"github.com/prysmaticlabs/prysm/v3/network/forks"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v3/proto/eth/v1"
 	ethpbv2 "github.com/prysmaticlabs/prysm/v3/proto/eth/v2"
 	"github.com/prysmaticlabs/prysm/v3/proto/migration"
+	eth "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
 	"go.opencensus.io/trace"
 	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/status"
+	"google.golang.org/protobuf/types/known/emptypb"
 )
 
 // GetBlindedBlock retrieves blinded block for given block id.
@@ -108,6 +114,112 @@ func (bs *Server) GetBlindedBlockSSZ(ctx context.Context, req *ethpbv1.BlockRequ
 	return nil, status.Errorf(codes.Internal, "Unknown block type %T", blk)
 }
 
+// SubmitBlindedBlock instructs the beacon node to use the components of the `SignedBlindedBeaconBlock` to construct
+// and publish a `SignedBeaconBlock` by swapping out the `transactions_root` for the corresponding full list of `transactions`.
+// The beacon node should broadcast a newly constructed `SignedBeaconBlock` to the beacon network,
+// to be included in the beacon chain. The beacon node is not required to validate the signed
+// `BeaconBlock`, and a successful response (20X) only indicates that the broadcast has been
+// successful. The beacon node is expected to integrate the new block into its state, and
+// therefore validate the block internally, however blocks which fail the validation are still
+// broadcast but a different status code is returned (202).
+func (bs *Server) SubmitBlindedBlock(ctx context.Context, req *ethpbv2.SignedBlindedBeaconBlockContainer) (*emptypb.Empty, error) {
+	ctx, span := trace.StartSpan(ctx, "beacon.SubmitBlindedBlock")
+	defer span.End()
+
+	capellaBlkContainer, ok := req.Message.(*ethpbv2.SignedBlindedBeaconBlockContainer_CapellaBlock)
+	if ok {
+		if err := bs.submitBlindedCapellaBlock(ctx, capellaBlkContainer.CapellaBlock, req.Signature); err != nil {
+			return nil, err
+		}
+	}
+
+	bellatrixBlkContainer, ok := req.Message.(*ethpbv2.SignedBlindedBeaconBlockContainer_BellatrixBlock)
+	if ok {
+		if err := bs.submitBlindedBellatrixBlock(ctx, bellatrixBlkContainer.BellatrixBlock, req.Signature); err != nil {
+			return nil, err
+		}
+	}
+
+	// At the end we check forks that don't have blinded blocks.
+	phase0BlkContainer, ok := req.Message.(*ethpbv2.SignedBlindedBeaconBlockContainer_Phase0Block)
+	if ok {
+		if err := bs.submitPhase0Block(ctx, phase0BlkContainer.Phase0Block, req.Signature); err != nil {
+			return nil, err
+		}
+	}
+	altairBlkContainer, ok := req.Message.(*ethpbv2.SignedBlindedBeaconBlockContainer_AltairBlock)
+	if ok {
+		if err := bs.submitAltairBlock(ctx, altairBlkContainer.AltairBlock, req.Signature); err != nil {
+			return nil, err
+		}
+	}
+
+	return &emptypb.Empty{}, nil
+}
+
+// SubmitBlindedBlockSSZ instructs the beacon node to use the components of the `SignedBlindedBeaconBlock` to construct
+// and publish a `SignedBeaconBlock` by swapping out the `transactions_root` for the corresponding full list of `transactions`.
+// The beacon node should broadcast a newly constructed `SignedBeaconBlock` to the beacon network,
+// to be included in the beacon chain. The beacon node is not required to validate the signed
+// `BeaconBlock`, and a successful response (20X) only indicates that the broadcast has been
+// successful. The beacon node is expected to integrate the new block into its state, and
+// therefore validate the block internally, however blocks which fail the validation are still
+// broadcast but a different status code is returned (202).
+//
+// The provided block must be SSZ-serialized.
+func (bs *Server) SubmitBlindedBlockSSZ(ctx context.Context, req *ethpbv2.SSZContainer) (*emptypb.Empty, error) {
+	ctx, span := trace.StartSpan(ctx, "beacon.SubmitBlindedBlockSSZ")
+	defer span.End()
+
+	md, ok := metadata.FromIncomingContext(ctx)
+	if !ok {
+		return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not read"+versionHeader+" header")
+	}
+	ver := md.Get(versionHeader)
+	if len(ver) == 0 {
+		return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not read"+versionHeader+" header")
+	}
+	schedule := forks.NewOrderedSchedule(params.BeaconConfig())
+	forkVer, err := schedule.VersionForName(ver[0])
+	if err != nil {
+		return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not determine fork version: %v", err)
+	}
+	unmarshaler, err := detect.FromForkVersion(forkVer)
+	if err != nil {
+		return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not create unmarshaler: %v", err)
+	}
+	block, err := unmarshaler.UnmarshalBlindedBeaconBlock(req.Data)
+	if err != nil {
+		return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not unmarshal request data into block: %v", err)
+	}
+
+	if block.IsBlinded() {
+		b, err := block.PbBlindedBellatrixBlock()
+		if err != nil {
+			b, err := block.PbBlindedCapellaBlock()
+			if err != nil {
+				return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not get blinded block: %v", err)
+			}
+			bb, err := migration.V1Alpha1BeaconBlockBlindedCapellaToV2Blinded(b.Block)
+			if err != nil {
+				return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not migrate block: %v", err)
+			}
+			return &emptypb.Empty{}, bs.submitBlindedCapellaBlock(ctx, bb, b.Signature)
+		}
+		bb, err := migration.V1Alpha1BeaconBlockBlindedBellatrixToV2Blinded(b.Block)
+		if err != nil {
+			return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not migrate block: %v", err)
+		}
+		return &emptypb.Empty{}, bs.submitBlindedBellatrixBlock(ctx, bb, b.Signature)
+	}
+
+	root, err := block.Block().HashTreeRoot()
+	if err != nil {
+		return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not compute block's hash tree root: %v", err)
+	}
+	return &emptypb.Empty{}, bs.submitBlock(ctx, root, block)
+}
+
 func getBlindedBlockPhase0(blk interfaces.SignedBeaconBlock) (*ethpbv2.BlindedBlockResponse, error) {
 	phase0Blk, err := blk.PbPhase0Block()
 	if err != nil {
@@ -442,3 +554,41 @@ func (bs *Server) getBlindedSSZBlockCapella(ctx context.Context, blk interfaces.
 	}
 	return &ethpbv2.SSZContainer{Version: ethpbv2.Version_CAPELLA, ExecutionOptimistic: isOptimistic, Data: sszData}, nil
 }
+
+func (bs *Server) submitBlindedBellatrixBlock(ctx context.Context, blindedBellatrixBlk *ethpbv2.BlindedBeaconBlockBellatrix, sig []byte) error {
+	b, err := migration.BlindedBellatrixToV1Alpha1SignedBlock(&ethpbv2.SignedBlindedBeaconBlockBellatrix{
+		Message:   blindedBellatrixBlk,
+		Signature: sig,
+	})
+	if err != nil {
+		return status.Errorf(codes.Internal, "Could not get blinded block: %v", err)
+	}
+	_, err = bs.V1Alpha1ValidatorServer.ProposeBeaconBlock(ctx, &eth.GenericSignedBeaconBlock{
+		Block: &eth.GenericSignedBeaconBlock_BlindedBellatrix{
+			BlindedBellatrix: b,
+		},
+	})
+	if err != nil {
+		return status.Errorf(codes.Internal, "Could not propose blinded block: %v", err)
+	}
+	return nil
+}
+
+func (bs *Server) submitBlindedCapellaBlock(ctx context.Context, blindedCapellaBlk *ethpbv2.BlindedBeaconBlockCapella, sig []byte) error {
+	b, err := migration.BlindedCapellaToV1Alpha1SignedBlock(&ethpbv2.SignedBlindedBeaconBlockCapella{
+		Message:   blindedCapellaBlk,
+		Signature: sig,
+	})
+	if err != nil {
+		return status.Errorf(codes.Internal, "Could not get blinded block: %v", err)
+	}
+	_, err = bs.V1Alpha1ValidatorServer.ProposeBeaconBlock(ctx, &eth.GenericSignedBeaconBlock{
+		Block: &eth.GenericSignedBeaconBlock_BlindedCapella{
+			BlindedCapella: b,
+		},
+	})
+	if err != nil {
+		return status.Errorf(codes.Internal, "Could not propose blinded block: %v", err)
+	}
+	return nil
+}

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

@@ -7,10 +7,17 @@ import (
 	"testing"
 
 	mock "github.com/prysmaticlabs/prysm/v3/beacon-chain/blockchain/testing"
+	builderTest "github.com/prysmaticlabs/prysm/v3/beacon-chain/builder/testing"
 	dbTest "github.com/prysmaticlabs/prysm/v3/beacon-chain/db/testing"
 	executionTest "github.com/prysmaticlabs/prysm/v3/beacon-chain/execution/testing"
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/synccommittee"
+	mockp2p "github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p/testing"
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/rpc/prysm/v1alpha1/validator"
+	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v3/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/v3/encoding/ssz"
 	enginev1 "github.com/prysmaticlabs/prysm/v3/proto/engine/v1"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v3/proto/eth/v1"
 	ethpbv2 "github.com/prysmaticlabs/prysm/v3/proto/eth/v2"
@@ -19,6 +26,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/testing/assert"
 	"github.com/prysmaticlabs/prysm/v3/testing/require"
 	"github.com/prysmaticlabs/prysm/v3/testing/util"
+	"google.golang.org/grpc/metadata"
 )
 
 func TestServer_GetBlindedBlock(t *testing.T) {
@@ -745,3 +753,402 @@ func TestServer_GetBlindedBlockSSZ(t *testing.T) {
 		assert.Equal(t, ethpbv2.Version_CAPELLA, resp.Version)
 	})
 }
+
+func TestServer_SubmitBlindedBlockSSZ_OK(t *testing.T) {
+	t.Run("Phase 0", func(t *testing.T) {
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		genesis := util.NewBeaconBlock()
+		util.SaveBlock(t, context.Background(), beaconDB, genesis)
+
+		numDeposits := uint64(64)
+		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
+		bsRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		genesisRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
+
+		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
+		beaconChainServer := &Server{
+			BeaconDB:         beaconDB,
+			BlockReceiver:    c,
+			ChainInfoFetcher: c,
+			BlockNotifier:    c.BlockNotifier(),
+			Broadcaster:      mockp2p.NewTestP2P(t),
+			HeadFetcher:      c,
+		}
+		req := util.NewBeaconBlock()
+		req.Block.Slot = 5
+		req.Block.ParentRoot = bsRoot[:]
+		util.SaveBlock(t, ctx, beaconDB, req)
+		blockSsz, err := req.MarshalSSZ()
+		require.NoError(t, err)
+		blockReq := &ethpbv2.SSZContainer{
+			Data: blockSsz,
+		}
+		md := metadata.MD{}
+		md.Set(versionHeader, "phase0")
+		sszCtx := metadata.NewIncomingContext(ctx, md)
+		_, err = beaconChainServer.SubmitBlindedBlockSSZ(sszCtx, blockReq)
+		assert.NoError(t, err, "Could not propose block correctly")
+	})
+
+	t.Run("Altair", func(t *testing.T) {
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		genesis := util.NewBeaconBlockAltair()
+		util.SaveBlock(t, context.Background(), beaconDB, genesis)
+
+		numDeposits := uint64(64)
+		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
+		bsRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		genesisRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
+
+		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
+		beaconChainServer := &Server{
+			BeaconDB:         beaconDB,
+			BlockReceiver:    c,
+			ChainInfoFetcher: c,
+			BlockNotifier:    c.BlockNotifier(),
+			Broadcaster:      mockp2p.NewTestP2P(t),
+			HeadFetcher:      c,
+		}
+		req := util.NewBeaconBlockAltair()
+		req.Block.Slot = params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().AltairForkEpoch))
+		req.Block.ParentRoot = bsRoot[:]
+		util.SaveBlock(t, ctx, beaconDB, req)
+		blockSsz, err := req.MarshalSSZ()
+		require.NoError(t, err)
+		blockReq := &ethpbv2.SSZContainer{
+			Data: blockSsz,
+		}
+		md := metadata.MD{}
+		md.Set(versionHeader, "altair")
+		sszCtx := metadata.NewIncomingContext(ctx, md)
+		_, err = beaconChainServer.SubmitBlindedBlockSSZ(sszCtx, blockReq)
+		assert.NoError(t, err, "Could not propose block correctly")
+	})
+
+	t.Run("Bellatrix", func(t *testing.T) {
+		// INFO: This code block can be removed once Bellatrix
+		// fork epoch is set to a value other than math.MaxUint64
+		params.SetupTestConfigCleanup(t)
+		cfg := params.BeaconConfig()
+		cfg.BellatrixForkEpoch = cfg.AltairForkEpoch + 1000
+		cfg.ForkVersionSchedule[bytesutil.ToBytes4(cfg.BellatrixForkVersion)] = cfg.AltairForkEpoch + 1000
+		params.OverrideBeaconConfig(cfg)
+
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		genesis := util.NewBeaconBlockBellatrix()
+		util.SaveBlock(t, context.Background(), beaconDB, genesis)
+
+		numDeposits := uint64(64)
+		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
+		bsRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		genesisRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
+
+		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
+		alphaServer := &validator.Server{
+			SyncCommitteePool: synccommittee.NewStore(),
+			P2P:               &mockp2p.MockBroadcaster{},
+			BlockBuilder:      &builderTest.MockBuilderService{},
+			BlockReceiver:     c,
+			BlockNotifier:     &mock.MockBlockNotifier{},
+		}
+		beaconChainServer := &Server{
+			BeaconDB:                beaconDB,
+			BlockReceiver:           c,
+			ChainInfoFetcher:        c,
+			BlockNotifier:           c.BlockNotifier(),
+			Broadcaster:             mockp2p.NewTestP2P(t),
+			HeadFetcher:             c,
+			V1Alpha1ValidatorServer: alphaServer,
+		}
+		req := util.NewBlindedBeaconBlockBellatrix()
+		req.Block.Slot = params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().BellatrixForkEpoch))
+		req.Block.ParentRoot = bsRoot[:]
+		util.SaveBlock(t, ctx, beaconDB, req)
+		blockSsz, err := req.MarshalSSZ()
+		require.NoError(t, err)
+		blockReq := &ethpbv2.SSZContainer{
+			Data: blockSsz,
+		}
+		md := metadata.MD{}
+		md.Set(versionHeader, "bellatrix")
+		sszCtx := metadata.NewIncomingContext(ctx, md)
+		_, err = beaconChainServer.SubmitBlindedBlockSSZ(sszCtx, blockReq)
+		assert.NoError(t, err, "Could not propose block correctly")
+	})
+
+	t.Run("Capella", func(t *testing.T) {
+		t.Skip("This test needs Capella fork version configured properly")
+
+		// INFO: This code block can be removed once Capella
+		// fork epoch is set to a value other than math.MaxUint64
+		params.SetupTestConfigCleanup(t)
+		cfg := params.BeaconConfig()
+		cfg.CapellaForkEpoch = cfg.BellatrixForkEpoch + 1000
+		cfg.ForkVersionSchedule[bytesutil.ToBytes4(cfg.CapellaForkVersion)] = cfg.BellatrixForkEpoch + 1000
+		params.OverrideBeaconConfig(cfg)
+
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		genesis := util.NewBeaconBlockCapella()
+		util.SaveBlock(t, context.Background(), beaconDB, genesis)
+
+		numDeposits := uint64(64)
+		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
+		bsRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		genesisRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
+
+		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
+		alphaServer := &validator.Server{
+			SyncCommitteePool: synccommittee.NewStore(),
+			P2P:               &mockp2p.MockBroadcaster{},
+			BlockBuilder:      &builderTest.MockBuilderService{},
+			BlockReceiver:     c,
+			BlockNotifier:     &mock.MockBlockNotifier{},
+		}
+		beaconChainServer := &Server{
+			BeaconDB:                beaconDB,
+			BlockReceiver:           c,
+			ChainInfoFetcher:        c,
+			BlockNotifier:           c.BlockNotifier(),
+			Broadcaster:             mockp2p.NewTestP2P(t),
+			HeadFetcher:             c,
+			V1Alpha1ValidatorServer: alphaServer,
+		}
+		req := util.NewBlindedBeaconBlockCapella()
+		req.Block.Slot = params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().CapellaForkEpoch))
+		req.Block.ParentRoot = bsRoot[:]
+		util.SaveBlock(t, ctx, beaconDB, req)
+		blockSsz, err := req.MarshalSSZ()
+		require.NoError(t, err)
+		blockReq := &ethpbv2.SSZContainer{
+			Data: blockSsz,
+		}
+		md := metadata.MD{}
+		md.Set(versionHeader, "capella")
+		sszCtx := metadata.NewIncomingContext(ctx, md)
+		_, err = beaconChainServer.SubmitBlindedBlockSSZ(sszCtx, blockReq)
+		assert.NoError(t, err, "Could not propose block correctly")
+	})
+}
+
+func TestSubmitBlindedBlock(t *testing.T) {
+	t.Run("Phase 0", func(t *testing.T) {
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		genesis := util.NewBeaconBlock()
+		util.SaveBlock(t, context.Background(), beaconDB, genesis)
+
+		numDeposits := uint64(64)
+		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
+		bsRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		genesisRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
+
+		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
+		beaconChainServer := &Server{
+			BeaconDB:         beaconDB,
+			BlockReceiver:    c,
+			ChainInfoFetcher: c,
+			BlockNotifier:    c.BlockNotifier(),
+			Broadcaster:      mockp2p.NewTestP2P(t),
+		}
+		req := util.NewBeaconBlock()
+		req.Block.Slot = 5
+		req.Block.ParentRoot = bsRoot[:]
+		v1Block, err := migration.V1Alpha1ToV1SignedBlock(req)
+		require.NoError(t, err)
+		util.SaveBlock(t, ctx, beaconDB, req)
+		blockReq := &ethpbv2.SignedBlindedBeaconBlockContainer{
+			Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_Phase0Block{Phase0Block: v1Block.Block},
+			Signature: v1Block.Signature,
+		}
+		_, err = beaconChainServer.SubmitBlindedBlock(context.Background(), blockReq)
+		assert.NoError(t, err, "Could not propose block correctly")
+	})
+
+	t.Run("Altair", func(t *testing.T) {
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		genesis := util.NewBeaconBlockAltair()
+		util.SaveBlock(t, context.Background(), beaconDB, genesis)
+
+		numDeposits := uint64(64)
+		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
+		bsRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		genesisRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
+
+		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
+		beaconChainServer := &Server{
+			BeaconDB:         beaconDB,
+			BlockReceiver:    c,
+			ChainInfoFetcher: c,
+			BlockNotifier:    c.BlockNotifier(),
+			Broadcaster:      mockp2p.NewTestP2P(t),
+		}
+		req := util.NewBeaconBlockAltair()
+		req.Block.Slot = 5
+		req.Block.ParentRoot = bsRoot[:]
+		v2Block, err := migration.V1Alpha1BeaconBlockAltairToV2(req.Block)
+		require.NoError(t, err)
+		util.SaveBlock(t, ctx, beaconDB, req)
+		blockReq := &ethpbv2.SignedBlindedBeaconBlockContainer{
+			Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_AltairBlock{AltairBlock: v2Block},
+			Signature: req.Signature,
+		}
+		_, err = beaconChainServer.SubmitBlindedBlock(context.Background(), blockReq)
+		assert.NoError(t, err, "Could not propose block correctly")
+	})
+
+	t.Run("Bellatrix", func(t *testing.T) {
+		transactions := [][]byte{[]byte("transaction1"), []byte("transaction2")}
+		transactionsRoot, err := ssz.TransactionsRoot(transactions)
+		require.NoError(t, err)
+
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		genesis := util.NewBeaconBlockBellatrix()
+		util.SaveBlock(t, context.Background(), beaconDB, genesis)
+
+		numDeposits := uint64(64)
+		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
+		bsRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		genesisRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
+
+		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
+		alphaServer := &validator.Server{
+			SyncCommitteePool: synccommittee.NewStore(),
+			P2P:               &mockp2p.MockBroadcaster{},
+			BlockBuilder:      &builderTest.MockBuilderService{},
+			BlockReceiver:     c,
+			BlockNotifier:     &mock.MockBlockNotifier{},
+		}
+		beaconChainServer := &Server{
+			BeaconDB:                beaconDB,
+			BlockReceiver:           c,
+			ChainInfoFetcher:        c,
+			BlockNotifier:           c.BlockNotifier(),
+			Broadcaster:             mockp2p.NewTestP2P(t),
+			V1Alpha1ValidatorServer: alphaServer,
+		}
+
+		blk := util.NewBeaconBlockBellatrix()
+		blk.Block.Slot = 5
+		blk.Block.ParentRoot = bsRoot[:]
+		blk.Block.Body.ExecutionPayload.Transactions = transactions
+		blindedBlk := util.NewBlindedBeaconBlockBellatrixV2()
+		blindedBlk.Message.Slot = 5
+		blindedBlk.Message.ParentRoot = bsRoot[:]
+		blindedBlk.Message.Body.ExecutionPayloadHeader.TransactionsRoot = transactionsRoot[:]
+		util.SaveBlock(t, ctx, beaconDB, blk)
+
+		blockReq := &ethpbv2.SignedBlindedBeaconBlockContainer{
+			Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_BellatrixBlock{BellatrixBlock: blindedBlk.Message},
+			Signature: blindedBlk.Signature,
+		}
+		_, err = beaconChainServer.SubmitBlindedBlock(context.Background(), blockReq)
+		assert.NoError(t, err)
+	})
+
+	t.Run("Capella", func(t *testing.T) {
+		transactions := [][]byte{[]byte("transaction1"), []byte("transaction2")}
+		transactionsRoot, err := ssz.TransactionsRoot(transactions)
+		require.NoError(t, err)
+
+		withdrawals := []*enginev1.Withdrawal{
+			{
+				Index:          1,
+				ValidatorIndex: 1,
+				Address:        bytesutil.PadTo([]byte("address1"), 20),
+				Amount:         1,
+			},
+			{
+				Index:          2,
+				ValidatorIndex: 2,
+				Address:        bytesutil.PadTo([]byte("address2"), 20),
+				Amount:         2,
+			},
+		}
+		withdrawalsRoot, err := ssz.WithdrawalSliceRoot(hash.CustomSHA256Hasher(), withdrawals, 16)
+		require.NoError(t, err)
+
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		genesis := util.NewBeaconBlockCapella()
+		util.SaveBlock(t, context.Background(), beaconDB, genesis)
+
+		numDeposits := uint64(64)
+		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
+		bsRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		genesisRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
+
+		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
+		alphaServer := &validator.Server{
+			SyncCommitteePool: synccommittee.NewStore(),
+			P2P:               &mockp2p.MockBroadcaster{},
+			BlockBuilder:      &builderTest.MockBuilderService{},
+			BlockReceiver:     c,
+			BlockNotifier:     &mock.MockBlockNotifier{},
+		}
+		beaconChainServer := &Server{
+			BeaconDB:                beaconDB,
+			BlockReceiver:           c,
+			ChainInfoFetcher:        c,
+			BlockNotifier:           c.BlockNotifier(),
+			Broadcaster:             mockp2p.NewTestP2P(t),
+			V1Alpha1ValidatorServer: alphaServer,
+		}
+
+		blk := util.NewBeaconBlockCapella()
+		blk.Block.Slot = 5
+		blk.Block.ParentRoot = bsRoot[:]
+		blk.Block.Body.ExecutionPayload.Transactions = transactions
+		blk.Block.Body.ExecutionPayload.Withdrawals = withdrawals
+		blindedBlk := util.NewBlindedBeaconBlockCapellaV2()
+		blindedBlk.Message.Slot = 5
+		blindedBlk.Message.ParentRoot = bsRoot[:]
+		blindedBlk.Message.Body.ExecutionPayloadHeader.TransactionsRoot = transactionsRoot[:]
+		blindedBlk.Message.Body.ExecutionPayloadHeader.WithdrawalsRoot = withdrawalsRoot[:]
+		util.SaveBlock(t, ctx, beaconDB, blk)
+
+		blockReq := &ethpbv2.SignedBlindedBeaconBlockContainer{
+			Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_CapellaBlock{CapellaBlock: blindedBlk.Message},
+			Signature: blindedBlk.Signature,
+		}
+		_, err = beaconChainServer.SubmitBlindedBlock(context.Background(), blockReq)
+		assert.NoError(t, err)
+	})
+}

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

@@ -23,7 +23,6 @@ import (
 	ethpbv1 "github.com/prysmaticlabs/prysm/v3/proto/eth/v1"
 	ethpbv2 "github.com/prysmaticlabs/prysm/v3/proto/eth/v2"
 	"github.com/prysmaticlabs/prysm/v3/proto/migration"
-	eth "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v3/time/slots"
 	"go.opencensus.io/trace"
 	"google.golang.org/grpc/codes"
@@ -282,112 +281,6 @@ func (bs *Server) SubmitBlockSSZ(ctx context.Context, req *ethpbv2.SSZContainer)
 	return &emptypb.Empty{}, bs.submitBlock(ctx, root, block)
 }
 
-// SubmitBlindedBlock instructs the beacon node to use the components of the `SignedBlindedBeaconBlock` to construct
-// and publish a `SignedBeaconBlock` by swapping out the `transactions_root` for the corresponding full list of `transactions`.
-// The beacon node should broadcast a newly constructed `SignedBeaconBlock` to the beacon network,
-// to be included in the beacon chain. The beacon node is not required to validate the signed
-// `BeaconBlock`, and a successful response (20X) only indicates that the broadcast has been
-// successful. The beacon node is expected to integrate the new block into its state, and
-// therefore validate the block internally, however blocks which fail the validation are still
-// broadcast but a different status code is returned (202).
-func (bs *Server) SubmitBlindedBlock(ctx context.Context, req *ethpbv2.SignedBlindedBeaconBlockContainer) (*emptypb.Empty, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon.SubmitBlindedBlock")
-	defer span.End()
-
-	capellaBlkContainer, ok := req.Message.(*ethpbv2.SignedBlindedBeaconBlockContainer_CapellaBlock)
-	if ok {
-		if err := bs.submitBlindedCapellaBlock(ctx, capellaBlkContainer.CapellaBlock, req.Signature); err != nil {
-			return nil, err
-		}
-	}
-
-	bellatrixBlkContainer, ok := req.Message.(*ethpbv2.SignedBlindedBeaconBlockContainer_BellatrixBlock)
-	if ok {
-		if err := bs.submitBlindedBellatrixBlock(ctx, bellatrixBlkContainer.BellatrixBlock, req.Signature); err != nil {
-			return nil, err
-		}
-	}
-
-	// At the end we check forks that don't have blinded blocks.
-	phase0BlkContainer, ok := req.Message.(*ethpbv2.SignedBlindedBeaconBlockContainer_Phase0Block)
-	if ok {
-		if err := bs.submitPhase0Block(ctx, phase0BlkContainer.Phase0Block, req.Signature); err != nil {
-			return nil, err
-		}
-	}
-	altairBlkContainer, ok := req.Message.(*ethpbv2.SignedBlindedBeaconBlockContainer_AltairBlock)
-	if ok {
-		if err := bs.submitAltairBlock(ctx, altairBlkContainer.AltairBlock, req.Signature); err != nil {
-			return nil, err
-		}
-	}
-
-	return &emptypb.Empty{}, nil
-}
-
-// SubmitBlindedBlockSSZ instructs the beacon node to use the components of the `SignedBlindedBeaconBlock` to construct
-// and publish a `SignedBeaconBlock` by swapping out the `transactions_root` for the corresponding full list of `transactions`.
-// The beacon node should broadcast a newly constructed `SignedBeaconBlock` to the beacon network,
-// to be included in the beacon chain. The beacon node is not required to validate the signed
-// `BeaconBlock`, and a successful response (20X) only indicates that the broadcast has been
-// successful. The beacon node is expected to integrate the new block into its state, and
-// therefore validate the block internally, however blocks which fail the validation are still
-// broadcast but a different status code is returned (202).
-//
-// The provided block must be SSZ-serialized.
-func (bs *Server) SubmitBlindedBlockSSZ(ctx context.Context, req *ethpbv2.SSZContainer) (*emptypb.Empty, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon.SubmitBlindedBlockSSZ")
-	defer span.End()
-
-	md, ok := metadata.FromIncomingContext(ctx)
-	if !ok {
-		return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not read"+versionHeader+" header")
-	}
-	ver := md.Get(versionHeader)
-	if len(ver) == 0 {
-		return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not read"+versionHeader+" header")
-	}
-	schedule := forks.NewOrderedSchedule(params.BeaconConfig())
-	forkVer, err := schedule.VersionForName(ver[0])
-	if err != nil {
-		return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not determine fork version: %v", err)
-	}
-	unmarshaler, err := detect.FromForkVersion(forkVer)
-	if err != nil {
-		return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not create unmarshaler: %v", err)
-	}
-	block, err := unmarshaler.UnmarshalBlindedBeaconBlock(req.Data)
-	if err != nil {
-		return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not unmarshal request data into block: %v", err)
-	}
-
-	if block.IsBlinded() {
-		b, err := block.PbBlindedBellatrixBlock()
-		if err != nil {
-			b, err := block.PbBlindedCapellaBlock()
-			if err != nil {
-				return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not get blinded block: %v", err)
-			}
-			bb, err := migration.V1Alpha1BeaconBlockBlindedCapellaToV2Blinded(b.Block)
-			if err != nil {
-				return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not migrate block: %v", err)
-			}
-			return &emptypb.Empty{}, bs.submitBlindedCapellaBlock(ctx, bb, b.Signature)
-		}
-		bb, err := migration.V1Alpha1BeaconBlockBlindedBellatrixToV2Blinded(b.Block)
-		if err != nil {
-			return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not migrate block: %v", err)
-		}
-		return &emptypb.Empty{}, bs.submitBlindedBellatrixBlock(ctx, bb, b.Signature)
-	}
-
-	root, err := block.Block().HashTreeRoot()
-	if err != nil {
-		return &emptypb.Empty{}, status.Errorf(codes.Internal, "Could not compute block's hash tree root: %v", err)
-	}
-	return &emptypb.Empty{}, bs.submitBlock(ctx, root, block)
-}
-
 // GetBlock retrieves block details for given block ID.
 func (bs *Server) GetBlock(ctx context.Context, req *ethpbv1.BlockRequest) (*ethpbv1.BlockResponse, error) {
 	ctx, span := trace.StartSpan(ctx, "beacon.GetBlock")
@@ -1166,44 +1059,6 @@ func (bs *Server) submitCapellaBlock(ctx context.Context, capellaBlk *ethpbv2.Be
 	return bs.submitBlock(ctx, root, wrappedCapellaBlk)
 }
 
-func (bs *Server) submitBlindedBellatrixBlock(ctx context.Context, blindedBellatrixBlk *ethpbv2.BlindedBeaconBlockBellatrix, sig []byte) error {
-	b, err := migration.BlindedBellatrixToV1Alpha1SignedBlock(&ethpbv2.SignedBlindedBeaconBlockBellatrix{
-		Message:   blindedBellatrixBlk,
-		Signature: sig,
-	})
-	if err != nil {
-		return status.Errorf(codes.Internal, "Could not get blinded block: %v", err)
-	}
-	_, err = bs.V1Alpha1ValidatorServer.ProposeBeaconBlock(ctx, &eth.GenericSignedBeaconBlock{
-		Block: &eth.GenericSignedBeaconBlock_BlindedBellatrix{
-			BlindedBellatrix: b,
-		},
-	})
-	if err != nil {
-		return status.Errorf(codes.Internal, "Could not propose blinded block: %v", err)
-	}
-	return nil
-}
-
-func (bs *Server) submitBlindedCapellaBlock(ctx context.Context, blindedCapellaBlk *ethpbv2.BlindedBeaconBlockCapella, sig []byte) error {
-	b, err := migration.BlindedCapellaToV1Alpha1SignedBlock(&ethpbv2.SignedBlindedBeaconBlockCapella{
-		Message:   blindedCapellaBlk,
-		Signature: sig,
-	})
-	if err != nil {
-		return status.Errorf(codes.Internal, "Could not get blinded block: %v", err)
-	}
-	_, err = bs.V1Alpha1ValidatorServer.ProposeBeaconBlock(ctx, &eth.GenericSignedBeaconBlock{
-		Block: &eth.GenericSignedBeaconBlock_BlindedCapella{
-			BlindedCapella: b,
-		},
-	})
-	if err != nil {
-		return status.Errorf(codes.Internal, "Could not propose blinded block: %v", err)
-	}
-	return nil
-}
-
 func (bs *Server) submitBlock(ctx context.Context, blockRoot [fieldparams.RootLength]byte, block interfaces.SignedBeaconBlock) error {
 	// Do not block proposal critical path with debug logging or block feed updates.
 	defer func() {

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

@@ -7,20 +7,15 @@ import (
 	"testing"
 
 	mock "github.com/prysmaticlabs/prysm/v3/beacon-chain/blockchain/testing"
-	builderTest "github.com/prysmaticlabs/prysm/v3/beacon-chain/builder/testing"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/db"
 	dbTest "github.com/prysmaticlabs/prysm/v3/beacon-chain/db/testing"
 	executionTest "github.com/prysmaticlabs/prysm/v3/beacon-chain/execution/testing"
-	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/synccommittee"
 	mockp2p "github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p/testing"
-	"github.com/prysmaticlabs/prysm/v3/beacon-chain/rpc/prysm/v1alpha1/validator"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v3/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v3/encoding/ssz"
 	enginev1 "github.com/prysmaticlabs/prysm/v3/proto/engine/v1"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v3/proto/eth/v1"
 	ethpbv2 "github.com/prysmaticlabs/prysm/v3/proto/eth/v2"
@@ -875,405 +870,6 @@ func TestServer_SubmitBlockSSZ_OK(t *testing.T) {
 	})
 }
 
-func TestServer_SubmitBlindedBlockSSZ_OK(t *testing.T) {
-	t.Run("Phase 0", func(t *testing.T) {
-		beaconDB := dbTest.SetupDB(t)
-		ctx := context.Background()
-
-		genesis := util.NewBeaconBlock()
-		util.SaveBlock(t, context.Background(), beaconDB, genesis)
-
-		numDeposits := uint64(64)
-		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
-		bsRoot, err := beaconState.HashTreeRoot(ctx)
-		require.NoError(t, err)
-		genesisRoot, err := genesis.Block.HashTreeRoot()
-		require.NoError(t, err)
-		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
-
-		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
-		beaconChainServer := &Server{
-			BeaconDB:         beaconDB,
-			BlockReceiver:    c,
-			ChainInfoFetcher: c,
-			BlockNotifier:    c.BlockNotifier(),
-			Broadcaster:      mockp2p.NewTestP2P(t),
-			HeadFetcher:      c,
-		}
-		req := util.NewBeaconBlock()
-		req.Block.Slot = 5
-		req.Block.ParentRoot = bsRoot[:]
-		util.SaveBlock(t, ctx, beaconDB, req)
-		blockSsz, err := req.MarshalSSZ()
-		require.NoError(t, err)
-		blockReq := &ethpbv2.SSZContainer{
-			Data: blockSsz,
-		}
-		md := metadata.MD{}
-		md.Set(versionHeader, "phase0")
-		sszCtx := metadata.NewIncomingContext(ctx, md)
-		_, err = beaconChainServer.SubmitBlindedBlockSSZ(sszCtx, blockReq)
-		assert.NoError(t, err, "Could not propose block correctly")
-	})
-
-	t.Run("Altair", func(t *testing.T) {
-		beaconDB := dbTest.SetupDB(t)
-		ctx := context.Background()
-
-		genesis := util.NewBeaconBlockAltair()
-		util.SaveBlock(t, context.Background(), beaconDB, genesis)
-
-		numDeposits := uint64(64)
-		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
-		bsRoot, err := beaconState.HashTreeRoot(ctx)
-		require.NoError(t, err)
-		genesisRoot, err := genesis.Block.HashTreeRoot()
-		require.NoError(t, err)
-		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
-
-		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
-		beaconChainServer := &Server{
-			BeaconDB:         beaconDB,
-			BlockReceiver:    c,
-			ChainInfoFetcher: c,
-			BlockNotifier:    c.BlockNotifier(),
-			Broadcaster:      mockp2p.NewTestP2P(t),
-			HeadFetcher:      c,
-		}
-		req := util.NewBeaconBlockAltair()
-		req.Block.Slot = params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().AltairForkEpoch))
-		req.Block.ParentRoot = bsRoot[:]
-		util.SaveBlock(t, ctx, beaconDB, req)
-		blockSsz, err := req.MarshalSSZ()
-		require.NoError(t, err)
-		blockReq := &ethpbv2.SSZContainer{
-			Data: blockSsz,
-		}
-		md := metadata.MD{}
-		md.Set(versionHeader, "altair")
-		sszCtx := metadata.NewIncomingContext(ctx, md)
-		_, err = beaconChainServer.SubmitBlindedBlockSSZ(sszCtx, blockReq)
-		assert.NoError(t, err, "Could not propose block correctly")
-	})
-
-	t.Run("Bellatrix", func(t *testing.T) {
-		// INFO: This code block can be removed once Bellatrix
-		// fork epoch is set to a value other than math.MaxUint64
-		params.SetupTestConfigCleanup(t)
-		cfg := params.BeaconConfig()
-		cfg.BellatrixForkEpoch = cfg.AltairForkEpoch + 1000
-		cfg.ForkVersionSchedule[bytesutil.ToBytes4(cfg.BellatrixForkVersion)] = cfg.AltairForkEpoch + 1000
-		params.OverrideBeaconConfig(cfg)
-
-		beaconDB := dbTest.SetupDB(t)
-		ctx := context.Background()
-
-		genesis := util.NewBeaconBlockBellatrix()
-		util.SaveBlock(t, context.Background(), beaconDB, genesis)
-
-		numDeposits := uint64(64)
-		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
-		bsRoot, err := beaconState.HashTreeRoot(ctx)
-		require.NoError(t, err)
-		genesisRoot, err := genesis.Block.HashTreeRoot()
-		require.NoError(t, err)
-		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
-
-		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
-		alphaServer := &validator.Server{
-			SyncCommitteePool: synccommittee.NewStore(),
-			P2P:               &mockp2p.MockBroadcaster{},
-			BlockBuilder:      &builderTest.MockBuilderService{},
-			BlockReceiver:     c,
-			BlockNotifier:     &mock.MockBlockNotifier{},
-		}
-		beaconChainServer := &Server{
-			BeaconDB:                beaconDB,
-			BlockReceiver:           c,
-			ChainInfoFetcher:        c,
-			BlockNotifier:           c.BlockNotifier(),
-			Broadcaster:             mockp2p.NewTestP2P(t),
-			HeadFetcher:             c,
-			V1Alpha1ValidatorServer: alphaServer,
-		}
-		req := util.NewBlindedBeaconBlockBellatrix()
-		req.Block.Slot = params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().BellatrixForkEpoch))
-		req.Block.ParentRoot = bsRoot[:]
-		util.SaveBlock(t, ctx, beaconDB, req)
-		blockSsz, err := req.MarshalSSZ()
-		require.NoError(t, err)
-		blockReq := &ethpbv2.SSZContainer{
-			Data: blockSsz,
-		}
-		md := metadata.MD{}
-		md.Set(versionHeader, "bellatrix")
-		sszCtx := metadata.NewIncomingContext(ctx, md)
-		_, err = beaconChainServer.SubmitBlindedBlockSSZ(sszCtx, blockReq)
-		assert.NoError(t, err, "Could not propose block correctly")
-	})
-
-	t.Run("Capella", func(t *testing.T) {
-		t.Skip("This test needs Capella fork version configured properly")
-
-		// INFO: This code block can be removed once Capella
-		// fork epoch is set to a value other than math.MaxUint64
-		params.SetupTestConfigCleanup(t)
-		cfg := params.BeaconConfig()
-		cfg.CapellaForkEpoch = cfg.BellatrixForkEpoch + 1000
-		cfg.ForkVersionSchedule[bytesutil.ToBytes4(cfg.CapellaForkVersion)] = cfg.BellatrixForkEpoch + 1000
-		params.OverrideBeaconConfig(cfg)
-
-		beaconDB := dbTest.SetupDB(t)
-		ctx := context.Background()
-
-		genesis := util.NewBeaconBlockCapella()
-		util.SaveBlock(t, context.Background(), beaconDB, genesis)
-
-		numDeposits := uint64(64)
-		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
-		bsRoot, err := beaconState.HashTreeRoot(ctx)
-		require.NoError(t, err)
-		genesisRoot, err := genesis.Block.HashTreeRoot()
-		require.NoError(t, err)
-		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
-
-		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
-		alphaServer := &validator.Server{
-			SyncCommitteePool: synccommittee.NewStore(),
-			P2P:               &mockp2p.MockBroadcaster{},
-			BlockBuilder:      &builderTest.MockBuilderService{},
-			BlockReceiver:     c,
-			BlockNotifier:     &mock.MockBlockNotifier{},
-		}
-		beaconChainServer := &Server{
-			BeaconDB:                beaconDB,
-			BlockReceiver:           c,
-			ChainInfoFetcher:        c,
-			BlockNotifier:           c.BlockNotifier(),
-			Broadcaster:             mockp2p.NewTestP2P(t),
-			HeadFetcher:             c,
-			V1Alpha1ValidatorServer: alphaServer,
-		}
-		req := util.NewBlindedBeaconBlockCapella()
-		req.Block.Slot = params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().CapellaForkEpoch))
-		req.Block.ParentRoot = bsRoot[:]
-		util.SaveBlock(t, ctx, beaconDB, req)
-		blockSsz, err := req.MarshalSSZ()
-		require.NoError(t, err)
-		blockReq := &ethpbv2.SSZContainer{
-			Data: blockSsz,
-		}
-		md := metadata.MD{}
-		md.Set(versionHeader, "capella")
-		sszCtx := metadata.NewIncomingContext(ctx, md)
-		_, err = beaconChainServer.SubmitBlindedBlockSSZ(sszCtx, blockReq)
-		assert.NoError(t, err, "Could not propose block correctly")
-	})
-}
-
-func TestSubmitBlindedBlock(t *testing.T) {
-	t.Run("Phase 0", func(t *testing.T) {
-		beaconDB := dbTest.SetupDB(t)
-		ctx := context.Background()
-
-		genesis := util.NewBeaconBlock()
-		util.SaveBlock(t, context.Background(), beaconDB, genesis)
-
-		numDeposits := uint64(64)
-		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
-		bsRoot, err := beaconState.HashTreeRoot(ctx)
-		require.NoError(t, err)
-		genesisRoot, err := genesis.Block.HashTreeRoot()
-		require.NoError(t, err)
-		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
-
-		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
-		beaconChainServer := &Server{
-			BeaconDB:         beaconDB,
-			BlockReceiver:    c,
-			ChainInfoFetcher: c,
-			BlockNotifier:    c.BlockNotifier(),
-			Broadcaster:      mockp2p.NewTestP2P(t),
-		}
-		req := util.NewBeaconBlock()
-		req.Block.Slot = 5
-		req.Block.ParentRoot = bsRoot[:]
-		v1Block, err := migration.V1Alpha1ToV1SignedBlock(req)
-		require.NoError(t, err)
-		util.SaveBlock(t, ctx, beaconDB, req)
-		blockReq := &ethpbv2.SignedBlindedBeaconBlockContainer{
-			Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_Phase0Block{Phase0Block: v1Block.Block},
-			Signature: v1Block.Signature,
-		}
-		_, err = beaconChainServer.SubmitBlindedBlock(context.Background(), blockReq)
-		assert.NoError(t, err, "Could not propose block correctly")
-	})
-
-	t.Run("Altair", func(t *testing.T) {
-		beaconDB := dbTest.SetupDB(t)
-		ctx := context.Background()
-
-		genesis := util.NewBeaconBlockAltair()
-		util.SaveBlock(t, context.Background(), beaconDB, genesis)
-
-		numDeposits := uint64(64)
-		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
-		bsRoot, err := beaconState.HashTreeRoot(ctx)
-		require.NoError(t, err)
-		genesisRoot, err := genesis.Block.HashTreeRoot()
-		require.NoError(t, err)
-		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
-
-		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
-		beaconChainServer := &Server{
-			BeaconDB:         beaconDB,
-			BlockReceiver:    c,
-			ChainInfoFetcher: c,
-			BlockNotifier:    c.BlockNotifier(),
-			Broadcaster:      mockp2p.NewTestP2P(t),
-		}
-		req := util.NewBeaconBlockAltair()
-		req.Block.Slot = 5
-		req.Block.ParentRoot = bsRoot[:]
-		v2Block, err := migration.V1Alpha1BeaconBlockAltairToV2(req.Block)
-		require.NoError(t, err)
-		util.SaveBlock(t, ctx, beaconDB, req)
-		blockReq := &ethpbv2.SignedBlindedBeaconBlockContainer{
-			Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_AltairBlock{AltairBlock: v2Block},
-			Signature: req.Signature,
-		}
-		_, err = beaconChainServer.SubmitBlindedBlock(context.Background(), blockReq)
-		assert.NoError(t, err, "Could not propose block correctly")
-	})
-
-	t.Run("Bellatrix", func(t *testing.T) {
-		transactions := [][]byte{[]byte("transaction1"), []byte("transaction2")}
-		transactionsRoot, err := ssz.TransactionsRoot(transactions)
-		require.NoError(t, err)
-
-		beaconDB := dbTest.SetupDB(t)
-		ctx := context.Background()
-
-		genesis := util.NewBeaconBlockBellatrix()
-		util.SaveBlock(t, context.Background(), beaconDB, genesis)
-
-		numDeposits := uint64(64)
-		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
-		bsRoot, err := beaconState.HashTreeRoot(ctx)
-		require.NoError(t, err)
-		genesisRoot, err := genesis.Block.HashTreeRoot()
-		require.NoError(t, err)
-		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
-
-		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
-		alphaServer := &validator.Server{
-			SyncCommitteePool: synccommittee.NewStore(),
-			P2P:               &mockp2p.MockBroadcaster{},
-			BlockBuilder:      &builderTest.MockBuilderService{},
-			BlockReceiver:     c,
-			BlockNotifier:     &mock.MockBlockNotifier{},
-		}
-		beaconChainServer := &Server{
-			BeaconDB:                beaconDB,
-			BlockReceiver:           c,
-			ChainInfoFetcher:        c,
-			BlockNotifier:           c.BlockNotifier(),
-			Broadcaster:             mockp2p.NewTestP2P(t),
-			V1Alpha1ValidatorServer: alphaServer,
-		}
-
-		blk := util.NewBeaconBlockBellatrix()
-		blk.Block.Slot = 5
-		blk.Block.ParentRoot = bsRoot[:]
-		blk.Block.Body.ExecutionPayload.Transactions = transactions
-		blindedBlk := util.NewBlindedBeaconBlockBellatrixV2()
-		blindedBlk.Message.Slot = 5
-		blindedBlk.Message.ParentRoot = bsRoot[:]
-		blindedBlk.Message.Body.ExecutionPayloadHeader.TransactionsRoot = transactionsRoot[:]
-		util.SaveBlock(t, ctx, beaconDB, blk)
-
-		blockReq := &ethpbv2.SignedBlindedBeaconBlockContainer{
-			Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_BellatrixBlock{BellatrixBlock: blindedBlk.Message},
-			Signature: blindedBlk.Signature,
-		}
-		_, err = beaconChainServer.SubmitBlindedBlock(context.Background(), blockReq)
-		assert.NoError(t, err)
-	})
-
-	t.Run("Capella", func(t *testing.T) {
-		transactions := [][]byte{[]byte("transaction1"), []byte("transaction2")}
-		transactionsRoot, err := ssz.TransactionsRoot(transactions)
-		require.NoError(t, err)
-
-		withdrawals := []*enginev1.Withdrawal{
-			{
-				Index:          1,
-				ValidatorIndex: 1,
-				Address:        bytesutil.PadTo([]byte("address1"), 20),
-				Amount:         1,
-			},
-			{
-				Index:          2,
-				ValidatorIndex: 2,
-				Address:        bytesutil.PadTo([]byte("address2"), 20),
-				Amount:         2,
-			},
-		}
-		withdrawalsRoot, err := ssz.WithdrawalSliceRoot(hash.CustomSHA256Hasher(), withdrawals, 16)
-		require.NoError(t, err)
-
-		beaconDB := dbTest.SetupDB(t)
-		ctx := context.Background()
-
-		genesis := util.NewBeaconBlockCapella()
-		util.SaveBlock(t, context.Background(), beaconDB, genesis)
-
-		numDeposits := uint64(64)
-		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
-		bsRoot, err := beaconState.HashTreeRoot(ctx)
-		require.NoError(t, err)
-		genesisRoot, err := genesis.Block.HashTreeRoot()
-		require.NoError(t, err)
-		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
-
-		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
-		alphaServer := &validator.Server{
-			SyncCommitteePool: synccommittee.NewStore(),
-			P2P:               &mockp2p.MockBroadcaster{},
-			BlockBuilder:      &builderTest.MockBuilderService{},
-			BlockReceiver:     c,
-			BlockNotifier:     &mock.MockBlockNotifier{},
-		}
-		beaconChainServer := &Server{
-			BeaconDB:                beaconDB,
-			BlockReceiver:           c,
-			ChainInfoFetcher:        c,
-			BlockNotifier:           c.BlockNotifier(),
-			Broadcaster:             mockp2p.NewTestP2P(t),
-			V1Alpha1ValidatorServer: alphaServer,
-		}
-
-		blk := util.NewBeaconBlockCapella()
-		blk.Block.Slot = 5
-		blk.Block.ParentRoot = bsRoot[:]
-		blk.Block.Body.ExecutionPayload.Transactions = transactions
-		blk.Block.Body.ExecutionPayload.Withdrawals = withdrawals
-		blindedBlk := util.NewBlindedBeaconBlockCapellaV2()
-		blindedBlk.Message.Slot = 5
-		blindedBlk.Message.ParentRoot = bsRoot[:]
-		blindedBlk.Message.Body.ExecutionPayloadHeader.TransactionsRoot = transactionsRoot[:]
-		blindedBlk.Message.Body.ExecutionPayloadHeader.WithdrawalsRoot = withdrawalsRoot[:]
-		util.SaveBlock(t, ctx, beaconDB, blk)
-
-		blockReq := &ethpbv2.SignedBlindedBeaconBlockContainer{
-			Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_CapellaBlock{CapellaBlock: blindedBlk.Message},
-			Signature: blindedBlk.Signature,
-		}
-		_, err = beaconChainServer.SubmitBlindedBlock(context.Background(), blockReq)
-		assert.NoError(t, err)
-	})
-}
-
 func TestServer_GetBlock(t *testing.T) {
 	beaconDB := dbTest.SetupDB(t)
 	ctx := context.Background()