golangci-lint/CI: Bump versions and introduce new linters (#798)

* golangci-lint/CI: Bump versions

Fix remaining linter issues

* Specifically set AppVeyor version

* Fix the infamous typos 👀

* Add go env cmd to AppVeyor

* Add go version cmd to AppVeyor

* Specify AppVeyor image, adjust linters

* Update go get to go install due to deprecation

* Bump golangci-lint timeout time for AppVeyor

* Change NW contract to NQ

* Address nitters

* GetRandomPair -> Pair{}

* Address nits

* Address time nitterinos plus additional tweaks

* More time inception upgrades!

* Bending time and space

exchanges/gateio/gateio.go

@@ -52,9 +52,6 @@ func (g *Gateio) GetSymbols(ctx context.Context) ([]string, error) {
 	var result []string
 	urlPath := fmt.Sprintf("/%s/%s", gateioAPIVersion, gateioSymbol)
 	err := g.SendHTTPRequest(ctx, exchange.RestSpotSupplementary, urlPath, &result)
-	if err != nil {
-		return nil, nil
-	}
 	return result, err
 }
 
@@ -76,9 +73,15 @@ func (g *Gateio) GetMarketInfo(ctx context.Context) (MarketInfoResponse, error)
 
 	result.Result = res.Result
 	for _, v := range res.Pairs {
-		item := v.(map[string]interface{})
+		item, ok := v.(map[string]interface{})
+		if !ok {
+			return result, errors.New("unable to type assert item")
+		}
 		for itemk, itemv := range item {
-			pairv := itemv.(map[string]interface{})
+			pairv, ok := itemv.(map[string]interface{})
+			if !ok {
+				return result, errors.New("unable to type assert pairv")
+			}
 			result.Pairs = append(result.Pairs, MarketInfoPairsResponse{
 				Symbol:        itemk,
 				DecimalPlaces: pairv["decimal_places"].(float64),
@@ -203,28 +206,27 @@ func (g *Gateio) GetSpotKline(ctx context.Context, arg KlinesRequestParams) (kli
 		arg.GroupSec,
 		arg.HourSize)
 
-	var rawKlines map[string]interface{}
-	err := g.SendHTTPRequest(ctx, exchange.RestSpotSupplementary, urlPath, &rawKlines)
-	if err != nil {
+	resp := struct {
+		Data   [][]string `json:"data"`
+		Result string     `json:"result"`
+	}{}
+
+	if err := g.SendHTTPRequest(ctx, exchange.RestSpotSupplementary, urlPath, &resp); err != nil {
 		return kline.Item{}, err
 	}
+	if resp.Result != "true" || len(resp.Data) == 0 {
+		return kline.Item{}, errors.New("rawKlines unexpected data returned")
+	}
 
 	result := kline.Item{
 		Exchange: g.Name,
 	}
 
-	if rawKlines == nil || rawKlines["data"] == nil {
-		return kline.Item{}, errors.New("rawKlines is nil")
-	}
-
-	rawKlineDatasString, _ := json.Marshal(rawKlines["data"].([]interface{}))
-	var rawKlineDatas [][]interface{}
-	if err := json.Unmarshal(rawKlineDatasString, &rawKlineDatas); err != nil {
-		return kline.Item{}, fmt.Errorf("rawKlines unmarshal failed. Err: %s", err)
-	}
-
-	for _, k := range rawKlineDatas {
-		otString, err := strconv.ParseFloat(k[0].(string), 64)
+	for x := range resp.Data {
+		if len(resp.Data[x]) < 6 {
+			return kline.Item{}, fmt.Errorf("unexpected kline data length")
+		}
+		otString, err := strconv.ParseFloat(resp.Data[x][0], 64)
 		if err != nil {
 			return kline.Item{}, err
 		}
@@ -232,23 +234,23 @@ func (g *Gateio) GetSpotKline(ctx context.Context, arg KlinesRequestParams) (kli
 		if err != nil {
 			return kline.Item{}, fmt.Errorf("cannot parse Kline.OpenTime. Err: %s", err)
 		}
-		_vol, err := convert.FloatFromString(k[1])
+		_vol, err := convert.FloatFromString(resp.Data[x][1])
 		if err != nil {
 			return kline.Item{}, fmt.Errorf("cannot parse Kline.Volume. Err: %s", err)
 		}
-		_close, err := convert.FloatFromString(k[2])
+		_close, err := convert.FloatFromString(resp.Data[x][2])
 		if err != nil {
 			return kline.Item{}, fmt.Errorf("cannot parse Kline.Close. Err: %s", err)
 		}
-		_high, err := convert.FloatFromString(k[3])
+		_high, err := convert.FloatFromString(resp.Data[x][3])
 		if err != nil {
 			return kline.Item{}, fmt.Errorf("cannot parse Kline.High. Err: %s", err)
 		}
-		_low, err := convert.FloatFromString(k[4])
+		_low, err := convert.FloatFromString(resp.Data[x][4])
 		if err != nil {
 			return kline.Item{}, fmt.Errorf("cannot parse Kline.Low. Err: %s", err)
 		}
-		_open, err := convert.FloatFromString(k[5])
+		_open, err := convert.FloatFromString(resp.Data[x][5])
 		if err != nil {
 			return kline.Item{}, fmt.Errorf("cannot parse Kline.Open. Err: %s", err)
 		}

exchanges/gateio/gateio_test.go

@@ -544,14 +544,14 @@ func TestWsGetOrderInfo(t *testing.T) {
 }
 
 func setupWSTestAuth(t *testing.T) {
+	t.Helper()
 	if wsSetupRan {
 		return
 	}
 	if !g.Websocket.IsEnabled() && !g.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
 		t.Skip(stream.WebsocketNotEnabled)
 	}
-	err := g.Websocket.Connect()
-	if err != nil {
+	if err := g.Websocket.Connect(); err != nil {
 		t.Fatal(err)
 	}
 	wsSetupRan = true

exchanges/gateio/gateio_websocket.go

@@ -225,11 +225,22 @@ func (g *Gateio) wsHandleData(respRaw []byte) error {
 		if err != nil {
 			return err
 		}
-		invalidJSON := orderUpdate.Params[1].(map[string]interface{})
+		if len(orderUpdate.Params) < 2 {
+			return errors.New("unexpected orderUpdate.Params data length")
+		}
+		invalidJSON, ok := orderUpdate.Params[1].(map[string]interface{})
+		if !ok {
+			return errors.New("unable to type assert invalidJSON")
+		}
 		oStatus := order.UnknownStatus
 		oType := order.UnknownType
 		oSide := order.UnknownSide
-		switch orderUpdate.Params[0].(float64) {
+
+		orderStatus, ok := orderUpdate.Params[0].(float64)
+		if !ok {
+			return errors.New("unable to type assert orderStatus")
+		}
+		switch orderStatus {
 		case 1:
 			oStatus = order.New
 		case 2:
@@ -237,42 +248,57 @@ func (g *Gateio) wsHandleData(respRaw []byte) error {
 		case 3:
 			oStatus = order.Filled
 		}
-		switch invalidJSON["orderType"].(float64) {
+
+		orderType, ok := invalidJSON["orderType"].(float64)
+		if !ok {
+			return errors.New("unable to type assert orderType")
+		}
+		switch orderType {
 		case 1:
 			oType = order.Limit
 		case 2:
 			oType = order.Market
 		}
-		switch invalidJSON["type"].(float64) {
+
+		orderSide, ok := invalidJSON["type"].(float64)
+		if !ok {
+			return errors.New("unable to type assert orderSide")
+		}
+		switch orderSide {
 		case 1:
 			oSide = order.Sell
 		case 2:
 			oSide = order.Buy
 		}
+
 		var price, amount, filledTotal, left, fee float64
-		price, err = strconv.ParseFloat(invalidJSON["price"].(string), 64)
+		price, err = convert.FloatFromString(invalidJSON["price"])
 		if err != nil {
 			return err
 		}
-		amount, err = strconv.ParseFloat(invalidJSON["amount"].(string), 64)
+		amount, err = convert.FloatFromString(invalidJSON["amount"])
 		if err != nil {
 			return err
 		}
-		filledTotal, err = strconv.ParseFloat(invalidJSON["filledTotal"].(string), 64)
+		filledTotal, err = convert.FloatFromString(invalidJSON["filledTotal"])
 		if err != nil {
 			return err
 		}
-		left, err = strconv.ParseFloat(invalidJSON["left"].(string), 64)
+		left, err = convert.FloatFromString(invalidJSON["left"])
 		if err != nil {
 			return err
 		}
-		fee, err = strconv.ParseFloat(invalidJSON["dealFee"].(string), 64)
+		fee, err = convert.FloatFromString(invalidJSON["dealFee"])
 		if err != nil {
 			return err
 		}
 
 		var p currency.Pair
-		p, err = currency.NewPairFromString(invalidJSON["market"].(string))
+		pairStr, ok := invalidJSON["market"].(string)
+		if !ok {
+			return errors.New("unable to type assert market")
+		}
+		p, err = currency.NewPairFromString(pairStr)
 		if err != nil {
 			return err
 		}

exchanges/gateio/gateio_wrapper.go

@@ -270,8 +270,7 @@ func (g *Gateio) UpdateTickers(ctx context.Context, a asset.Item) error {
 
 // UpdateTicker updates and returns the ticker for a currency pair
 func (g *Gateio) UpdateTicker(ctx context.Context, p currency.Pair, a asset.Item) (*ticker.Price, error) {
-	err := g.UpdateTickers(ctx, a)
-	if err != nil {
+	if err := g.UpdateTickers(ctx, a); err != nil {
 		return nil, err
 	}
 	return ticker.GetTicker(g.Name, p, a)
@@ -411,8 +410,7 @@ func (g *Gateio) UpdateAccountInfo(ctx context.Context, assetType asset.Item) (a
 	}
 
 	info.Exchange = g.Name
-	err := account.Process(&info)
-	if err != nil {
+	if err := account.Process(&info); err != nil {
 		return account.Holdings{}, err
 	}