Add /eth/v2/validator/aggregate_attestation

CHANGELOG.md

@@ -15,6 +15,7 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Light client support: Implement capella and deneb changes.
 - Light client support: Implement `BlockToLightClientHeaderXXX` functions upto Deneb
 - GetBeaconStateV2: add Electra case.
+- Added GetAggregatedAttestationsV2 endpoint.
 
 ### Changed
 

api/server/structs/endpoints_validator.go

@@ -10,6 +10,11 @@ type AggregateAttestationResponse struct {
 	Data *Attestation `json:"data"`
 }
 
+type AggregateAttestationV2Response struct {
+	Version string       `json:"version"`
+	Data    *Attestation `json:"data"`
+}
+
 type SubmitContributionAndProofsRequest struct {
 	Data []*SignedContributionAndProof `json:"data"`
 }

beacon-chain/rpc/endpoints.go

@@ -199,6 +199,15 @@ func (s *Service) validatorEndpoints(
 			handler: server.GetAggregateAttestation,
 			methods: []string{http.MethodGet},
 		},
+		{
+			template: "/eth/v2/validator/aggregate_attestation",
+			name:     namespace + ".GetAggregateAttestationV2",
+			middleware: []middleware.Middleware{
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+			},
+			handler: server.GetAggregateAttestationV2,
+			methods: []string{http.MethodGet},
+		},
 		{
 			template: "/eth/v1/validator/contribution_and_proofs",
 			name:     namespace + ".SubmitContributionAndProofs",

beacon-chain/rpc/endpoints_test.go

@@ -98,6 +98,7 @@ func Test_endpoints(t *testing.T) {
 		"/eth/v1/validator/blinded_blocks/{slot}":          {http.MethodGet},
 		"/eth/v1/validator/attestation_data":               {http.MethodGet},
 		"/eth/v1/validator/aggregate_attestation":          {http.MethodGet},
+		"/eth/v2/validator/aggregate_attestation":          {http.MethodGet},
 		"/eth/v1/validator/aggregate_and_proofs":           {http.MethodPost},
 		"/eth/v1/validator/beacon_committee_subscriptions": {http.MethodPost},
 		"/eth/v1/validator/sync_committee_subscriptions":   {http.MethodPost},

beacon-chain/rpc/eth/validator/handlers.go

@@ -31,6 +31,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	ethpbalpha "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
 	"google.golang.org/grpc/codes"
@@ -52,32 +53,57 @@ func (s *Server) GetAggregateAttestation(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
-	var match ethpbalpha.Att
-	var err error
+	match := s.aggregateAttestation(w, slot, 0, attDataRoot)
+	if match == nil {
+		return
+	}
+	response := &structs.AggregateAttestationResponse{
+		Data: &structs.Attestation{
+			AggregationBits: hexutil.Encode(match.GetAggregationBits()),
+			Data: &structs.AttestationData{
+				Slot:            strconv.FormatUint(uint64(match.GetData().Slot), 10),
+				CommitteeIndex:  strconv.FormatUint(uint64(match.GetData().CommitteeIndex), 10),
+				BeaconBlockRoot: hexutil.Encode(match.GetData().BeaconBlockRoot),
+				Source: &structs.Checkpoint{
+					Epoch: strconv.FormatUint(uint64(match.GetData().Source.Epoch), 10),
+					Root:  hexutil.Encode(match.GetData().Source.Root),
+				},
+				Target: &structs.Checkpoint{
+					Epoch: strconv.FormatUint(uint64(match.GetData().Target.Epoch), 10),
+					Root:  hexutil.Encode(match.GetData().Target.Root),
+				},
+			},
+			Signature: hexutil.Encode(match.GetSignature()),
+		}}
+	httputil.WriteJson(w, response)
+}
 
-	match, err = matchingAtt(s.AttestationsPool.AggregatedAttestations(), primitives.Slot(slot), attDataRoot)
-	if err != nil {
-		httputil.HandleError(w, "Could not get matching attestation: "+err.Error(), http.StatusInternalServerError)
+// GetAggregateAttestationV2 aggregates all attestations matching the given attestation data root and slot, returning the aggregated result.
+func (s *Server) GetAggregateAttestationV2(w http.ResponseWriter, r *http.Request) {
+	_, span := trace.StartSpan(r.Context(), "validator.GetAggregateAttestation")
+	defer span.End()
+
+	_, attDataRoot, ok := shared.HexFromQuery(w, r, "attestation_data_root", fieldparams.RootLength, true)
+	if !ok {
 		return
 	}
-	if match == nil {
-		atts, err := s.AttestationsPool.UnaggregatedAttestations()
-		if err != nil {
-			httputil.HandleError(w, "Could not get unaggregated attestations: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-		match, err = matchingAtt(atts, primitives.Slot(slot), attDataRoot)
-		if err != nil {
-			httputil.HandleError(w, "Could not get matching attestation: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
+
+	_, slot, ok := shared.UintFromQuery(w, r, "slot", true)
+	if !ok {
+		return
 	}
-	if match == nil {
-		httputil.HandleError(w, "No matching attestation found", http.StatusNotFound)
+
+	_, index, ok := shared.UintFromQuery(w, r, "committee_index", true)
+	if !ok {
 		return
 	}
 
-	response := &structs.AggregateAttestationResponse{
+	match := s.aggregateAttestation(w, slot, index, attDataRoot)
+	if match == nil {
+		return
+	}
+	response := &structs.AggregateAttestationV2Response{
+		Version: version.String(match.Version()),
 		Data: &structs.Attestation{
 			AggregationBits: hexutil.Encode(match.GetAggregationBits()),
 			Data: &structs.AttestationData{
@@ -98,15 +124,49 @@ func (s *Server) GetAggregateAttestation(w http.ResponseWriter, r *http.Request)
 	httputil.WriteJson(w, response)
 }
 
-func matchingAtt(atts []ethpbalpha.Att, slot primitives.Slot, attDataRoot []byte) (ethpbalpha.Att, error) {
+func (s *Server) aggregateAttestation(w http.ResponseWriter, slot, index uint64, attDataRoot []byte) ethpbalpha.Att {
+	var match ethpbalpha.Att
+	var err error
+
+	match, err = matchingAtt(s.AttestationsPool.AggregatedAttestations(), primitives.Slot(slot), attDataRoot, primitives.CommitteeIndex(index))
+	if err != nil {
+		httputil.HandleError(w, "Could not get matching attestation: "+err.Error(), http.StatusInternalServerError)
+		return nil
+	}
+	if match == nil {
+		atts, err := s.AttestationsPool.UnaggregatedAttestations()
+		if err != nil {
+			httputil.HandleError(w, "Could not get unaggregated attestations: "+err.Error(), http.StatusInternalServerError)
+			return nil
+		}
+		match, err = matchingAtt(atts, primitives.Slot(slot), attDataRoot, primitives.CommitteeIndex(index))
+		if err != nil {
+			httputil.HandleError(w, "Could not get matching attestation: "+err.Error(), http.StatusInternalServerError)
+			return nil
+		}
+	}
+	if match == nil {
+		httputil.HandleError(w, "No matching attestation found", http.StatusNotFound)
+		return nil
+	}
+	return match
+}
+
+func matchingAtt(atts []ethpbalpha.Att, slot primitives.Slot, attDataRoot []byte, index primitives.CommitteeIndex) (ethpbalpha.Att, error) {
 	for _, att := range atts {
 		if att.GetData().Slot == slot {
 			root, err := att.GetData().HashTreeRoot()
 			if err != nil {
 				return nil, errors.Wrap(err, "could not get attestation data root")
 			}
-			if bytes.Equal(root[:], attDataRoot) {
-				return att, nil
+			if index == 0 {
+				if bytes.Equal(root[:], attDataRoot) {
+					return att, nil
+				}
+			} else {
+				if bytes.Equal(root[:], attDataRoot) && att.GetData().CommitteeIndex == index {
+					return att, nil
+				}
 			}
 		}
 	}

beacon-chain/rpc/eth/validator/handlers_test.go

@@ -178,6 +178,33 @@ func TestGetAggregateAttestation(t *testing.T) {
 		assert.Equal(t, "1", resp.Data.Data.Target.Epoch)
 		assert.DeepEqual(t, hexutil.Encode(root22), resp.Data.Data.Target.Root)
 	})
+	t.Run("matching aggregated att V2", func(t *testing.T) {
+		reqRoot, err := attslot22.Data.HashTreeRoot()
+		require.NoError(t, err)
+		attDataRoot := hexutil.Encode(reqRoot[:])
+		url := "http://example.com?attestation_data_root=" + attDataRoot + "&slot=2" + "&committee_index=1"
+		request := httptest.NewRequest(http.MethodGet, url, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetAggregateAttestationV2(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.AggregateAttestationV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.NotNil(t, resp)
+		require.NotNil(t, resp.Data)
+		assert.DeepEqual(t, "0x00010101", resp.Data.AggregationBits)
+		assert.DeepEqual(t, hexutil.Encode(sig22), resp.Data.Signature)
+		assert.Equal(t, "2", resp.Data.Data.Slot)
+		assert.Equal(t, "1", resp.Data.Data.CommitteeIndex)
+		assert.DeepEqual(t, hexutil.Encode(root22), resp.Data.Data.BeaconBlockRoot)
+		require.NotNil(t, resp.Data.Data.Source)
+		assert.Equal(t, "1", resp.Data.Data.Source.Epoch)
+		assert.DeepEqual(t, hexutil.Encode(root22), resp.Data.Data.Source.Root)
+		require.NotNil(t, resp.Data.Data.Target)
+		assert.Equal(t, "1", resp.Data.Data.Target.Epoch)
+		assert.DeepEqual(t, hexutil.Encode(root22), resp.Data.Data.Target.Root)
+	})
 	t.Run("matching unaggregated att", func(t *testing.T) {
 		reqRoot, err := attslot32.Data.HashTreeRoot()
 		require.NoError(t, err)
@@ -205,6 +232,33 @@ func TestGetAggregateAttestation(t *testing.T) {
 		assert.Equal(t, "1", resp.Data.Data.Target.Epoch)
 		assert.DeepEqual(t, hexutil.Encode(root32), resp.Data.Data.Target.Root)
 	})
+	t.Run("matching unaggregated att V2", func(t *testing.T) {
+		reqRoot, err := attslot32.Data.HashTreeRoot()
+		require.NoError(t, err)
+		attDataRoot := hexutil.Encode(reqRoot[:])
+		url := "http://example.com?attestation_data_root=" + attDataRoot + "&slot=3" + "&committee_index=1"
+		request := httptest.NewRequest(http.MethodGet, url, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetAggregateAttestationV2(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.AggregateAttestationV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.NotNil(t, resp)
+		require.NotNil(t, resp.Data)
+		assert.DeepEqual(t, "0x0001", resp.Data.AggregationBits)
+		assert.DeepEqual(t, hexutil.Encode(sig32), resp.Data.Signature)
+		assert.Equal(t, "3", resp.Data.Data.Slot)
+		assert.Equal(t, "1", resp.Data.Data.CommitteeIndex)
+		assert.DeepEqual(t, hexutil.Encode(root32), resp.Data.Data.BeaconBlockRoot)
+		require.NotNil(t, resp.Data.Data.Source)
+		assert.Equal(t, "1", resp.Data.Data.Source.Epoch)
+		assert.DeepEqual(t, hexutil.Encode(root32), resp.Data.Data.Source.Root)
+		require.NotNil(t, resp.Data.Data.Target)
+		assert.Equal(t, "1", resp.Data.Data.Target.Epoch)
+		assert.DeepEqual(t, hexutil.Encode(root32), resp.Data.Data.Target.Root)
+	})
 	t.Run("no matching attestation", func(t *testing.T) {
 		attDataRoot := hexutil.Encode(bytesutil.PadTo([]byte("foo"), 32))
 		url := "http://example.com?attestation_data_root=" + attDataRoot + "&slot=2"
@@ -219,6 +273,23 @@ func TestGetAggregateAttestation(t *testing.T) {
 		assert.Equal(t, http.StatusNotFound, e.Code)
 		assert.Equal(t, true, strings.Contains(e.Message, "No matching attestation found"))
 	})
+	t.Run("no matching attestation V2", func(t *testing.T) {
+		//attDataRoot := hexutil.Encode(bytesutil.PadTo([]byte("foo"), 32))
+		reqRoot, err := attslot32.Data.HashTreeRoot()
+		require.NoError(t, err)
+		attDataRoot := hexutil.Encode(reqRoot[:])
+		url := "http://example.com?attestation_data_root=" + attDataRoot + "&slot=3" + "&committee_index=2"
+		request := httptest.NewRequest(http.MethodGet, url, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetAggregateAttestationV2(writer, request)
+		assert.Equal(t, http.StatusNotFound, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusNotFound, e.Code)
+		assert.Equal(t, true, strings.Contains(e.Message, "No matching attestation found"))
+	})
 	t.Run("no attestation_data_root provided", func(t *testing.T) {
 		url := "http://example.com?slot=2"
 		request := httptest.NewRequest(http.MethodGet, url, nil)
@@ -232,6 +303,19 @@ func TestGetAggregateAttestation(t *testing.T) {
 		assert.Equal(t, http.StatusBadRequest, e.Code)
 		assert.Equal(t, true, strings.Contains(e.Message, "attestation_data_root is required"))
 	})
+	t.Run("no attestation_data_root provided V2", func(t *testing.T) {
+		url := "http://example.com?slot=2"
+		request := httptest.NewRequest(http.MethodGet, url, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetAggregateAttestationV2(writer, request)
+		assert.Equal(t, http.StatusBadRequest, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusBadRequest, e.Code)
+		assert.Equal(t, true, strings.Contains(e.Message, "attestation_data_root is required"))
+	})
 	t.Run("invalid attestation_data_root provided", func(t *testing.T) {
 		url := "http://example.com?attestation_data_root=foo&slot=2"
 		request := httptest.NewRequest(http.MethodGet, url, nil)
@@ -245,6 +329,19 @@ func TestGetAggregateAttestation(t *testing.T) {
 		assert.Equal(t, http.StatusBadRequest, e.Code)
 		assert.Equal(t, true, strings.Contains(e.Message, "attestation_data_root is invalid"))
 	})
+	t.Run("invalid attestation_data_root provided V2", func(t *testing.T) {
+		url := "http://example.com?attestation_data_root=foo&slot=2&committee_index=1"
+		request := httptest.NewRequest(http.MethodGet, url, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetAggregateAttestationV2(writer, request)
+		assert.Equal(t, http.StatusBadRequest, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusBadRequest, e.Code)
+		assert.Equal(t, true, strings.Contains(e.Message, "attestation_data_root is invalid"))
+	})
 	t.Run("no slot provided", func(t *testing.T) {
 		attDataRoot := hexutil.Encode(bytesutil.PadTo([]byte("foo"), 32))
 		url := "http://example.com?attestation_data_root=" + attDataRoot
@@ -259,6 +356,20 @@ func TestGetAggregateAttestation(t *testing.T) {
 		assert.Equal(t, http.StatusBadRequest, e.Code)
 		assert.Equal(t, true, strings.Contains(e.Message, "slot is required"))
 	})
+	t.Run("no slot provided V2", func(t *testing.T) {
+		attDataRoot := hexutil.Encode(bytesutil.PadTo([]byte("foo"), 32))
+		url := "http://example.com?attestation_data_root=" + attDataRoot
+		request := httptest.NewRequest(http.MethodGet, url, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetAggregateAttestationV2(writer, request)
+		assert.Equal(t, http.StatusBadRequest, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusBadRequest, e.Code)
+		assert.Equal(t, true, strings.Contains(e.Message, "slot is required"))
+	})
 	t.Run("invalid slot provided", func(t *testing.T) {
 		attDataRoot := hexutil.Encode(bytesutil.PadTo([]byte("foo"), 32))
 		url := "http://example.com?attestation_data_root=" + attDataRoot + "&slot=foo"
@@ -273,6 +384,34 @@ func TestGetAggregateAttestation(t *testing.T) {
 		assert.Equal(t, http.StatusBadRequest, e.Code)
 		assert.Equal(t, true, strings.Contains(e.Message, "slot is invalid"))
 	})
+	t.Run("invalid slot provided V2", func(t *testing.T) {
+		attDataRoot := hexutil.Encode(bytesutil.PadTo([]byte("foo"), 32))
+		url := "http://example.com?attestation_data_root=" + attDataRoot + "&slot=foo"
+		request := httptest.NewRequest(http.MethodGet, url, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetAggregateAttestationV2(writer, request)
+		assert.Equal(t, http.StatusBadRequest, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusBadRequest, e.Code)
+		assert.Equal(t, true, strings.Contains(e.Message, "slot is invalid"))
+	})
+	t.Run("invalid committee_index provided V2", func(t *testing.T) {
+		attDataRoot := hexutil.Encode(bytesutil.PadTo([]byte("foo"), 32))
+		url := "http://example.com?attestation_data_root=" + attDataRoot + "&slot=3&committee_index=foo"
+		request := httptest.NewRequest(http.MethodGet, url, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetAggregateAttestationV2(writer, request)
+		assert.Equal(t, http.StatusBadRequest, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusBadRequest, e.Code)
+		assert.Equal(t, true, strings.Contains(e.Message, "committee_index is invalid"))
+	})
 }
 
 func TestGetAggregateAttestation_SameSlotAndRoot_ReturnMostAggregationBits(t *testing.T) {