exchanges: Add V2 Crypto.com exchange support

exchanges/cryptodotcom/cryptodotcom.go

@@ -6,10 +6,8 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io"
 	"net/http"
 	"net/url"
-	"reflect"
 	"sort"
 	"strconv"
 	"strings"
@@ -663,19 +661,18 @@ func (cr *Cryptodotcom) SendAuthHTTPRequest(ctx context.Context, ePath exchange.
 	}
 	newRequest := func() (*request.Item, error) {
 		timestamp := time.Now()
-		var body io.Reader
-		var hmac, payload []byte
 		var id string
-		var idInt int64
 		id, err = common.GenerateRandomString(6, common.NumberCharacters)
 		if err != nil {
 			return nil, err
 		}
+		var idInt int64
 		idInt, err = strconv.ParseInt(id, 10, 64)
 		if err != nil {
 			return nil, err
 		}
 		signaturePayload := path + strconv.FormatInt(idInt, 10) + creds.Key + cr.getParamString(arg) + strconv.FormatInt(timestamp.UnixMilli(), 10)
+		var hmac []byte
 		hmac, err = crypto.GetHMAC(crypto.HashSHA256,
 			[]byte(signaturePayload),
 			[]byte(creds.Secret))
@@ -692,11 +689,12 @@ func (cr *Cryptodotcom) SendAuthHTTPRequest(ctx context.Context, ePath exchange.
 			Params:    arg,
 			Signature: crypto.HexEncodeToString(hmac),
 		}
+		var payload []byte
 		payload, err = json.Marshal(req)
 		if err != nil {
 			return nil, err
 		}
-		body = bytes.NewBuffer(payload)
+		body := bytes.NewBuffer(payload)
 		return &request.Item{
 			Method:        http.MethodPost,
 			Path:          endpoint + cryptodotcomAPIVersion + path,
@@ -730,44 +728,20 @@ func (cr *Cryptodotcom) getParamString(params map[string]interface{}) string {
 		if params[keys[x]] == nil {
 			paramString += keys[x] + "null"
 		}
-		switch reflect.ValueOf(params[keys[x]]).Kind() {
-		case reflect.Bool:
-			param, ok := params[keys[x]].(bool)
-			if !ok {
-				param = false
-			}
-			paramString += keys[x] + strconv.FormatBool(param)
-		case reflect.Int64:
-			param, ok := params[keys[x]].(int64)
-			if !ok {
-				param = 0
-			}
-			paramString += keys[x] + strconv.FormatInt(param, 10)
-		case reflect.Float32:
-			param, ok := params[keys[x]].(float64)
-			if !ok {
-				param = 0.0
-			}
-			paramString += keys[x] + strconv.FormatFloat(param, 'f', -1, 64)
-		case reflect.Map:
-			param, ok := params[keys[x]].(map[string]interface{})
-			if !ok {
-				param = make(map[string]interface{})
-			}
-			paramString += keys[x] + cr.getParamString((param))
-		case reflect.String:
-			param, ok := params[keys[x]].(string)
-			if !ok {
-				param = ""
-			}
-			paramString += keys[x] + param
-		case reflect.Slice:
-			listOfMaps, ok := params[keys[x]].([]map[string]interface{})
-			if !ok {
-				return ""
-			}
-			for y := range listOfMaps {
-				paramString += cr.getParamString(listOfMaps[y])
+		switch value := params[keys[x]].(type) {
+		case bool:
+			paramString += keys[x] + strconv.FormatBool(value)
+		case int64:
+			paramString += keys[x] + strconv.FormatInt(value, 10)
+		case float64:
+			paramString += keys[x] + strconv.FormatFloat(value, 'f', -1, 64)
+		case map[string]interface{}:
+			paramString += keys[x] + cr.getParamString(value)
+		case string:
+			paramString += keys[x] + value
+		case []map[string]interface{}:
+			for y := range value {
+				paramString += cr.getParamString(value[y])
 			}
 		}
 	}

exchanges/cryptodotcom/cryptodotcom_test.go

@@ -2,6 +2,7 @@ package cryptodotcom
 
 import (
 	"context"
+	"errors"
 	"log"
 	"os"
 	"testing"
@@ -252,7 +253,6 @@ func TestGetPersonalOpenOrders(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-	t.Error(err)
 	_, err = cr.WsRetrivePersonalOpenOrders("", 0, 0)
 	if err != nil {
 		t.Error(err)
@@ -414,7 +414,7 @@ func TestGetOTCQuoteHistory(t *testing.T) {
 	if !areTestAPIKeysSet() {
 		t.Skip(credInfoNotProvided)
 	}
-	_, err := cr.GetOTCQuoteHistory(context.Background(), currency.NewPair(currency.EMPTYCODE, currency.EMPTYCODE), time.Time{}, time.Time{}, 0, 10)
+	_, err := cr.GetOTCQuoteHistory(context.Background(), currency.EMPTYPAIR, time.Time{}, time.Time{}, 0, 10)
 	if err != nil {
 		t.Error(err)
 	}
@@ -775,3 +775,33 @@ func TestWsSetCancelOnDisconnect(t *testing.T) {
 		t.Error(err)
 	}
 }
+
+func TestGetCreateParamMap(t *testing.T) {
+	t.Parallel()
+	arg := &CreateOrderParam{InstrumentName: "BTC_USDT", ClientOrderID: "", TimeInForce: "", Side: order.Buy, OrderType: order.Limit, PostOnly: false, TriggerPrice: 0, Price: 123, Quantity: 12, Notional: 0}
+	_, err := arg.getCreateParamMap()
+	if err != nil {
+		t.Error(err)
+	}
+	arg.OrderType = order.Market
+	_, err = arg.getCreateParamMap()
+	if err != nil {
+		t.Error(err)
+	}
+	arg.OrderType = order.TakeProfit
+	arg.Notional = 12
+	_, err = arg.getCreateParamMap()
+	if err != nil && !errors.Is(err, errTriggerPriceRequired) {
+		t.Errorf("expecting %v, but found %v", errTriggerPriceRequired, err)
+	}
+	arg.OrderType = order.UnknownType
+	_, err = arg.getCreateParamMap()
+	if err != nil && !errors.Is(err, order.ErrTypeIsInvalid) {
+		t.Errorf("expecting %v but found %v", order.ErrTypeIsInvalid, err)
+	}
+	arg.OrderType = order.StopLimit
+	_, err = arg.getCreateParamMap()
+	if err != nil && !errors.Is(err, errTriggerPriceRequired) {
+		t.Errorf("expecting %v, but found %v", order.ErrTypeIsInvalid, err)
+	}
+}

exchanges/cryptodotcom/cryptodotcom_types.go

@@ -17,6 +17,8 @@ var (
 	errInvalidAmount                 = errors.New("amount has to be greater than zero")
 	errNoArgumentPassed              = errors.New("no argument passed")
 	errInvalidResponseFromServer     = errors.New("invalid response from server")
+	errInvalidQuantity               = errors.New("quantity must be non-zero positive decimal value for order")
+	errTriggerPriceRequired          = errors.New("trigger price is required")
 )
 
 // InstrumentsResponse represents instruments response.
@@ -319,12 +321,12 @@ func (arg *CreateOrderParam) getCreateParamMap() (map[string]interface{}, error)
 			return nil, fmt.Errorf("%w, price must be non-zero positive decimal value", order.ErrPriceBelowMin)
 		}
 		if arg.Quantity <= 0 {
-			return nil, fmt.Errorf("quantity must be non-zero positive decimal value")
+			return nil, errInvalidQuantity
 		}
 		switch arg.OrderType {
 		case order.StopLimit, order.TakeProfitLimit:
 			if arg.TriggerPrice <= 0 {
-				return nil, fmt.Errorf("trigger price is required for Order Type: %v", arg.OrderType)
+				return nil, fmt.Errorf("%w for Order Type: %v", errTriggerPriceRequired, arg.OrderType)
 			}
 		}
 	case order.Market:
@@ -334,21 +336,21 @@ func (arg *CreateOrderParam) getCreateParamMap() (map[string]interface{}, error)
 			}
 		} else {
 			if arg.Quantity <= 0 {
-				return nil, fmt.Errorf("quantity must be non-zero positive decimal value for order type: %v and order side: %v", arg.OrderType, arg.Side)
+				return nil, fmt.Errorf("%w order type: %v and order side: %v", errInvalidQuantity, arg.OrderType, arg.Side)
 			}
 		}
 	case order.StopLoss, order.TakeProfit:
 		if arg.Side == order.Sell {
 			if arg.Quantity <= 0 {
-				return nil, fmt.Errorf("quantity must be non-zero positive decimal value for order type: %v and order side: %v", arg.OrderType, arg.Side)
+				return nil, fmt.Errorf("%w order type: %v and order side: %v", errInvalidQuantity, arg.OrderType, arg.Side)
 			}
 		} else {
 			if arg.Notional <= 0 {
-				return nil, fmt.Errorf("quantity must be non-zero positive decimal value for order type: %v", arg.OrderType)
+				return nil, fmt.Errorf("notional must be non-zero positive decimal value for order type: %v", arg.OrderType)
 			}
 		}
 		if arg.TriggerPrice <= 0 {
-			return nil, fmt.Errorf("trigger price is required for Order Type: %v", arg.OrderType)
+			return nil, fmt.Errorf("%w for Order Type: %s", errTriggerPriceRequired, arg.OrderType)
 		}
 	default:
 		return nil, fmt.Errorf("unsupported order type: %v", arg.OrderType)

exchanges/cryptodotcom/cryptodotcom_wrapper.go

@@ -944,13 +944,7 @@ func (cr *Cryptodotcom) GetHistoricCandles(ctx context.Context, pair currency.Pa
 			Volume: candles.Data[x].Volume,
 		}
 	}
-	return &kline.Item{
-		Exchange: cr.Name,
-		Pair:     req.RequestFormatted,
-		Asset:    a,
-		Interval: interval,
-		Candles:  candleElements,
-	}, nil
+	return req.ProcessResponse(candleElements)
 }
 
 // GetHistoricCandlesExtended returns candles between a time period for a set time interval