Maintainable Beacon Block API Endpoints (#9528)

* add new proto endpoints and deprecate old

* regen protos

* regen mocks

* begin fixing tests

* build tests

* e2e build

* go build

* resolve conflicts

* pass tests

* amend generated name

* fix build

* more fixes

* update gateway paths

* radek comments

* fix comment

Co-authored-by: Preston Van Loon <preston@prysmaticlabs.com>

validator/client/propose.go

@@ -200,7 +200,7 @@ func (v *validator) proposeBlockAltair(ctx context.Context, slot types.Slot, pub
 	}
 
 	// Request block from beacon node
-	b, err := v.validatorClient.GetBlockAltair(ctx, &ethpb.BlockRequest{
+	b, err := v.validatorClient.GetBeaconBlock(ctx, &ethpb.BlockRequest{
 		Slot:         slot,
 		RandaoReveal: randaoReveal,
 		Graffiti:     g,
@@ -212,9 +212,17 @@ func (v *validator) proposeBlockAltair(ctx context.Context, slot types.Slot, pub
 		}
 		return
 	}
+	altairBlk, ok := b.Block.(*ethpb.GenericBeaconBlock_Altair)
+	if !ok {
+		log.Error("Not an Altair block")
+		if v.emitAccountMetrics {
+			ValidatorProposeFailVec.WithLabelValues(fmtKey).Inc()
+		}
+		return
+	}
 
 	// Sign returned block from beacon node
-	wb, err := wrapper.WrappedAltairBeaconBlock(b)
+	wb, err := wrapper.WrappedAltairBeaconBlock(altairBlk.Altair)
 	if err != nil {
 		log.WithError(err).Error("Failed to wrap block")
 		if v.emitAccountMetrics {
@@ -231,11 +239,11 @@ func (v *validator) proposeBlockAltair(ctx context.Context, slot types.Slot, pub
 		return
 	}
 	blk := &ethpb.SignedBeaconBlockAltair{
-		Block:     b,
+		Block:     altairBlk.Altair,
 		Signature: sig,
 	}
 
-	signingRoot, err := helpers.ComputeSigningRoot(b, domain.SignatureDomain)
+	signingRoot, err := helpers.ComputeSigningRoot(altairBlk.Altair, domain.SignatureDomain)
 	if err != nil {
 		if v.emitAccountMetrics {
 			ValidatorProposeFailVec.WithLabelValues(fmtKey).Inc()
@@ -273,7 +281,9 @@ func (v *validator) proposeBlockAltair(ctx context.Context, slot types.Slot, pub
 	}
 
 	// Propose and broadcast block via beacon node
-	blkResp, err := v.validatorClient.ProposeBlockAltair(ctx, blk)
+	blkResp, err := v.validatorClient.ProposeBeaconBlock(ctx, &ethpb.GenericSignedBeaconBlock{
+		Block: &ethpb.GenericSignedBeaconBlock_Altair{Altair: blk},
+	})
 	if err != nil {
 		log.WithError(err).Error("Failed to propose block")
 		if v.emitAccountMetrics {
@@ -284,17 +294,17 @@ func (v *validator) proposeBlockAltair(ctx context.Context, slot types.Slot, pub
 
 	span.AddAttributes(
 		trace.StringAttribute("blockRoot", fmt.Sprintf("%#x", blkResp.BlockRoot)),
-		trace.Int64Attribute("numDeposits", int64(len(b.Body.Deposits))),
-		trace.Int64Attribute("numAttestations", int64(len(b.Body.Attestations))),
+		trace.Int64Attribute("numDeposits", int64(len(altairBlk.Altair.Body.Deposits))),
+		trace.Int64Attribute("numAttestations", int64(len(altairBlk.Altair.Body.Attestations))),
 	)
 
 	blkRoot := fmt.Sprintf("%#x", bytesutil.Trunc(blkResp.BlockRoot))
 	log.WithFields(logrus.Fields{
-		"slot":            b.Slot,
+		"slot":            altairBlk.Altair.Slot,
 		"blockRoot":       blkRoot,
-		"numAttestations": len(b.Body.Attestations),
-		"numDeposits":     len(b.Body.Deposits),
-		"graffiti":        string(b.Body.Graffiti),
+		"numAttestations": len(altairBlk.Altair.Body.Attestations),
+		"numDeposits":     len(altairBlk.Altair.Body.Deposits),
+		"graffiti":        string(altairBlk.Altair.Body.Graffiti),
 		"fork":            "altair",
 	}).Info("Submitted new block")
 

validator/client/propose_test.go

@@ -173,7 +173,7 @@ func TestProposeBlockAltair_RequestBlockFailed(t *testing.T) {
 		gomock.Any(), // epoch
 	).Return(&ethpb.DomainResponse{SignatureDomain: make([]byte, 32)}, nil /*err*/)
 
-	m.validatorClient.EXPECT().GetBlockAltair(
+	m.validatorClient.EXPECT().GetBeaconBlock(
 		gomock.Any(), // ctx
 		gomock.Any(), // block request
 	).Return(nil /*response*/, errors.New("uh oh"))
@@ -229,19 +229,21 @@ func TestProposeBlockAltair_ProposeBlockFailed(t *testing.T) {
 		gomock.Any(), // epoch
 	).Return(&ethpb.DomainResponse{SignatureDomain: make([]byte, 32)}, nil /*err*/)
 
-	m.validatorClient.EXPECT().GetBlockAltair(
+	m.validatorClient.EXPECT().GetBeaconBlock(
 		gomock.Any(), // ctx
 		gomock.Any(),
-	).Return(testutil.NewBeaconBlockAltair().Block, nil /*err*/)
+	).Return(&ethpb.GenericBeaconBlock{
+		Block: &ethpb.GenericBeaconBlock_Altair{Altair: testutil.NewBeaconBlockAltair().Block},
+	}, nil /*err*/)
 
 	m.validatorClient.EXPECT().DomainData(
 		gomock.Any(), // ctx
 		gomock.Any(), // epoch
 	).Return(&ethpb.DomainResponse{SignatureDomain: make([]byte, 32)}, nil /*err*/)
 
-	m.validatorClient.EXPECT().ProposeBlockAltair(
+	m.validatorClient.EXPECT().ProposeBeaconBlock(
 		gomock.Any(), // ctx
-		gomock.AssignableToTypeOf(&ethpb.SignedBeaconBlockAltair{}),
+		gomock.AssignableToTypeOf(&ethpb.GenericSignedBeaconBlock{}),
 	).Return(nil /*response*/, errors.New("uh oh"))
 
 	validator.ProposeBlock(context.Background(), 2*params.BeaconConfig().SlotsPerEpoch, pubKey)
@@ -324,29 +326,33 @@ func TestProposeBlockAltair_BlocksDoubleProposal(t *testing.T) {
 	testBlock := testutil.NewBeaconBlockAltair()
 	slot := params.BeaconConfig().SlotsPerEpoch*5 + 2
 	testBlock.Block.Slot = slot
-	m.validatorClient.EXPECT().GetBlockAltair(
+	m.validatorClient.EXPECT().GetBeaconBlock(
 		gomock.Any(), // ctx
 		gomock.Any(),
-	).Return(testBlock.Block, nil /*err*/)
+	).Return(&ethpb.GenericBeaconBlock{
+		Block: &ethpb.GenericBeaconBlock_Altair{Altair: testBlock.Block},
+	}, nil /*err*/)
 
 	secondTestBlock := testutil.NewBeaconBlockAltair()
 	secondTestBlock.Block.Slot = slot
 	graffiti := [32]byte{}
 	copy(graffiti[:], "someothergraffiti")
 	secondTestBlock.Block.Body.Graffiti = graffiti[:]
-	m.validatorClient.EXPECT().GetBlockAltair(
+	m.validatorClient.EXPECT().GetBeaconBlock(
 		gomock.Any(), // ctx
 		gomock.Any(),
-	).Return(secondTestBlock.Block, nil /*err*/)
+	).Return(&ethpb.GenericBeaconBlock{
+		Block: &ethpb.GenericBeaconBlock_Altair{Altair: secondTestBlock.Block},
+	}, nil /*err*/)
 
 	m.validatorClient.EXPECT().DomainData(
 		gomock.Any(), // ctx
 		gomock.Any(), // epoch
 	).Times(3).Return(&ethpb.DomainResponse{SignatureDomain: make([]byte, 32)}, nil /*err*/)
 
-	m.validatorClient.EXPECT().ProposeBlockAltair(
+	m.validatorClient.EXPECT().ProposeBeaconBlock(
 		gomock.Any(), // ctx
-		gomock.AssignableToTypeOf(&ethpb.SignedBeaconBlockAltair{}),
+		gomock.AssignableToTypeOf(&ethpb.GenericSignedBeaconBlock{}),
 	).Return(&ethpb.ProposeResponse{BlockRoot: make([]byte, 32)}, nil /*error*/)
 
 	validator.ProposeBlock(context.Background(), slot, pubKey)
@@ -591,28 +597,33 @@ func TestProposeBlockAltair_BroadcastsBlock_WithGraffiti(t *testing.T) {
 
 	blk := testutil.NewBeaconBlockAltair()
 	blk.Block.Body.Graffiti = validator.graffiti
-	m.validatorClient.EXPECT().GetBlockAltair(
+	m.validatorClient.EXPECT().GetBeaconBlock(
 		gomock.Any(), // ctx
 		gomock.Any(),
-	).Return(blk.Block, nil /*err*/)
+	).Return(&ethpb.GenericBeaconBlock{
+		Block: &ethpb.GenericBeaconBlock_Altair{
+			Altair: blk.Block,
+		},
+	}, nil /*err*/)
 
 	m.validatorClient.EXPECT().DomainData(
 		gomock.Any(), // ctx
 		gomock.Any(), // epoch
 	).Return(&ethpb.DomainResponse{SignatureDomain: make([]byte, 32)}, nil /*err*/)
 
-	var sentBlock *ethpb.SignedBeaconBlockAltair
+	var sentBlock *ethpb.GenericSignedBeaconBlock
 
-	m.validatorClient.EXPECT().ProposeBlockAltair(
+	m.validatorClient.EXPECT().ProposeBeaconBlock(
 		gomock.Any(), // ctx
-		gomock.AssignableToTypeOf(&ethpb.SignedBeaconBlockAltair{}),
-	).DoAndReturn(func(ctx context.Context, block *ethpb.SignedBeaconBlockAltair, opts ...grpc.CallOption) (*ethpb.ProposeResponse, error) {
+		gomock.AssignableToTypeOf(&ethpb.GenericSignedBeaconBlock{}),
+	).DoAndReturn(func(ctx context.Context, block *ethpb.GenericSignedBeaconBlock, opts ...grpc.CallOption) (*ethpb.ProposeResponse, error) {
 		sentBlock = block
 		return &ethpb.ProposeResponse{BlockRoot: make([]byte, 32)}, nil
 	})
 
 	validator.ProposeBlock(context.Background(), 2*params.BeaconConfig().SlotsPerEpoch, pubKey)
-	assert.Equal(t, string(validator.graffiti), string(sentBlock.Block.Body.Graffiti))
+	altairBlk := sentBlock.Block.(*ethpb.GenericSignedBeaconBlock_Altair).Altair.Block
+	assert.Equal(t, string(validator.graffiti), string(altairBlk.Body.Graffiti))
 }
 
 func TestProposeExit_ValidatorIndexFailed(t *testing.T) {