validator REST: attestation v2

CHANGELOG.md

@@ -24,6 +24,7 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Added GetAggregatedAttestationV2 endpoint.
 - Added SubmitAttestationsV2 endpoint.
 - Validator REST mode Electra block support
+- Added Validator REST mode use of Attestation V2 endpoints and Electra attestations
 
 ### Changed
 

validator/client/beacon-api/beacon_api_validator_client.go

@@ -155,7 +155,12 @@ func (c *beaconApiValidatorClient) ProposeAttestation(ctx context.Context, in *e
 }
 
 func (c *beaconApiValidatorClient) ProposeAttestationElectra(ctx context.Context, in *ethpb.AttestationElectra) (*ethpb.AttestResponse, error) {
-	return nil, errors.New("ProposeAttestationElectra is not implemented")
+	ctx, span := trace.StartSpan(ctx, "beacon-api.ProposeAttestationElectra")
+	defer span.End()
+
+	return wrapInMetrics[*ethpb.AttestResponse]("ProposeAttestationElectra", func() (*ethpb.AttestResponse, error) {
+		return c.proposeAttestationElectra(ctx, in)
+	})
 }
 
 func (c *beaconApiValidatorClient) ProposeBeaconBlock(ctx context.Context, in *ethpb.GenericSignedBeaconBlock) (*ethpb.ProposeResponse, error) {
@@ -190,7 +195,12 @@ func (c *beaconApiValidatorClient) SubmitAggregateSelectionProof(ctx context.Con
 }
 
 func (c *beaconApiValidatorClient) SubmitAggregateSelectionProofElectra(ctx context.Context, in *ethpb.AggregateSelectionRequest, index primitives.ValidatorIndex, committeeLength uint64) (*ethpb.AggregateSelectionElectraResponse, error) {
-	return nil, errors.New("SubmitAggregateSelectionProofElectra is not implemented")
+	ctx, span := trace.StartSpan(ctx, "beacon-api.SubmitAggregateSelectionProofElectra")
+	defer span.End()
+
+	return wrapInMetrics[*ethpb.AggregateSelectionElectraResponse]("SubmitAggregateSelectionProofElectra", func() (*ethpb.AggregateSelectionElectraResponse, error) {
+		return c.submitAggregateSelectionProofElectra(ctx, in, index, committeeLength)
+	})
 }
 
 func (c *beaconApiValidatorClient) SubmitSignedAggregateSelectionProof(ctx context.Context, in *ethpb.SignedAggregateSubmitRequest) (*ethpb.SignedAggregateSubmitResponse, error) {
@@ -203,7 +213,12 @@ func (c *beaconApiValidatorClient) SubmitSignedAggregateSelectionProof(ctx conte
 }
 
 func (c *beaconApiValidatorClient) SubmitSignedAggregateSelectionProofElectra(ctx context.Context, in *ethpb.SignedAggregateSubmitElectraRequest) (*ethpb.SignedAggregateSubmitResponse, error) {
-	return nil, errors.New("SubmitSignedAggregateSelectionProofElectra is not implemented")
+	ctx, span := trace.StartSpan(ctx, "beacon-api.SubmitSignedAggregateSelectionProofElectra")
+	defer span.End()
+
+	return wrapInMetrics[*ethpb.SignedAggregateSubmitResponse]("SubmitSignedAggregateSelectionProofElectra", func() (*ethpb.SignedAggregateSubmitResponse, error) {
+		return c.submitSignedAggregateSelectionProofElectra(ctx, in)
+	})
 }
 
 func (c *beaconApiValidatorClient) SubmitSignedContributionAndProof(ctx context.Context, in *ethpb.SignedContributionAndProof) (*empty.Empty, error) {

validator/client/beacon-api/beacon_block_json_helpers.go

@@ -51,6 +51,14 @@ func jsonifyAttestations(attestations []*ethpb.Attestation) []*structs.Attestati
 	return jsonAttestations
 }
 
+func jsonifyAttestationsElectra(attestations []*ethpb.AttestationElectra) []*structs.AttestationElectra {
+	jsonAttestations := make([]*structs.AttestationElectra, len(attestations))
+	for index, attestation := range attestations {
+		jsonAttestations[index] = jsonifyAttestationElectra(attestation)
+	}
+	return jsonAttestations
+}
+
 func jsonifyAttesterSlashings(attesterSlashings []*ethpb.AttesterSlashing) []*structs.AttesterSlashing {
 	jsonAttesterSlashings := make([]*structs.AttesterSlashing, len(attesterSlashings))
 	for index, attesterSlashing := range attesterSlashings {
@@ -164,6 +172,15 @@ func jsonifyAttestation(attestation *ethpb.Attestation) *structs.Attestation {
 	}
 }
 
+func jsonifyAttestationElectra(attestation *ethpb.AttestationElectra) *structs.AttestationElectra {
+	return &structs.AttestationElectra{
+		AggregationBits: hexutil.Encode(attestation.AggregationBits),
+		Data:            jsonifyAttestationData(attestation.Data),
+		Signature:       hexutil.Encode(attestation.Signature),
+		CommitteeBits:   hexutil.Encode(attestation.CommitteeBits),
+	}
+}
+
 func jsonifySignedAggregateAndProof(signedAggregateAndProof *ethpb.SignedAggregateAttestationAndProof) *structs.SignedAggregateAttestationAndProof {
 	return &structs.SignedAggregateAttestationAndProof{
 		Message: &structs.AggregateAttestationAndProof{
@@ -175,6 +192,17 @@ func jsonifySignedAggregateAndProof(signedAggregateAndProof *ethpb.SignedAggrega
 	}
 }
 
+func jsonifySignedAggregateAndProofElectra(signedAggregateAndProof *ethpb.SignedAggregateAttestationAndProofElectra) *structs.SignedAggregateAttestationAndProofElectra {
+	return &structs.SignedAggregateAttestationAndProofElectra{
+		Message: &structs.AggregateAttestationAndProofElectra{
+			AggregatorIndex: uint64ToString(signedAggregateAndProof.Message.AggregatorIndex),
+			Aggregate:       jsonifyAttestationElectra(signedAggregateAndProof.Message.Aggregate),
+			SelectionProof:  hexutil.Encode(signedAggregateAndProof.Message.SelectionProof),
+		},
+		Signature: hexutil.Encode(signedAggregateAndProof.Signature),
+	}
+}
+
 func jsonifyWithdrawals(withdrawals []*enginev1.Withdrawal) []*structs.Withdrawal {
 	jsonWithdrawals := make([]*structs.Withdrawal, len(withdrawals))
 	for index, withdrawal := range withdrawals {

validator/client/beacon-api/beacon_block_proto_helpers.go

@@ -197,6 +197,39 @@ func convertAttestationToProto(jsonAttestation *structs.Attestation) (*ethpb.Att
 	}, nil
 }
 
+func convertAttestationElectraToProto(jsonAttestation *structs.AttestationElectra) (*ethpb.AttestationElectra, error) {
+	if jsonAttestation == nil {
+		return nil, errors.New("json attestation is nil")
+	}
+
+	aggregationBits, err := hexutil.Decode(jsonAttestation.AggregationBits)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to decode aggregation bits `%s`", jsonAttestation.AggregationBits)
+	}
+
+	attestationData, err := convertAttestationDataToProto(jsonAttestation.Data)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to get attestation data")
+	}
+
+	signature, err := hexutil.Decode(jsonAttestation.Signature)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to decode attestation signature `%s`", jsonAttestation.Signature)
+	}
+
+	committeeBits, err := hexutil.Decode(jsonAttestation.CommitteeBits)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to decode committee bits `%s`", jsonAttestation.CommitteeBits)
+	}
+
+	return &ethpb.AttestationElectra{
+		AggregationBits: aggregationBits,
+		Data:            attestationData,
+		Signature:       signature,
+		CommitteeBits:   committeeBits,
+	}, nil
+}
+
 func convertAttestationsToProto(jsonAttestations []*structs.Attestation) ([]*ethpb.Attestation, error) {
 	var attestations []*ethpb.Attestation
 	for index, jsonAttestation := range jsonAttestations {

validator/client/beacon-api/propose_attestation.go

@@ -10,7 +10,10 @@ import (
 )
 
 func (c *beaconApiValidatorClient) proposeAttestation(ctx context.Context, attestation *ethpb.Attestation) (*ethpb.AttestResponse, error) {
-	if err := checkNilAttestation(attestation); err != nil {
+	if attestation == nil {
+		return nil, errors.New("attestation is nil")
+	}
+	if err := checkNilContentsAttestation(attestation); err != nil {
 		return nil, err
 	}
 
@@ -37,27 +40,57 @@ func (c *beaconApiValidatorClient) proposeAttestation(ctx context.Context, attes
 	return &ethpb.AttestResponse{AttestationDataRoot: attestationDataRoot[:]}, nil
 }
 
-// checkNilAttestation returns error if attestation or any field of attestation is nil.
-func checkNilAttestation(attestation *ethpb.Attestation) error {
-	if attestation == nil {
-		return errors.New("attestation is nil")
-	}
-
-	if attestation.Data == nil {
+// checkNilContentsAttestation returns error if attestation or any field of attestation is nil.
+func checkNilContentsAttestation(attestation ethpb.Att) error {
+	if attestation.GetData() == nil {
 		return errors.New("attestation data is nil")
 	}
 
-	if attestation.Data.Source == nil || attestation.Data.Target == nil {
+	if attestation.GetData().Source == nil || attestation.GetData().Target == nil {
 		return errors.New("source/target in attestation data is nil")
 	}
 
-	if len(attestation.AggregationBits) == 0 {
+	if len(attestation.GetAggregationBits()) == 0 {
 		return errors.New("attestation aggregation bits is empty")
 	}
 
-	if len(attestation.Signature) == 0 {
+	if len(attestation.GetSignature()) == 0 {
 		return errors.New("attestation signature is empty")
 	}
 
 	return nil
 }
+
+func (c *beaconApiValidatorClient) proposeAttestationElectra(ctx context.Context, attestation *ethpb.AttestationElectra) (*ethpb.AttestResponse, error) {
+	if attestation == nil {
+		return nil, errors.New("attestation is nil")
+	}
+	if err := checkNilContentsAttestation(attestation); err != nil {
+		return nil, err
+	}
+	if len(attestation.CommitteeBits) == 0 {
+		return nil, errors.New("attestation committee bits is empty")
+	}
+
+	marshalledAttestation, err := json.Marshal(jsonifyAttestationsElectra([]*ethpb.AttestationElectra{attestation}))
+	if err != nil {
+		return nil, err
+	}
+
+	if err = c.jsonRestHandler.Post(
+		ctx,
+		"/eth/v2/beacon/pool/attestations",
+		nil,
+		bytes.NewBuffer(marshalledAttestation),
+		nil,
+	); err != nil {
+		return nil, err
+	}
+
+	attestationDataRoot, err := attestation.Data.HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to compute attestation data root")
+	}
+
+	return &ethpb.AttestResponse{AttestationDataRoot: attestationDataRoot[:]}, nil
+}

validator/client/beacon-api/propose_attestation_test.go

@@ -117,7 +117,7 @@ func TestProposeAttestation(t *testing.T) {
 			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			var marshalledAttestations []byte
-			if checkNilAttestation(test.attestation) == nil {
+			if checkNilContentsAttestation(test.attestation) == nil {
 				b, err := json.Marshal(jsonifyAttestations([]*ethpb.Attestation{test.attestation}))
 				require.NoError(t, err)
 				marshalledAttestations = b
@@ -153,3 +153,169 @@ func TestProposeAttestation(t *testing.T) {
 		})
 	}
 }
+
+func TestProposeAttestationElectra(t *testing.T) {
+	attestation := &ethpb.AttestationElectra{
+		AggregationBits: testhelpers.FillByteSlice(4, 74),
+		Data: &ethpb.AttestationData{
+			Slot:            75,
+			CommitteeIndex:  76,
+			BeaconBlockRoot: testhelpers.FillByteSlice(32, 38),
+			Source: &ethpb.Checkpoint{
+				Epoch: 78,
+				Root:  testhelpers.FillByteSlice(32, 79),
+			},
+			Target: &ethpb.Checkpoint{
+				Epoch: 80,
+				Root:  testhelpers.FillByteSlice(32, 81),
+			},
+		},
+		Signature:     testhelpers.FillByteSlice(96, 82),
+		CommitteeBits: testhelpers.FillByteSlice(8, 83),
+	}
+
+	tests := []struct {
+		name                 string
+		attestation          *ethpb.AttestationElectra
+		expectedErrorMessage string
+		endpointError        error
+		endpointCall         int
+	}{
+		{
+			name:         "valid",
+			attestation:  attestation,
+			endpointCall: 1,
+		},
+		{
+			name:                 "nil attestation",
+			expectedErrorMessage: "attestation is nil",
+		},
+		{
+			name: "nil attestation data",
+			attestation: &ethpb.AttestationElectra{
+				AggregationBits: testhelpers.FillByteSlice(4, 74),
+				Signature:       testhelpers.FillByteSlice(96, 82),
+				CommitteeBits:   testhelpers.FillByteSlice(8, 83),
+			},
+			expectedErrorMessage: "attestation data is nil",
+		},
+		{
+			name: "nil source checkpoint",
+			attestation: &ethpb.AttestationElectra{
+				AggregationBits: testhelpers.FillByteSlice(4, 74),
+				Data: &ethpb.AttestationData{
+					Target: &ethpb.Checkpoint{},
+				},
+				Signature:     testhelpers.FillByteSlice(96, 82),
+				CommitteeBits: testhelpers.FillByteSlice(8, 83),
+			},
+			expectedErrorMessage: "source/target in attestation data is nil",
+		},
+		{
+			name: "nil target checkpoint",
+			attestation: &ethpb.AttestationElectra{
+				AggregationBits: testhelpers.FillByteSlice(4, 74),
+				Data: &ethpb.AttestationData{
+					Source: &ethpb.Checkpoint{},
+				},
+				Signature:     testhelpers.FillByteSlice(96, 82),
+				CommitteeBits: testhelpers.FillByteSlice(8, 83),
+			},
+			expectedErrorMessage: "source/target in attestation data is nil",
+		},
+		{
+			name: "nil aggregation bits",
+			attestation: &ethpb.AttestationElectra{
+				Data: &ethpb.AttestationData{
+					Source: &ethpb.Checkpoint{},
+					Target: &ethpb.Checkpoint{},
+				},
+				Signature:     testhelpers.FillByteSlice(96, 82),
+				CommitteeBits: testhelpers.FillByteSlice(8, 83),
+			},
+			expectedErrorMessage: "attestation aggregation bits is empty",
+		},
+		{
+			name: "nil signature",
+			attestation: &ethpb.AttestationElectra{
+				AggregationBits: testhelpers.FillByteSlice(4, 74),
+				Data: &ethpb.AttestationData{
+					Source: &ethpb.Checkpoint{},
+					Target: &ethpb.Checkpoint{},
+				},
+				CommitteeBits: testhelpers.FillByteSlice(8, 83),
+			},
+			expectedErrorMessage: "attestation signature is empty",
+		},
+		{
+			name: "nil committee bits",
+			attestation: &ethpb.AttestationElectra{
+				AggregationBits: testhelpers.FillByteSlice(4, 74),
+				Data: &ethpb.AttestationData{
+					Slot:            75,
+					CommitteeIndex:  76,
+					BeaconBlockRoot: testhelpers.FillByteSlice(32, 38),
+					Source: &ethpb.Checkpoint{
+						Epoch: 78,
+						Root:  testhelpers.FillByteSlice(32, 79),
+					},
+					Target: &ethpb.Checkpoint{
+						Epoch: 80,
+						Root:  testhelpers.FillByteSlice(32, 81),
+					},
+				},
+				Signature: testhelpers.FillByteSlice(96, 82),
+			},
+			expectedErrorMessage: "attestation committee bits is empty",
+		},
+		{
+			name:                 "bad request",
+			attestation:          attestation,
+			expectedErrorMessage: "bad request",
+			endpointError:        errors.New("bad request"),
+			endpointCall:         1,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			ctrl := gomock.NewController(t)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+
+			var marshalledAttestations []byte
+			if checkNilContentsAttestation(test.attestation) == nil {
+				b, err := json.Marshal(jsonifyAttestationsElectra([]*ethpb.AttestationElectra{test.attestation}))
+				require.NoError(t, err)
+				marshalledAttestations = b
+			}
+
+			ctx := context.Background()
+
+			jsonRestHandler.EXPECT().Post(
+				gomock.Any(),
+				"/eth/v2/beacon/pool/attestations",
+				nil,
+				bytes.NewBuffer(marshalledAttestations),
+				nil,
+			).Return(
+				test.endpointError,
+			).Times(test.endpointCall)
+
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+			proposeResponse, err := validatorClient.proposeAttestationElectra(ctx, test.attestation)
+			if test.expectedErrorMessage != "" {
+				require.ErrorContains(t, test.expectedErrorMessage, err)
+				return
+			}
+
+			require.NoError(t, err)
+			require.NotNil(t, proposeResponse)
+
+			expectedAttestationDataRoot, err := attestation.Data.HashTreeRoot()
+			require.NoError(t, err)
+
+			// Make sure that the attestation data root is set
+			assert.DeepEqual(t, expectedAttestationDataRoot[:], proposeResponse.AttestationDataRoot)
+		})
+	}
+}