Requested changes: Modify hex to int conversion for hex return types

utils/asset.go

@@ -335,13 +335,17 @@ func (*UtilsStruct) GetDataToCommitFromJob(job bindings.StructsJob, localCache *
 		parsedData = regexp.MustCompile(`[\p{Sc}, ]`).ReplaceAllString(dataPoint, "")
 	}
 
-	parsedDataInDecimal, err := ManageReturnType(parsedData, dataSourceURLStruct.ReturnType)
-	if err != nil {
-		log.Error("Error in converting parsed data to decimal value: ", err)
-		return nil, err
+	if strings.ToLower(dataSourceURLStruct.ReturnType) == core.HexReturnType {
+		log.Warn("RETURN TYPE FOR DATASOURCE STRUCT IS HEX")
+		parsedDataInDecimal, err := ConvertHexToInt(parsedData)
+		if err != nil {
+			log.Error("Error in converting parsed data to decimal value: ", err)
+			return nil, err
+		}
+		parsedData = parsedDataInDecimal
 	}
 
-	datum, err := ConvertToNumber(parsedDataInDecimal)
+	datum, err := ConvertToNumber(parsedData)
 	if err != nil {
 		log.Error("Result is not a number")
 		return nil, err

utils/math.go

@@ -3,11 +3,9 @@ package utils
 import (
 	"crypto/rand"
 	"errors"
-	"fmt"
 	"math"
 	"math/big"
 	mathRand "math/rand"
-	"razor/core"
 	"sort"
 	"strconv"
 	"strings"
@@ -34,20 +32,19 @@ func ConvertToNumber(num interface{}) (*big.Float, error) {
 	return big.NewFloat(0), nil
 }
 
-func ManageReturnType(num interface{}, returnType string) (interface{}, error) {
-	switch returnType {
-	case core.HexReturnType:
-		//removing "0x" from hex value
-		hexValue := strings.TrimPrefix(fmt.Sprint(num), "0x")
-		//Converting given hex value to decimal value
-		decimalValue, err := strconv.ParseUint(hexValue, 16, 64)
+func ConvertHexToInt(num interface{}) (int, error) {
+	switch v := num.(type) {
+	case string:
+		hexValue := strings.TrimPrefix(v, "0x")
+		decimalValue, err := strconv.ParseInt(hexValue, 16, 64)
 		if err != nil {
-			log.Errorf("%v is not of type %v, error in converting %v to decimal value", hexValue, core.HexReturnType, hexValue)
-			return nil, err
+			log.Errorf("Error converting hex value %v to integer: %v", hexValue, err)
+			return 0, err
 		}
 		return int(decimalValue), nil
 	default:
-		return num, nil
+		log.Errorf("Input data %v is not a hex value", num)
+		return 0, errors.New("input data is not hex")
 	}
 }
 

utils/math_test.go

@@ -958,44 +958,27 @@ func IndexNotEqual(a []uint32, b []uint32) bool {
 
 }
 
-func TestManageReturnType(t *testing.T) {
-	type args struct {
-		num        interface{}
-		returnType string
-	}
+func TestConvertHexToInt(t *testing.T) {
 	tests := []struct {
 		name    string
-		args    args
-		want    interface{}
+		input   interface{}
+		want    int
 		wantErr bool
 	}{
-		{
-			name: "Test 1: When there is a valid hex value",
-			args: args{
-				num:        "0x0000000000000000000000000000000000000000000000000000000061a55c2e",
-				returnType: "hex",
-			},
-			want: 1638226990,
-		},
-		{
-			name: "Test 2: When the hex value is invalid",
-			args: args{
-				num:        "0xZZ",
-				returnType: "hex",
-			},
-			want:    nil,
-			wantErr: true,
-		},
+		{name: "Valid hex string with prefix", input: "0x1A", want: 26, wantErr: false},
+		{name: "Valid hex string without prefix", input: "1A", want: 26, wantErr: false},
+		{name: "Valid hex string without prefix", input: "100", want: 256, wantErr: false},
+		{name: "Invalid hex string", input: "0xZZ", want: 0, wantErr: true},
+		{name: "Integer input", input: 123, want: 0, wantErr: true},
+		{name: "Float input", input: 3.14, want: 0, wantErr: true},
+		{name: "Unsupported data type", input: struct{}{}, want: 0, wantErr: true},
 	}
+
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := ManageReturnType(tt.args.num, tt.args.returnType)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ManageReturnType() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("ManageReturnType() got = %v, want %v", got, tt.want)
+			got, err := ConvertHexToInt(tt.input)
+			if got != tt.want || (err != nil) != tt.wantErr {
+				t.Errorf("ConvertHexToInt(%v) = %v, error: %v; want %v, error expected: %v", tt.input, got, err != nil, tt.want, tt.wantErr)
 			}
 		})
 	}