Merge pull request #5186 from multiversx/update-rc-v1.6.0-rc-v1.5.0-2…

…023.04.21

Update rc v1.6.0 rc v1.5.0 2023.04.21

api/errors/errors.go

@@ -31,6 +31,9 @@ var ErrGetKeyValuePairs = errors.New("get key-value pairs error")
 // ErrGetESDTBalance signals an error in getting esdt balance for given address
 var ErrGetESDTBalance = errors.New("get esdt balance for account error")
 
+// ErrGetGuardianData signals an error in getting the guardian data for given address
+var ErrGetGuardianData = errors.New("get guardian data for account error")
+
 // ErrGetRolesForAccount signals an error in getting esdt tokens and roles for a given address
 var ErrGetRolesForAccount = errors.New("get roles for account error")
 

api/groups/addressGroup.go

@@ -30,6 +30,7 @@ const (
 	getESDTsRolesPath         = "/:address/esdts/roles"
 	getRegisteredNFTsPath     = "/:address/registered-nfts"
 	getESDTNFTDataPath        = "/:address/nft/:tokenIdentifier/nonce/:nonce"
+	getGuardianData           = "/:address/guardian-data"
 	urlParamOnFinalBlock      = "onFinalBlock"
 	urlParamOnStartOfEpoch    = "onStartOfEpoch"
 	urlParamBlockNonce        = "blockNonce"
@@ -52,6 +53,7 @@ type addressFacadeHandler interface {
 	GetESDTsWithRole(address string, role string, options api.AccountQueryOptions) ([]string, api.BlockInfo, error)
 	GetAllESDTTokens(address string, options api.AccountQueryOptions) (map[string]*esdt.ESDigitalToken, api.BlockInfo, error)
 	GetKeyValuePairs(address string, options api.AccountQueryOptions) (map[string]string, api.BlockInfo, error)
+	GetGuardianData(address string, options api.AccountQueryOptions) (api.GuardianData, api.BlockInfo, error)
 	IsInterfaceNil() bool
 }
 
@@ -157,6 +159,11 @@ func NewAddressGroup(facade addressFacadeHandler) (*addressGroup, error) {
 			Method:  http.MethodGet,
 			Handler: ag.getESDTsRoles,
 		},
+		{
+			Path:    getGuardianData,
+			Method:  http.MethodGet,
+			Handler: ag.getGuardianData,
+		},
 	}
 	ag.endpoints = endpoints
 
@@ -309,6 +316,29 @@ func (ag *addressGroup) getValueForKey(c *gin.Context) {
 	shared.RespondWithSuccess(c, gin.H{"value": value, "blockInfo": blockInfo})
 }
 
+// getGuardianData returns the guardian data and guarded state for a given account
+func (ag *addressGroup) getGuardianData(c *gin.Context) {
+	addr := c.Param("address")
+	if addr == "" {
+		shared.RespondWithValidationError(c, errors.ErrGetGuardianData, errors.ErrEmptyAddress)
+		return
+	}
+
+	options, err := extractAccountQueryOptions(c)
+	if err != nil {
+		shared.RespondWithValidationError(c, errors.ErrGetGuardianData, err)
+		return
+	}
+
+	guardianData, blockInfo, err := ag.getFacade().GetGuardianData(addr, options)
+	if err != nil {
+		shared.RespondWithInternalError(c, errors.ErrGetGuardianData, err)
+		return
+	}
+
+	shared.RespondWithSuccess(c, gin.H{"guardianData": guardianData, "blockInfo": blockInfo})
+}
+
 // addressGroup returns all the key-value pairs for the given address
 func (ag *addressGroup) getKeyValuePairs(c *gin.Context) {
 	addr := c.Param("address")

api/groups/addressGroup_test.go

@@ -95,6 +95,16 @@ type esdtTokenResponse struct {
 	Code  string                `json:"code"`
 }
 
+type guardianDataResponseData struct {
+	GuardianData api.GuardianData `json:"guardianData"`
+}
+
+type guardianDataResponse struct {
+	Data  guardianDataResponseData `json:"data"`
+	Error string                   `json:"error"`
+	Code  string                   `json:"code"`
+}
+
 type esdtNFTResponse struct {
 	Data  esdtNFTResponseData `json:"data"`
 	Error string              `json:"error"`
@@ -1047,6 +1057,86 @@ func TestGetKeyValuePairs_ShouldWork(t *testing.T) {
 	assert.Equal(t, pairs, response.Data.Pairs)
 }
 
+func TestGetGuardianData(t *testing.T) {
+	t.Parallel()
+
+	testAddress := "address"
+	t.Run("with empty address should err", func(t *testing.T) {
+		facade := mock.FacadeStub{}
+		addrGroup, err := groups.NewAddressGroup(&facade)
+		require.Nil(t, err)
+
+		ws := startWebServer(addrGroup, "address", getAddressRoutesConfig())
+
+		emptyAddress := ""
+		req, _ := http.NewRequest("GET", fmt.Sprintf("/address/%s/guardian-data", emptyAddress), nil)
+		resp := httptest.NewRecorder()
+		ws.ServeHTTP(resp, req)
+
+		response := shared.GenericAPIResponse{}
+		loadResponse(resp.Body, &response)
+		assert.Equal(t, http.StatusBadRequest, resp.Code)
+		assert.NotEmpty(t, response)
+		assert.True(t, strings.Contains(response.Error,
+			fmt.Sprintf("%s: %s", apiErrors.ErrGetGuardianData.Error(), apiErrors.ErrEmptyAddress.Error()),
+		))
+	})
+	t.Run("with node fail should err", func(t *testing.T) {
+		expectedErr := errors.New("expected error")
+		facade := mock.FacadeStub{
+			GetGuardianDataCalled: func(address string, options api.AccountQueryOptions) (api.GuardianData, api.BlockInfo, error) {
+				return api.GuardianData{}, api.BlockInfo{}, expectedErr
+			},
+		}
+		addrGroup, err := groups.NewAddressGroup(&facade)
+		require.NoError(t, err)
+
+		ws := startWebServer(addrGroup, "address", getAddressRoutesConfig())
+
+		req, _ := http.NewRequest("GET", fmt.Sprintf("/address/%s/guardian-data", testAddress), nil)
+		resp := httptest.NewRecorder()
+		ws.ServeHTTP(resp, req)
+
+		response := &shared.GenericAPIResponse{}
+		loadResponse(resp.Body, &response)
+		assert.Equal(t, http.StatusInternalServerError, resp.Code)
+		assert.True(t, strings.Contains(response.Error, expectedErr.Error()))
+
+	})
+	t.Run("should work", func(t *testing.T) {
+		expectedGuardianData := api.GuardianData{
+			ActiveGuardian: &api.Guardian{
+				Address:         "guardian1",
+				ActivationEpoch: 0,
+			},
+			PendingGuardian: &api.Guardian{
+				Address:         "guardian2",
+				ActivationEpoch: 10,
+			},
+			Guarded: true,
+		}
+		facade := mock.FacadeStub{
+			GetGuardianDataCalled: func(address string, options api.AccountQueryOptions) (api.GuardianData, api.BlockInfo, error) {
+				return expectedGuardianData, api.BlockInfo{}, nil
+			},
+		}
+
+		addrGroup, err := groups.NewAddressGroup(&facade)
+		require.NoError(t, err)
+
+		ws := startWebServer(addrGroup, "address", getAddressRoutesConfig())
+
+		req, _ := http.NewRequest("GET", fmt.Sprintf("/address/%s/guardian-data", testAddress), nil)
+		resp := httptest.NewRecorder()
+		ws.ServeHTTP(resp, req)
+
+		response := guardianDataResponse{}
+		loadResponse(resp.Body, &response)
+		assert.Equal(t, http.StatusOK, resp.Code)
+		assert.Equal(t, expectedGuardianData, response.Data.GuardianData)
+	})
+}
+
 func TestGetESDTsRoles_WithEmptyAddressShouldReturnError(t *testing.T) {
 	t.Parallel()
 	facade := mock.FacadeStub{}
@@ -1180,6 +1270,7 @@ func getAddressRoutesConfig() config.ApiRoutesConfig {
 				Routes: []config.RouteConfig{
 					{Name: "/:address", Open: true},
 					{Name: "/bulk", Open: true},
+					{Name: "/:address/guardian-data", Open: true},
 					{Name: "/:address/balance", Open: true},
 					{Name: "/:address/username", Open: true},
 					{Name: "/:address/code-hash", Open: true},

api/groups/networkGroup_test.go

@@ -180,6 +180,36 @@ func TestGetNetworkStatus_ShouldReturnErrorIfFacadeReturnsError(t *testing.T) {
 	assert.Equal(t, expectedErr.Error(), response.Error)
 }
 
+func TestNetworkConfigMetrics_GasLimitGuardedTxShouldWork(t *testing.T) {
+	t.Parallel()
+
+	statusMetricsProvider := statusHandler.NewStatusMetrics()
+	key := common.MetricExtraGasLimitGuardedTx
+	value := uint64(37)
+	statusMetricsProvider.SetUInt64Value(key, value)
+
+	facade := mock.FacadeStub{}
+	facade.StatusMetricsHandler = func() external.StatusMetricsHandler {
+		return statusMetricsProvider
+	}
+
+	networkGroup, err := groups.NewNetworkGroup(&facade)
+	require.NoError(t, err)
+
+	ws := startWebServer(networkGroup, "network", getNetworkRoutesConfig())
+
+	req, _ := http.NewRequest("GET", "/network/config", nil)
+	resp := httptest.NewRecorder()
+	ws.ServeHTTP(resp, req)
+
+	respBytes, _ := ioutil.ReadAll(resp.Body)
+	respStr := string(respBytes)
+	assert.Equal(t, resp.Code, http.StatusOK)
+
+	keyAndValueFoundInResponse := strings.Contains(respStr, key) && strings.Contains(respStr, fmt.Sprintf("%d", value))
+	assert.True(t, keyAndValueFoundInResponse)
+}
+
 func TestNetworkStatusMetrics_ShouldWork(t *testing.T) {
 	t.Parallel()