gateio: Update contract settlement currencies (#1702)

* gateio: Update contract settlement currencies

* GateIO: Fix TestGetSettlementFromCurrency race

exchanges/gateio/gateio_types.go

@@ -11,20 +11,13 @@ import (
 )
 
 const (
-	// Settles
-	settleBTC  = "btc"
-	settleUSD  = "usd"
-	settleUSDT = "usdt"
-
-	// types.Time time in force variables
-
+	// Order time in force variables
 	gtcTIF = "gtc" // good-'til-canceled
 	iocTIF = "ioc" // immediate-or-cancel
 	pocTIF = "poc"
 	fokTIF = "fok" // fill-or-kill
 
-	// frequently used order Status
-
+	// Frequently used order Status
 	statusOpen     = "open"
 	statusLoaned   = "loaned"
 	statusFinished = "finished"
@@ -34,6 +27,8 @@ const (
 	sideBorrow = "borrow"
 )
 
+var settlementCurrencies = []currency.Code{currency.BTC, currency.USDT}
+
 // WithdrawalFees the large list of predefined withdrawal fees
 // Prone to change
 var WithdrawalFees = map[currency.Code]float64{
@@ -1827,7 +1822,7 @@ type OrderCreateParams struct {
 	ClosePosition bool          `json:"close,omitempty"` // Size needs to be zero if true
 	ReduceOnly    bool          `json:"reduce_only,omitempty"`
 	AutoSize      string        `json:"auto_size,omitempty"`
-	Settle        string        `json:"-"` // Used in URL.
+	Settle        currency.Code `json:"-"` // Used in URL.
 }
 
 // Order represents future order response

exchanges/gateio/gateio_wrapper.go

@@ -336,8 +336,8 @@ func (g *Gateio) UpdateTicker(ctx context.Context, p currency.Pair, a asset.Item
 			AssetType:    a,
 		}
 	case asset.Futures:
-		var settle string
-		settle, err = g.getSettlementFromCurrency(fPair, true)
+		var settle currency.Code
+		settle, err = getSettlementFromCurrency(fPair)
 		if err != nil {
 			return nil, err
 		}
@@ -403,8 +403,8 @@ func (g *Gateio) UpdateTicker(ctx context.Context, p currency.Pair, a asset.Item
 		}
 		return ticker.GetTicker(g.Name, fPair, a)
 	case asset.DeliveryFutures:
-		var settle string
-		settle, err = g.getSettlementFromCurrency(fPair, false)
+		var settle currency.Code
+		settle, err = getSettlementFromCurrency(fPair)
 		if err != nil {
 			return nil, err
 		}
@@ -498,11 +498,11 @@ func (g *Gateio) FetchTradablePairs(ctx context.Context, a asset.Item) (currency
 		}
 		return pairs, nil
 	case asset.Futures:
-		btcContracts, err := g.GetAllFutureContracts(ctx, settleBTC)
+		btcContracts, err := g.GetAllFutureContracts(ctx, currency.BTC)
 		if err != nil {
 			return nil, err
 		}
-		usdtContracts, err := g.GetAllFutureContracts(ctx, settleUSDT)
+		usdtContracts, err := g.GetAllFutureContracts(ctx, currency.USDT)
 		if err != nil {
 			return nil, err
 		}
@@ -524,11 +524,11 @@ func (g *Gateio) FetchTradablePairs(ctx context.Context, a asset.Item) (currency
 		}
 		return pairs, nil
 	case asset.DeliveryFutures:
-		btcContracts, err := g.GetAllDeliveryContracts(ctx, settleBTC)
+		btcContracts, err := g.GetAllDeliveryContracts(ctx, currency.BTC)
 		if err != nil {
 			return nil, err
 		}
-		usdtContracts, err := g.GetAllDeliveryContracts(ctx, settleUSDT)
+		usdtContracts, err := g.GetAllDeliveryContracts(ctx, currency.USDT)
 		if err != nil {
 			return nil, err
 		}
@@ -636,13 +636,10 @@ func (g *Gateio) UpdateTickers(ctx context.Context, a asset.Item) error {
 	case asset.Futures, asset.DeliveryFutures:
 		var tickers []FuturesTicker
 		var ticks []FuturesTicker
-		for _, settle := range []string{settleBTC, settleUSDT, settleUSD} {
+		for _, settle := range settlementCurrencies {
 			if a == asset.Futures {
 				ticks, err = g.GetFuturesTickers(ctx, settle, currency.EMPTYPAIR)
 			} else {
-				if settle == settleUSD {
-					continue
-				}
 				ticks, err = g.GetDeliveryFutureTickers(ctx, settle, currency.EMPTYPAIR)
 			}
 			if err != nil {
@@ -733,15 +730,15 @@ func (g *Gateio) UpdateOrderbook(ctx context.Context, p currency.Pair, a asset.I
 		}
 		orderbookNew, err = g.GetOrderbook(ctx, p.String(), "", 0, true)
 	case asset.Futures:
-		var settle string
-		settle, err = g.getSettlementFromCurrency(p, true)
+		var settle currency.Code
+		settle, err = getSettlementFromCurrency(p)
 		if err != nil {
 			return nil, err
 		}
 		orderbookNew, err = g.GetFuturesOrderbook(ctx, settle, p.String(), "", 0, true)
 	case asset.DeliveryFutures:
-		var settle string
-		settle, err = g.getSettlementFromCurrency(p.Upper(), false)
+		var settle currency.Code
+		settle, err = getSettlementFromCurrency(p.Upper())
 		if err != nil {
 			return nil, err
 		}
@@ -833,22 +830,18 @@ func (g *Gateio) UpdateAccountInfo(ctx context.Context, a asset.Item) (account.H
 			Currencies: currencies,
 		})
 	case asset.Futures, asset.DeliveryFutures:
-		currencies := make([]account.Balance, 0, 3)
-		settles := []currency.Code{currency.BTC, currency.USDT, currency.USD}
-		for x := range settles {
+		currencies := make([]account.Balance, 0, 2)
+		for x := range settlementCurrencies {
 			var balance *FuturesAccount
 			if a == asset.Futures {
-				if settles[x].Equal(currency.USD) {
-					continue
-				}
-				balance, err = g.QueryFuturesAccount(ctx, settles[x].String())
+				balance, err = g.QueryFuturesAccount(ctx, settlementCurrencies[x])
 			} else {
-				balance, err = g.GetDeliveryFuturesAccounts(ctx, settles[x].String())
+				balance, err = g.GetDeliveryFuturesAccounts(ctx, settlementCurrencies[x])
 			}
 			if err != nil {
 				if strings.Contains(err.Error(), unfundedFuturesAccount) {
 					if g.Verbose {
-						log.Warnf(log.ExchangeSys, "%s %v for settlement: %v", g.Name, err, settles[x])
+						log.Warnf(log.ExchangeSys, "%s %v for settlement: %v", g.Name, err, settlementCurrencies[x])
 					}
 					continue
 				}
@@ -972,8 +965,8 @@ func (g *Gateio) GetRecentTrades(ctx context.Context, p currency.Pair, a asset.I
 			}
 		}
 	case asset.Futures:
-		var settle string
-		settle, err = g.getSettlementFromCurrency(p, true)
+		var settle currency.Code
+		settle, err = getSettlementFromCurrency(p)
 		if err != nil {
 			return nil, err
 		}
@@ -995,8 +988,8 @@ func (g *Gateio) GetRecentTrades(ctx context.Context, p currency.Pair, a asset.I
 			}
 		}
 	case asset.DeliveryFutures:
-		var settle string
-		settle, err = g.getSettlementFromCurrency(p, false)
+		var settle currency.Code
+		settle, err = getSettlementFromCurrency(p)
 		if err != nil {
 			return nil, err
 		}
@@ -1122,7 +1115,7 @@ func (g *Gateio) SubmitOrder(ctx context.Context, s *order.Submit) (*order.Submi
 		//	* iceberg orders
 		//	* auto_size (close_long, close_short)
 		// 	* stp_act (self trade prevention)
-		settle, err := g.getSettlementFromCurrency(s.Pair, true)
+		settle, err := getSettlementFromCurrency(s.Pair)
 		if err != nil {
 			return nil, err
 		}
@@ -1168,7 +1161,7 @@ func (g *Gateio) SubmitOrder(ctx context.Context, s *order.Submit) (*order.Submi
 		response.AverageExecutedPrice = fOrder.FillPrice.Float64()
 		return response, nil
 	case asset.DeliveryFutures:
-		settle, err := g.getSettlementFromCurrency(s.Pair, false)
+		settle, err := getSettlementFromCurrency(s.Pair)
 		if err != nil {
 			return nil, err
 		}
@@ -1260,8 +1253,8 @@ func (g *Gateio) CancelOrder(ctx context.Context, o *order.Cancel) error {
 	case asset.Spot, asset.Margin, asset.CrossMargin:
 		_, err = g.CancelSingleSpotOrder(ctx, o.OrderID, fPair.String(), o.AssetType == asset.CrossMargin)
 	case asset.Futures, asset.DeliveryFutures:
-		var settle string
-		settle, err = g.getSettlementFromCurrency(fPair, true)
+		var settle currency.Code
+		settle, err = getSettlementFromCurrency(fPair)
 		if err != nil {
 			return err
 		}
@@ -1338,7 +1331,7 @@ func (g *Gateio) CancelBatchOrders(ctx context.Context, o []order.Cancel) (*orde
 		}
 	case asset.Futures:
 		for a := range o {
-			cancel, err := g.CancelMultipleFuturesOpenOrders(ctx, o[a].Pair, o[a].Side.Lower(), o[a].Pair.Quote.String())
+			cancel, err := g.CancelMultipleFuturesOpenOrders(ctx, o[a].Pair, o[a].Side.Lower(), o[a].Pair.Quote)
 			if err != nil {
 				return nil, err
 			}
@@ -1348,7 +1341,7 @@ func (g *Gateio) CancelBatchOrders(ctx context.Context, o []order.Cancel) (*orde
 		}
 	case asset.DeliveryFutures:
 		for a := range o {
-			settle, err := g.getSettlementFromCurrency(o[a].Pair, false)
+			settle, err := getSettlementFromCurrency(o[a].Pair)
 			if err != nil {
 				return nil, err
 			}
@@ -1401,8 +1394,8 @@ func (g *Gateio) CancelAllOrders(ctx context.Context, o *order.Cancel) (order.Ca
 		if o.Pair.IsEmpty() {
 			return cancelAllOrdersResponse, currency.ErrCurrencyPairEmpty
 		}
-		var settle string
-		settle, err = g.getSettlementFromCurrency(o.Pair, true)
+		var settle currency.Code
+		settle, err = getSettlementFromCurrency(o.Pair)
 		if err != nil {
 			return cancelAllOrdersResponse, err
 		}
@@ -1418,8 +1411,8 @@ func (g *Gateio) CancelAllOrders(ctx context.Context, o *order.Cancel) (order.Ca
 		if o.Pair.IsEmpty() {
 			return cancelAllOrdersResponse, currency.ErrCurrencyPairEmpty
 		}
-		var settle string
-		settle, err = g.getSettlementFromCurrency(o.Pair, false)
+		var settle currency.Code
+		settle, err = getSettlementFromCurrency(o.Pair)
 		if err != nil {
 			return cancelAllOrdersResponse, err
 		}
@@ -1501,8 +1494,8 @@ func (g *Gateio) GetOrderInfo(ctx context.Context, orderID string, pair currency
 			LastUpdated:    spotOrder.UpdateTimeMs.Time(),
 		}, nil
 	case asset.Futures, asset.DeliveryFutures:
-		var settle string
-		settle, err = g.getSettlementFromCurrency(pair, a == asset.Futures)
+		var settle currency.Code
+		settle, err = getSettlementFromCurrency(pair)
 		if err != nil {
 			return nil, err
 		}
@@ -1715,19 +1708,19 @@ func (g *Gateio) GetActiveOrders(ctx context.Context, req *order.MultiOrderReque
 			}
 		}
 	case asset.Futures, asset.DeliveryFutures:
-		settlements := map[string]bool{}
+		settlements := map[currency.Code]bool{}
 		if len(req.Pairs) == 0 {
-			settlements["btc"] = true
-			settlements["usdt"] = true
-			settlements["usd"] = true
+			for x := range settlementCurrencies {
+				settlements[settlementCurrencies[x]] = true
+			}
 		} else {
 			for x := range req.Pairs {
-				var s string
-				s, err = g.getSettlementFromCurrency(req.Pairs[x], req.AssetType == asset.Futures)
+				var settle currency.Code
+				settle, err = getSettlementFromCurrency(req.Pairs[x])
 				if err != nil {
 					return nil, err
 				}
-				settlements[s] = true
+				settlements[settle] = true
 			}
 		}
 
@@ -1773,7 +1766,7 @@ func (g *Gateio) GetActiveOrders(ctx context.Context, req *order.MultiOrderReque
 					AssetType:            req.AssetType,
 					Side:                 side,
 					Type:                 order.Limit,
-					SettlementCurrency:   currency.NewCode(settlement),
+					SettlementCurrency:   settlement,
 					ReduceOnly:           futuresOrders[x].IsReduceOnly,
 					PostOnly:             futuresOrders[x].TimeInForce == "poc",
 					AverageExecutedPrice: futuresOrders[x].FillPrice.Float64(),
@@ -1865,18 +1858,11 @@ func (g *Gateio) GetOrderHistory(ctx context.Context, req *order.MultiOrderReque
 	case asset.Futures, asset.DeliveryFutures:
 		for x := range req.Pairs {
 			fPair := req.Pairs[x].Format(format)
-			var settle string
-			if req.AssetType == asset.Futures {
-				settle, err = g.getSettlementFromCurrency(fPair, true)
-			} else {
-				settle, err = g.getSettlementFromCurrency(fPair, false)
-			}
+			var settle currency.Code
+			settle, err = getSettlementFromCurrency(fPair)
 			if err != nil {
 				return nil, err
 			}
-			if req.AssetType == asset.Futures && settle == settleUSD {
-				settle = settleBTC
-			}
 			var futuresOrder []TradingHistoryItem
 			if req.AssetType == asset.Futures {
 				futuresOrder, err = g.GetMyPersonalTradingHistory(ctx, settle, "", req.FromOrderID, fPair, 0, 0, 0)
@@ -1954,18 +1940,11 @@ func (g *Gateio) GetHistoricCandles(ctx context.Context, pair currency.Pair, a a
 			}
 		}
 	case asset.Futures, asset.DeliveryFutures:
-		var settlement string
-		if req.Asset == asset.Futures {
-			settlement, err = g.getSettlementFromCurrency(req.RequestFormatted, true)
-		} else {
-			settlement, err = g.getSettlementFromCurrency(req.RequestFormatted, false)
-		}
+		var settlement currency.Code
+		settlement, err = getSettlementFromCurrency(req.RequestFormatted)
 		if err != nil {
 			return nil, err
 		}
-		if req.Asset == asset.Futures && settlement == settleUSD {
-			settlement = settleBTC
-		}
 		var candles []FuturesCandlestick
 		if a == asset.Futures {
 			candles, err = g.GetFuturesCandlesticks(ctx, settlement, req.RequestFormatted.String(), start, end, 0, interval)
@@ -2018,18 +1997,11 @@ func (g *Gateio) GetHistoricCandlesExtended(ctx context.Context, pair currency.P
 				})
 			}
 		case asset.Futures, asset.DeliveryFutures:
-			var settle string
-			if req.Asset == asset.Futures {
-				settle, err = g.getSettlementFromCurrency(req.RequestFormatted, true)
-			} else {
-				settle, err = g.getSettlementFromCurrency(req.RequestFormatted, false)
-			}
+			var settle currency.Code
+			settle, err = getSettlementFromCurrency(req.RequestFormatted)
 			if err != nil {
 				return nil, err
 			}
-			if req.Asset == asset.Futures && settle == settleUSD {
-				settle = settleBTC
-			}
 			var candles []FuturesCandlestick
 			if a == asset.Futures {
 				candles, err = g.GetFuturesCandlesticks(ctx, settle, req.RequestFormatted.String(), req.RangeHolder.Ranges[b].Start.Time, req.RangeHolder.Ranges[b].End.Time, 0, interval)
@@ -2099,10 +2071,9 @@ func (g *Gateio) GetFuturesContractDetails(ctx context.Context, item asset.Item)
 	}
 	switch item {
 	case asset.Futures:
-		settlePairs := []string{"btc", "usdt", "usd"}
 		var resp []futures.Contract
-		for k := range settlePairs {
-			contracts, err := g.GetAllFutureContracts(ctx, settlePairs[k])
+		for k := range settlementCurrencies {
+			contracts, err := g.GetAllFutureContracts(ctx, settlementCurrencies[k])
 			if err != nil {
 				return nil, err
 			}
@@ -2113,12 +2084,11 @@ func (g *Gateio) GetFuturesContractDetails(ctx context.Context, item asset.Item)
 				if err != nil {
 					return nil, err
 				}
-				settlePair := currency.NewCode(settlePairs[k])
 				contractSettlementType := futures.Linear
 				switch {
-				case name.Base.Equal(currency.BTC) && settlePair.Equal(currency.BTC):
+				case name.Base.Equal(currency.BTC) && settlementCurrencies[k].Equal(currency.BTC):
 					contractSettlementType = futures.Inverse
-				case !name.Base.Equal(settlePair) && !settlePair.Equal(currency.USDT):
+				case !name.Base.Equal(settlementCurrencies[k]) && !settlementCurrencies[k].Equal(currency.USDT):
 					contractSettlementType = futures.Quanto
 				}
 				c := futures.Contract{
@@ -2129,7 +2099,7 @@ func (g *Gateio) GetFuturesContractDetails(ctx context.Context, item asset.Item)
 					IsActive:             !contracts[j].InDelisting,
 					Type:                 futures.Perpetual,
 					SettlementType:       contractSettlementType,
-					SettlementCurrencies: currency.Currencies{settlePair},
+					SettlementCurrencies: currency.Currencies{settlementCurrencies[k]},
 					Multiplier:           contracts[j].QuantoMultiplier.Float64(),
 					MaxLeverage:          contracts[j].LeverageMax.Float64(),
 				}
@@ -2145,10 +2115,9 @@ func (g *Gateio) GetFuturesContractDetails(ctx context.Context, item asset.Item)
 		}
 		return resp, nil
 	case asset.DeliveryFutures:
-		settlePairs := []string{"btc", "usdt"}
 		var resp []futures.Contract
-		for k := range settlePairs {
-			contracts, err := g.GetAllDeliveryContracts(ctx, settlePairs[k])
+		for k := range settlementCurrencies {
+			contracts, err := g.GetAllDeliveryContracts(ctx, settlementCurrencies[k])
 			if err != nil {
 				return nil, err
 			}
@@ -2194,7 +2163,7 @@ func (g *Gateio) GetFuturesContractDetails(ctx context.Context, item asset.Item)
 					SettlementType:       futures.Linear,
 					IsActive:             !contracts[j].InDelisting,
 					Type:                 ct,
-					SettlementCurrencies: currency.Currencies{currency.NewCode(settlePairs[k])},
+					SettlementCurrencies: currency.Currencies{settlementCurrencies[k]},
 					MarginCurrency:       currency.Code{},
 					Multiplier:           contracts[j].QuantoMultiplier.Float64(),
 					MaxLeverage:          contracts[j].LeverageMax.Float64(),
@@ -2297,7 +2266,7 @@ func (g *Gateio) GetHistoricalFundingRates(ctx context.Context, r *fundingrate.H
 		return nil, err
 	}
 
-	records, err := g.GetFutureFundingRates(ctx, r.PaymentCurrency.String(), fPair, 1000)
+	records, err := g.GetFutureFundingRates(ctx, r.PaymentCurrency, fPair, 1000)
 	if err != nil {
 		return nil, err
 	}
@@ -2354,8 +2323,8 @@ func (g *Gateio) GetLatestFundingRates(ctx context.Context, r *fundingrate.Lates
 		if err != nil {
 			return nil, err
 		}
-		var settle string
-		settle, err = g.getSettlementFromCurrency(fPair, true)
+		var settle currency.Code
+		settle, err = getSettlementFromCurrency(fPair)
 		if err != nil {
 			return nil, err
 		}
@@ -2368,14 +2337,13 @@ func (g *Gateio) GetLatestFundingRates(ctx context.Context, r *fundingrate.Lates
 	}
 
 	var resp []fundingrate.LatestRateResponse
-	settleCurrencies := []string{"btc", "usdt", "usd"}
 	pairs, err := g.GetEnabledPairs(asset.Futures)
 	if err != nil {
 		return nil, err
 	}
 
-	for i := range settleCurrencies {
-		contracts, err := g.GetAllFutureContracts(ctx, settleCurrencies[i])
+	for i := range settlementCurrencies {
+		contracts, err := g.GetAllFutureContracts(ctx, settlementCurrencies[i])
 		if err != nil {
 			return nil, err
 		}
@@ -2450,7 +2418,7 @@ func (g *Gateio) GetOpenInterest(ctx context.Context, k ...key.PairAsset) ([]fut
 		}
 		switch k[0].Asset {
 		case asset.DeliveryFutures:
-			contractResp, err := g.GetSingleDeliveryContracts(ctx, "usdt", p)
+			contractResp, err := g.GetSingleDeliveryContracts(ctx, currency.USDT, p)
 			if err != nil {
 				return nil, err
 			}
@@ -2467,7 +2435,7 @@ func (g *Gateio) GetOpenInterest(ctx context.Context, k ...key.PairAsset) ([]fut
 				},
 			}, nil
 		case asset.Futures:
-			for _, s := range []string{"usd", "usdt", "btc"} {
+			for _, s := range settlementCurrencies {
 				contractResp, err := g.GetSingleContract(ctx, s, p.String())
 				if err != nil {
 					continue
@@ -2491,7 +2459,7 @@ func (g *Gateio) GetOpenInterest(ctx context.Context, k ...key.PairAsset) ([]fut
 	for _, a := range g.GetAssetTypes(true) {
 		switch a {
 		case asset.DeliveryFutures:
-			contractResp, err := g.GetAllDeliveryContracts(ctx, "usdt")
+			contractResp, err := g.GetAllDeliveryContracts(ctx, currency.USDT)
 			if err != nil {
 				return nil, err
 			}
@@ -2526,7 +2494,7 @@ func (g *Gateio) GetOpenInterest(ctx context.Context, k ...key.PairAsset) ([]fut
 				})
 			}
 		case asset.Futures:
-			for _, s := range []string{"usd", "usdt", "btc"} {
+			for _, s := range settlementCurrencies {
 				contractResp, err := g.GetAllFutureContracts(ctx, s)
 				if err != nil {
 					return nil, err