From d172f3dfe107dae3f8ea941aad24b23b1a362e9c Mon Sep 17 00:00:00 2001 From: Adrian Gallagher Date: Fri, 8 Nov 2024 10:11:13 +1100 Subject: [PATCH] gateio: Update contract settlement currencies (#1702) * gateio: Update contract settlement currencies * GateIO: Fix TestGetSettlementFromCurrency race --- exchanges/gateio/gateio.go | 673 ++++++++++++++--------------- exchanges/gateio/gateio_test.go | 668 +++++++++++----------------- exchanges/gateio/gateio_types.go | 15 +- exchanges/gateio/gateio_wrapper.go | 162 +++---- 4 files changed, 643 insertions(+), 875 deletions(-) diff --git a/exchanges/gateio/gateio.go b/exchanges/gateio/gateio.go index 7d932a8d..11d0dcd3 100644 --- a/exchanges/gateio/gateio.go +++ b/exchanges/gateio/gateio.go @@ -10,6 +10,7 @@ import ( "fmt" "net/http" "net/url" + "slices" "strconv" "strings" "time" @@ -133,42 +134,42 @@ const ( ) var ( - errEmptySettlementCurrency = errors.New("empty settlement currency") - errInvalidOrMissingContractParam = errors.New("invalid or empty contract") - errNoValidResponseFromServer = errors.New("no valid response from server") - errInvalidUnderlying = errors.New("missing underlying") - errInvalidOrderSize = errors.New("invalid order size") - errInvalidOrderID = errors.New("invalid order id") - errInvalidAmount = errors.New("invalid amount") - errInvalidOrEmptySubaccount = errors.New("invalid or empty subaccount") - errInvalidTransferDirection = errors.New("invalid transfer direction") - errInvalidOrderSide = errors.New("invalid order side") - errDifferentAccount = errors.New("account type must be identical for all orders") - errInvalidPrice = errors.New("invalid price") - errNoValidParameterPassed = errors.New("no valid parameter passed") - errInvalidCountdown = errors.New("invalid countdown, Countdown time, in seconds At least 5 seconds, 0 means cancel the countdown") - errInvalidOrderStatus = errors.New("invalid order status") - errInvalidLoanSide = errors.New("invalid loan side, only 'lend' and 'borrow'") - errInvalidLoanID = errors.New("missing loan ID") - errInvalidRepayMode = errors.New("invalid repay mode specified, must be 'all' or 'partial'") - errMissingPreviewID = errors.New("missing required parameter: preview_id") - errChangeHasToBePositive = errors.New("change has to be positive") - errInvalidLeverageValue = errors.New("invalid leverage value") - errInvalidRiskLimit = errors.New("new position risk limit") - errInvalidCountTotalValue = errors.New("invalid \"count_total\" value, supported \"count_total\" values are 0 and 1") - errInvalidTimeInForce = errors.New("invalid time in force value") - errInvalidAutoSizeValue = errors.New("invalid \"auto_size\" value, only \"close_long\" and \"close_short\" are supported") - errTooManyOrderRequest = errors.New("too many order creation request") - errInvalidTimeout = errors.New("invalid timeout, should be in seconds At least 5 seconds, 0 means cancel the countdown") - errNoTickerData = errors.New("no ticker data available") - errNilArgument = errors.New("null argument") - errInvalidTimezone = errors.New("invalid timezone") - errMultipleOrders = errors.New("multiple orders passed") - errMissingWithdrawalID = errors.New("missing withdrawal ID") - errInvalidSubAccountUserID = errors.New("sub-account user id is required") - errCannotParseSettlementCurrency = errors.New("cannot derive settlement currency") - errMissingAPIKey = errors.New("missing API key information") - errInvalidTextValue = errors.New("invalid text value, requires prefix `t-`") + errEmptyOrInvalidSettlementCurrency = errors.New("empty or invalid settlement currency") + errInvalidOrMissingContractParam = errors.New("invalid or empty contract") + errNoValidResponseFromServer = errors.New("no valid response from server") + errInvalidUnderlying = errors.New("missing underlying") + errInvalidOrderSize = errors.New("invalid order size") + errInvalidOrderID = errors.New("invalid order id") + errInvalidAmount = errors.New("invalid amount") + errInvalidOrEmptySubaccount = errors.New("invalid or empty subaccount") + errInvalidTransferDirection = errors.New("invalid transfer direction") + errInvalidOrderSide = errors.New("invalid order side") + errDifferentAccount = errors.New("account type must be identical for all orders") + errInvalidPrice = errors.New("invalid price") + errNoValidParameterPassed = errors.New("no valid parameter passed") + errInvalidCountdown = errors.New("invalid countdown, Countdown time, in seconds At least 5 seconds, 0 means cancel the countdown") + errInvalidOrderStatus = errors.New("invalid order status") + errInvalidLoanSide = errors.New("invalid loan side, only 'lend' and 'borrow'") + errInvalidLoanID = errors.New("missing loan ID") + errInvalidRepayMode = errors.New("invalid repay mode specified, must be 'all' or 'partial'") + errMissingPreviewID = errors.New("missing required parameter: preview_id") + errChangeHasToBePositive = errors.New("change has to be positive") + errInvalidLeverageValue = errors.New("invalid leverage value") + errInvalidRiskLimit = errors.New("new position risk limit") + errInvalidCountTotalValue = errors.New("invalid \"count_total\" value, supported \"count_total\" values are 0 and 1") + errInvalidTimeInForce = errors.New("invalid time in force value") + errInvalidAutoSizeValue = errors.New("invalid \"auto_size\" value, only \"close_long\" and \"close_short\" are supported") + errTooManyOrderRequest = errors.New("too many order creation request") + errInvalidTimeout = errors.New("invalid timeout, should be in seconds At least 5 seconds, 0 means cancel the countdown") + errNoTickerData = errors.New("no ticker data available") + errNilArgument = errors.New("null argument") + errInvalidTimezone = errors.New("invalid timezone") + errMultipleOrders = errors.New("multiple orders passed") + errMissingWithdrawalID = errors.New("missing withdrawal ID") + errInvalidSubAccountUserID = errors.New("sub-account user id is required") + errCannotParseSettlementCurrency = errors.New("cannot derive settlement currency") + errMissingAPIKey = errors.New("missing API key information") + errInvalidTextValue = errors.New("invalid text value, requires prefix `t-`") ) // Gateio is the overarching type across this package @@ -1298,13 +1299,13 @@ func (g *Gateio) GetSubAccountMarginBalances(ctx context.Context, subAccountUser } // GetSubAccountFuturesBalances retrieves sub accounts' futures account balances -func (g *Gateio) GetSubAccountFuturesBalances(ctx context.Context, subAccountUserID, settle string) ([]FuturesSubAccountBalance, error) { +func (g *Gateio) GetSubAccountFuturesBalances(ctx context.Context, subAccountUserID string, settle currency.Code) ([]FuturesSubAccountBalance, error) { params := url.Values{} if subAccountUserID != "" { params.Set("sub_uid", subAccountUserID) } - if settle != "" { - params.Set("settle", settle) + if !settle.IsEmpty() { + params.Set("settle", settle.Item.Lower) } var response []FuturesSubAccountBalance return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, walletEPL, http.MethodGet, walletSubAccountFuturesBalance, params, nil, &response) @@ -1338,14 +1339,14 @@ func (g *Gateio) GetSavedAddresses(ctx context.Context, ccy currency.Code, chain } // GetPersonalTradingFee retrieves personal trading fee -func (g *Gateio) GetPersonalTradingFee(ctx context.Context, currencyPair currency.Pair, settle string) (*PersonalTradingFee, error) { +func (g *Gateio) GetPersonalTradingFee(ctx context.Context, currencyPair currency.Pair, settle currency.Code) (*PersonalTradingFee, error) { params := url.Values{} if currencyPair.IsPopulated() { // specify a currency pair to retrieve precise fee rate params.Set("currency_pair", currencyPair.String()) } - if settle != "" { - params.Set("settle", settle) + if !settle.IsEmpty() { + params.Set("settle", settle.Item.Lower) } var response *PersonalTradingFee return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, walletEPL, http.MethodGet, walletTradingFee, params, nil, &response) @@ -1849,36 +1850,33 @@ func (g *Gateio) GetSingleBorrowLoanDetail(ctx context.Context, loanID string) ( // *********************************Futures*************************************** // GetAllFutureContracts retrieves list all futures contracts -func (g *Gateio) GetAllFutureContracts(ctx context.Context, settle string) ([]FuturesContract, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetAllFutureContracts(ctx context.Context, settle currency.Code) ([]FuturesContract, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } var contracts []FuturesContract - return contracts, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, futuresPath+settle+"/contracts", &contracts) + return contracts, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, futuresPath+settle.Item.Lower+"/contracts", &contracts) } // GetSingleContract returns a single contract info for the specified settle and Currency Pair (contract << in this case) -func (g *Gateio) GetSingleContract(ctx context.Context, settle, contract string) (*FuturesContract, error) { +func (g *Gateio) GetSingleContract(ctx context.Context, settle currency.Code, contract string) (*FuturesContract, error) { if contract == "" { return nil, currency.ErrCurrencyPairEmpty } - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } var futureContract *FuturesContract - return futureContract, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, futuresPath+settle+"/contracts/"+contract, &futureContract) + return futureContract, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, futuresPath+settle.Item.Lower+"/contracts/"+contract, &futureContract) } // GetFuturesOrderbook retrieves futures order book data -func (g *Gateio) GetFuturesOrderbook(ctx context.Context, settle, contract, interval string, limit uint64, withOrderbookID bool) (*Orderbook, error) { +func (g *Gateio) GetFuturesOrderbook(ctx context.Context, settle currency.Code, contract, interval string, limit uint64, withOrderbookID bool) (*Orderbook, error) { if contract == "" { return nil, currency.ErrCurrencyPairEmpty } - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} params.Set("contract", contract) @@ -1892,14 +1890,13 @@ func (g *Gateio) GetFuturesOrderbook(ctx context.Context, settle, contract, inte params.Set("with_id", "true") } var response *Orderbook - return response, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, common.EncodeURLValues(futuresPath+settle+"/order_book", params), &response) + return response, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, common.EncodeURLValues(futuresPath+settle.Item.Lower+"/order_book", params), &response) } // GetFuturesTradingHistory retrieves futures trading history -func (g *Gateio) GetFuturesTradingHistory(ctx context.Context, settle string, contract currency.Pair, limit, offset uint64, lastID string, from, to time.Time) ([]TradingHistoryItem, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetFuturesTradingHistory(ctx context.Context, settle currency.Code, contract currency.Pair, limit, offset uint64, lastID string, from, to time.Time) ([]TradingHistoryItem, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsEmpty() { return nil, currency.ErrCurrencyPairEmpty @@ -1923,14 +1920,13 @@ func (g *Gateio) GetFuturesTradingHistory(ctx context.Context, settle string, co } var response []TradingHistoryItem return response, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, - common.EncodeURLValues(futuresPath+settle+"/trades", params), &response) + common.EncodeURLValues(futuresPath+settle.Item.Lower+"/trades", params), &response) } // GetFuturesCandlesticks retrieves specified contract candlesticks. -func (g *Gateio) GetFuturesCandlesticks(ctx context.Context, settle, contract string, from, to time.Time, limit uint64, interval kline.Interval) ([]FuturesCandlestick, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetFuturesCandlesticks(ctx context.Context, settle currency.Code, contract string, from, to time.Time, limit uint64, interval kline.Interval) ([]FuturesCandlestick, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract == "" { return nil, currency.ErrCurrencyPairEmpty @@ -1955,15 +1951,15 @@ func (g *Gateio) GetFuturesCandlesticks(ctx context.Context, settle, contract st } var candlesticks []FuturesCandlestick return candlesticks, g.SendHTTPRequest(ctx, exchange.RestFutures, perpetualSwapDefaultEPL, - common.EncodeURLValues(futuresPath+settle+"/candlesticks", params), + common.EncodeURLValues(futuresPath+settle.Item.Lower+"/candlesticks", params), &candlesticks) } // PremiumIndexKLine retrieves premium Index K-Line // Maximum of 1000 points can be returned in a query. Be sure not to exceed the limit when specifying from, to and interval -func (g *Gateio) PremiumIndexKLine(ctx context.Context, settleCurrency string, contract currency.Pair, from, to time.Time, limit int64, interval kline.Interval) ([]FuturesPremiumIndexKLineResponse, error) { - if settleCurrency == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) PremiumIndexKLine(ctx context.Context, settleCurrency currency.Code, contract currency.Pair, from, to time.Time, limit int64, interval kline.Interval) ([]FuturesPremiumIndexKLineResponse, error) { + if settleCurrency.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsEmpty() { return nil, currency.ErrCurrencyPairEmpty @@ -1985,28 +1981,26 @@ func (g *Gateio) PremiumIndexKLine(ctx context.Context, settleCurrency string, c } params.Set("interval", intervalString) var resp []FuturesPremiumIndexKLineResponse - return resp, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, common.EncodeURLValues(futuresPath+settleCurrency+"/premium_index", params), &resp) + return resp, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, common.EncodeURLValues(futuresPath+settleCurrency.Item.Lower+"/premium_index", params), &resp) } // GetFuturesTickers retrieves futures ticker information for a specific settle and contract info. -func (g *Gateio) GetFuturesTickers(ctx context.Context, settle string, contract currency.Pair) ([]FuturesTicker, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetFuturesTickers(ctx context.Context, settle currency.Code, contract currency.Pair) ([]FuturesTicker, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} if contract.IsPopulated() { params.Set("contract", contract.String()) } var tickers []FuturesTicker - return tickers, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, common.EncodeURLValues(futuresPath+settle+"/tickers", params), &tickers) + return tickers, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, common.EncodeURLValues(futuresPath+settle.Item.Lower+"/tickers", params), &tickers) } // GetFutureFundingRates retrieves funding rate information. -func (g *Gateio) GetFutureFundingRates(ctx context.Context, settle string, contract currency.Pair, limit uint64) ([]FuturesFundingRate, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetFutureFundingRates(ctx context.Context, settle currency.Code, contract currency.Pair, limit uint64) ([]FuturesFundingRate, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, currency.ErrCurrencyPairEmpty @@ -2017,14 +2011,13 @@ func (g *Gateio) GetFutureFundingRates(ctx context.Context, settle string, contr params.Set("limit", strconv.FormatUint(limit, 10)) } var rates []FuturesFundingRate - return rates, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, common.EncodeURLValues(futuresPath+settle+"/funding_rate", params), &rates) + return rates, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, common.EncodeURLValues(futuresPath+settle.Item.Lower+"/funding_rate", params), &rates) } // GetFuturesInsuranceBalanceHistory retrieves futures insurance balance history -func (g *Gateio) GetFuturesInsuranceBalanceHistory(ctx context.Context, settle string, limit uint64) ([]InsuranceBalance, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetFuturesInsuranceBalanceHistory(ctx context.Context, settle currency.Code, limit uint64) ([]InsuranceBalance, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} if limit > 0 { @@ -2033,15 +2026,14 @@ func (g *Gateio) GetFuturesInsuranceBalanceHistory(ctx context.Context, settle s var balances []InsuranceBalance return balances, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, - common.EncodeURLValues(futuresPath+settle+"/insurance", params), + common.EncodeURLValues(futuresPath+settle.Item.Lower+"/insurance", params), &balances) } // GetFutureStats retrieves futures stats -func (g *Gateio) GetFutureStats(ctx context.Context, settle string, contract currency.Pair, from time.Time, interval kline.Interval, limit uint64) ([]ContractStat, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetFutureStats(ctx context.Context, settle currency.Code, contract currency.Pair, from time.Time, interval kline.Interval, limit uint64) ([]ContractStat, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, currency.ErrCurrencyPairEmpty @@ -2064,15 +2056,14 @@ func (g *Gateio) GetFutureStats(ctx context.Context, settle string, contract cur var stats []ContractStat return stats, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, - common.EncodeURLValues(futuresPath+settle+"/contract_stats", params), + common.EncodeURLValues(futuresPath+settle.Item.Lower+"/contract_stats", params), &stats) } // GetIndexConstituent retrieves index constituents -func (g *Gateio) GetIndexConstituent(ctx context.Context, settle, index string) (*IndexConstituent, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetIndexConstituent(ctx context.Context, settle currency.Code, index string) (*IndexConstituent, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if index == "" { return nil, currency.ErrCurrencyPairEmpty @@ -2081,15 +2072,14 @@ func (g *Gateio) GetIndexConstituent(ctx context.Context, settle, index string) var constituents *IndexConstituent return constituents, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, - futuresPath+settle+"/index_constituents/"+indexString, + futuresPath+settle.Item.Lower+"/index_constituents/"+indexString, &constituents) } // GetLiquidationHistory retrieves liqudiation history -func (g *Gateio) GetLiquidationHistory(ctx context.Context, settle string, contract currency.Pair, from, to time.Time, limit uint64) ([]LiquidationHistory, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetLiquidationHistory(ctx context.Context, settle currency.Code, contract currency.Pair, from, to time.Time, limit uint64) ([]LiquidationHistory, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, errInvalidOrMissingContractParam @@ -2108,24 +2098,23 @@ func (g *Gateio) GetLiquidationHistory(ctx context.Context, settle string, contr var histories []LiquidationHistory return histories, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, - common.EncodeURLValues(futuresPath+settle+"/liq_orders", params), + common.EncodeURLValues(futuresPath+settle.Item.Lower+"/liq_orders", params), &histories) } // QueryFuturesAccount retrieves futures account -func (g *Gateio) QueryFuturesAccount(ctx context.Context, settle string) (*FuturesAccount, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) QueryFuturesAccount(ctx context.Context, settle currency.Code) (*FuturesAccount, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } var response *FuturesAccount - return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, futuresPath+settle+"/accounts", nil, nil, &response) + return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, futuresPath+settle.Item.Lower+"/accounts", nil, nil, &response) } // GetFuturesAccountBooks retrieves account books -func (g *Gateio) GetFuturesAccountBooks(ctx context.Context, settle string, limit uint64, from, to time.Time, changingType string) ([]AccountBookItem, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetFuturesAccountBooks(ctx context.Context, settle currency.Code, limit uint64, from, to time.Time, changingType string) ([]AccountBookItem, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} if limit > 0 { @@ -2142,44 +2131,43 @@ func (g *Gateio) GetFuturesAccountBooks(ctx context.Context, settle string, limi } var response []AccountBookItem return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, - http.MethodGet, futuresPath+settle+"/account_book", + http.MethodGet, futuresPath+settle.Item.Lower+"/account_book", params, nil, &response) } // GetAllFuturesPositionsOfUsers list all positions of users. -func (g *Gateio) GetAllFuturesPositionsOfUsers(ctx context.Context, settle string, realPositionsOnly bool) ([]Position, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetAllFuturesPositionsOfUsers(ctx context.Context, settle currency.Code, realPositionsOnly bool) ([]Position, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} if realPositionsOnly { params.Set("holding", "true") } var response []Position - return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, futuresPath+settle+"/positions", params, nil, &response) + return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, futuresPath+settle.Item.Lower+"/positions", params, nil, &response) } // GetSinglePosition returns a single position -func (g *Gateio) GetSinglePosition(ctx context.Context, settle string, contract currency.Pair) (*Position, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetSinglePosition(ctx context.Context, settle currency.Code, contract currency.Pair) (*Position, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) } var response *Position return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, - http.MethodPost, futuresPath+settle+positionsPath+contract.String(), + http.MethodPost, futuresPath+settle.Item.Lower+positionsPath+contract.String(), nil, nil, &response) } // UpdateFuturesPositionMargin represents account position margin for a futures contract. -func (g *Gateio) UpdateFuturesPositionMargin(ctx context.Context, settle string, change float64, contract currency.Pair) (*Position, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) UpdateFuturesPositionMargin(ctx context.Context, settle currency.Code, change float64, contract currency.Pair) (*Position, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) @@ -2192,14 +2180,14 @@ func (g *Gateio) UpdateFuturesPositionMargin(ctx context.Context, settle string, var response *Position return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPlaceOrdersEPL, - http.MethodPost, futuresPath+settle+positionsPath+contract.String()+"/margin", + http.MethodPost, futuresPath+settle.Item.Lower+positionsPath+contract.String()+"/margin", params, nil, &response) } // UpdateFuturesPositionLeverage update position leverage -func (g *Gateio) UpdateFuturesPositionLeverage(ctx context.Context, settle string, contract currency.Pair, leverage, crossLeverageLimit float64) (*Position, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) UpdateFuturesPositionLeverage(ctx context.Context, settle currency.Code, contract currency.Pair, leverage, crossLeverageLimit float64) (*Position, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) @@ -2215,13 +2203,13 @@ func (g *Gateio) UpdateFuturesPositionLeverage(ctx context.Context, settle strin var response *Position return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPlaceOrdersEPL, http.MethodPost, - futuresPath+settle+positionsPath+contract.String()+"/leverage", params, nil, &response) + futuresPath+settle.Item.Lower+positionsPath+contract.String()+"/leverage", params, nil, &response) } // UpdateFuturesPositionRiskLimit updates the position risk limit -func (g *Gateio) UpdateFuturesPositionRiskLimit(ctx context.Context, settle string, contract currency.Pair, riskLimit uint64) (*Position, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) UpdateFuturesPositionRiskLimit(ctx context.Context, settle currency.Code, contract currency.Pair, riskLimit uint64) (*Position, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) @@ -2230,27 +2218,27 @@ func (g *Gateio) UpdateFuturesPositionRiskLimit(ctx context.Context, settle stri params.Set("risk_limit", strconv.FormatUint(riskLimit, 10)) var response *Position return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPlaceOrdersEPL, - http.MethodPost, futuresPath+settle+positionsPath+contract.String()+"/risk_limit", params, nil, &response) + http.MethodPost, futuresPath+settle.Item.Lower+positionsPath+contract.String()+"/risk_limit", params, nil, &response) } // EnableOrDisableDualMode enable or disable dual mode // Before setting dual mode, make sure all positions are closed and no orders are open -func (g *Gateio) EnableOrDisableDualMode(ctx context.Context, settle string, dualMode bool) (*DualModeResponse, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) EnableOrDisableDualMode(ctx context.Context, settle currency.Code, dualMode bool) (*DualModeResponse, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} params.Set("dual_mode", strconv.FormatBool(dualMode)) var response *DualModeResponse return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, - http.MethodGet, futuresPath+settle+"/dual_mode", + http.MethodGet, futuresPath+settle.Item.Lower+"/dual_mode", params, nil, &response) } // RetrivePositionDetailInDualMode retrieve position detail in dual mode -func (g *Gateio) RetrivePositionDetailInDualMode(ctx context.Context, settle string, contract currency.Pair) ([]Position, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) RetrivePositionDetailInDualMode(ctx context.Context, settle currency.Code, contract currency.Pair) ([]Position, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) @@ -2258,14 +2246,14 @@ func (g *Gateio) RetrivePositionDetailInDualMode(ctx context.Context, settle str var response []Position return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, - futuresPath+settle+"/dual_comp/positions/"+contract.String(), + futuresPath+settle.Item.Lower+"/dual_comp/positions/"+contract.String(), nil, nil, &response) } // UpdatePositionMarginInDualMode update position margin in dual mode -func (g *Gateio) UpdatePositionMarginInDualMode(ctx context.Context, settle string, contract currency.Pair, change float64, dualSide string) ([]Position, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) UpdatePositionMarginInDualMode(ctx context.Context, settle currency.Code, contract currency.Pair, change float64, dualSide string) ([]Position, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) @@ -2279,14 +2267,14 @@ func (g *Gateio) UpdatePositionMarginInDualMode(ctx context.Context, settle stri var response []Position return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPlaceOrdersEPL, http.MethodPost, - futuresPath+settle+"/dual_comp/positions/"+contract.String()+"/margin", + futuresPath+settle.Item.Lower+"/dual_comp/positions/"+contract.String()+"/margin", params, nil, &response) } // UpdatePositionLeverageInDualMode update position leverage in dual mode -func (g *Gateio) UpdatePositionLeverageInDualMode(ctx context.Context, settle string, contract currency.Pair, leverage, crossLeverageLimit float64) (*Position, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) UpdatePositionLeverageInDualMode(ctx context.Context, settle currency.Code, contract currency.Pair, leverage, crossLeverageLimit float64) (*Position, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) @@ -2300,13 +2288,13 @@ func (g *Gateio) UpdatePositionLeverageInDualMode(ctx context.Context, settle st params.Set("cross_leverage_limit", strconv.FormatFloat(crossLeverageLimit, 'f', -1, 64)) } var response *Position - return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPlaceOrdersEPL, http.MethodPost, futuresPath+settle+"/dual_comp/positions/"+contract.String()+"/leverage", params, nil, &response) + return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPlaceOrdersEPL, http.MethodPost, futuresPath+settle.Item.Lower+"/dual_comp/positions/"+contract.String()+"/leverage", params, nil, &response) } // UpdatePositionRiskLimitInDualMode update position risk limit in dual mode -func (g *Gateio) UpdatePositionRiskLimitInDualMode(ctx context.Context, settle string, contract currency.Pair, riskLimit float64) ([]Position, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) UpdatePositionRiskLimitInDualMode(ctx context.Context, settle currency.Code, contract currency.Pair, riskLimit float64) ([]Position, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) @@ -2319,7 +2307,7 @@ func (g *Gateio) UpdatePositionRiskLimitInDualMode(ctx context.Context, settle s var response []Position return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPlaceOrdersEPL, http.MethodPost, - futuresPath+settle+"/dual_comp/positions/"+contract.String()+"/risk_limit", params, + futuresPath+settle.Item.Lower+"/dual_comp/positions/"+contract.String()+"/risk_limit", params, nil, &response) } @@ -2352,16 +2340,16 @@ func (g *Gateio) PlaceFuturesOrder(ctx context.Context, arg *OrderCreateParams) if arg.AutoSize != "" && (arg.AutoSize == "close_long" || arg.AutoSize == "close_short") { return nil, errInvalidAutoSizeValue } - arg.Settle = strings.ToLower(arg.Settle) - if arg.Settle == "" { - return nil, errEmptySettlementCurrency + if arg.Settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } + var response *Order return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPlaceOrdersEPL, http.MethodPost, - futuresPath+arg.Settle+ordersPath, + futuresPath+arg.Settle.Item.Lower+ordersPath, nil, &arg, &response) @@ -2369,9 +2357,9 @@ func (g *Gateio) PlaceFuturesOrder(ctx context.Context, arg *OrderCreateParams) // GetFuturesOrders retrieves list of futures orders // Zero-filled order cannot be retrieved 10 minutes after order cancellation -func (g *Gateio) GetFuturesOrders(ctx context.Context, contract currency.Pair, status, lastID, settle string, limit, offset uint64, countTotal int64) ([]Order, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetFuturesOrders(ctx context.Context, contract currency.Pair, status, lastID string, settle currency.Code, limit, offset uint64, countTotal int64) ([]Order, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} if !contract.IsEmpty() { @@ -2397,15 +2385,15 @@ func (g *Gateio) GetFuturesOrders(ctx context.Context, contract currency.Pair, s } var response []Order return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, - http.MethodGet, futuresPath+settle+ordersPath, + http.MethodGet, futuresPath+settle.Item.Lower+ordersPath, params, nil, &response) } // CancelMultipleFuturesOpenOrders ancel all open orders // Zero-filled order cannot be retrieved 10 minutes after order cancellation -func (g *Gateio) CancelMultipleFuturesOpenOrders(ctx context.Context, contract currency.Pair, side, settle string) ([]Order, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) CancelMultipleFuturesOpenOrders(ctx context.Context, contract currency.Pair, side string, settle currency.Code) ([]Order, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) @@ -2417,7 +2405,7 @@ func (g *Gateio) CancelMultipleFuturesOpenOrders(ctx context.Context, contract c params.Set("contract", contract.String()) var response []Order return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapCancelOrdersEPL, - http.MethodDelete, futuresPath+settle+ordersPath, params, nil, &response) + http.MethodDelete, futuresPath+settle.Item.Lower+ordersPath, params, nil, &response) } // PlaceBatchFuturesOrders creates a list of futures orders @@ -2428,9 +2416,9 @@ func (g *Gateio) CancelMultipleFuturesOpenOrders(ctx context.Context, contract c // In the returned result, the succeeded field of type bool indicates whether the execution was successful or not // If the execution is successful, the normal order content is included; if the execution fails, the label field is included to indicate the cause of the error // In the rate limiting, each order is counted individually -func (g *Gateio) PlaceBatchFuturesOrders(ctx context.Context, settle string, args []OrderCreateParams) ([]Order, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) PlaceBatchFuturesOrders(ctx context.Context, settle currency.Code, args []OrderCreateParams) ([]Order, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if len(args) > 10 { return nil, errTooManyOrderRequest @@ -2457,20 +2445,20 @@ func (g *Gateio) PlaceBatchFuturesOrders(ctx context.Context, settle string, arg if args[x].AutoSize != "" && (args[x].AutoSize == "close_long" || args[x].AutoSize == "close_short") { return nil, errInvalidAutoSizeValue } - if args[x].Settle != settleBTC && args[x].Settle != settleUSD && args[x].Settle != settleUSDT { - return nil, errEmptySettlementCurrency + if !args[x].Settle.Equal(currency.BTC) && !args[x].Settle.Equal(currency.USDT) { + return nil, errEmptyOrInvalidSettlementCurrency } } var response []Order return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, - http.MethodPost, futuresPath+settle+"/batch_orders", + http.MethodPost, futuresPath+settle.Item.Lower+"/batch_orders", nil, &args, &response) } // GetSingleFuturesOrder retrieves a single order by its identifier -func (g *Gateio) GetSingleFuturesOrder(ctx context.Context, settle, orderID string) (*Order, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetSingleFuturesOrder(ctx context.Context, settle currency.Code, orderID string) (*Order, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if orderID == "" { return nil, fmt.Errorf("%w, 'order_id' cannot be empty", errInvalidOrderID) @@ -2478,27 +2466,27 @@ func (g *Gateio) GetSingleFuturesOrder(ctx context.Context, settle, orderID stri var response *Order return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, - http.MethodGet, futuresPath+settle+"/orders/"+orderID, + http.MethodGet, futuresPath+settle.Item.Lower+"/orders/"+orderID, nil, nil, &response) } // CancelSingleFuturesOrder cancel a single order -func (g *Gateio) CancelSingleFuturesOrder(ctx context.Context, settle, orderID string) (*Order, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) CancelSingleFuturesOrder(ctx context.Context, settle currency.Code, orderID string) (*Order, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if orderID == "" { return nil, fmt.Errorf("%w, 'order_id' cannot be empty", errInvalidOrderID) } var response *Order return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapCancelOrdersEPL, http.MethodDelete, - futuresPath+settle+"/orders/"+orderID, nil, nil, &response) + futuresPath+settle.Item.Lower+"/orders/"+orderID, nil, nil, &response) } // AmendFuturesOrder amends an existing futures order -func (g *Gateio) AmendFuturesOrder(ctx context.Context, settle, orderID string, arg AmendFuturesOrderParam) (*Order, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) AmendFuturesOrder(ctx context.Context, settle currency.Code, orderID string, arg AmendFuturesOrderParam) (*Order, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if orderID == "" { return nil, fmt.Errorf("%w, 'order_id' cannot be empty", errInvalidOrderID) @@ -2508,13 +2496,13 @@ func (g *Gateio) AmendFuturesOrder(ctx context.Context, settle, orderID string, } var response *Order return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPlaceOrdersEPL, http.MethodPut, - futuresPath+settle+"/orders/"+orderID, nil, &arg, &response) + futuresPath+settle.Item.Lower+"/orders/"+orderID, nil, &arg, &response) } // GetMyPersonalTradingHistory retrieves my personal trading history -func (g *Gateio) GetMyPersonalTradingHistory(ctx context.Context, settle, lastID, orderID string, contract currency.Pair, limit, offset, countTotal uint64) ([]TradingHistoryItem, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetMyPersonalTradingHistory(ctx context.Context, settle currency.Code, lastID, orderID string, contract currency.Pair, limit, offset, countTotal uint64) ([]TradingHistoryItem, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} if contract.IsPopulated() { @@ -2537,13 +2525,13 @@ func (g *Gateio) GetMyPersonalTradingHistory(ctx context.Context, settle, lastID } var response []TradingHistoryItem return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, - futuresPath+settle+"/my_trades", params, nil, &response) + futuresPath+settle.Item.Lower+"/my_trades", params, nil, &response) } // GetFuturesPositionCloseHistory lists position close history -func (g *Gateio) GetFuturesPositionCloseHistory(ctx context.Context, settle string, contract currency.Pair, limit, offset uint64, from, to time.Time) ([]PositionCloseHistoryResponse, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetFuturesPositionCloseHistory(ctx context.Context, settle currency.Code, contract currency.Pair, limit, offset uint64, from, to time.Time) ([]PositionCloseHistoryResponse, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} if contract.IsPopulated() { @@ -2563,13 +2551,13 @@ func (g *Gateio) GetFuturesPositionCloseHistory(ctx context.Context, settle stri } var response []PositionCloseHistoryResponse return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, - futuresPath+settle+"/position_close", params, nil, &response) + futuresPath+settle.Item.Lower+"/position_close", params, nil, &response) } // GetFuturesLiquidationHistory list liquidation history -func (g *Gateio) GetFuturesLiquidationHistory(ctx context.Context, settle string, contract currency.Pair, limit uint64, at time.Time) ([]LiquidationHistoryItem, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetFuturesLiquidationHistory(ctx context.Context, settle currency.Code, contract currency.Pair, limit uint64, at time.Time) ([]LiquidationHistoryItem, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} if contract.IsPopulated() { @@ -2584,13 +2572,13 @@ func (g *Gateio) GetFuturesLiquidationHistory(ctx context.Context, settle string var response []LiquidationHistoryItem return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, - futuresPath+settle+"/liquidates", params, nil, &response) + futuresPath+settle.Item.Lower+"/liquidates", params, nil, &response) } // CountdownCancelOrders represents a trigger time response -func (g *Gateio) CountdownCancelOrders(ctx context.Context, settle string, arg CountdownParams) (*TriggerTimeResponse, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) CountdownCancelOrders(ctx context.Context, settle currency.Code, arg CountdownParams) (*TriggerTimeResponse, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if arg.Timeout < 0 { return nil, errInvalidTimeout @@ -2598,16 +2586,16 @@ func (g *Gateio) CountdownCancelOrders(ctx context.Context, settle string, arg C var response *TriggerTimeResponse return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPlaceOrdersEPL, http.MethodPost, - futuresPath+settle+"/countdown_cancel_all", nil, &arg, &response) + futuresPath+settle.Item.Lower+"/countdown_cancel_all", nil, &arg, &response) } // CreatePriceTriggeredFuturesOrder create a price-triggered order -func (g *Gateio) CreatePriceTriggeredFuturesOrder(ctx context.Context, settle string, arg *FuturesPriceTriggeredOrderParam) (*OrderID, error) { +func (g *Gateio) CreatePriceTriggeredFuturesOrder(ctx context.Context, settle currency.Code, arg *FuturesPriceTriggeredOrderParam) (*OrderID, error) { if arg == nil { return nil, errNilArgument } - if settle == "" { - return nil, errEmptySettlementCurrency + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if arg.Initial.Contract.IsEmpty() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) @@ -2638,16 +2626,16 @@ func (g *Gateio) CreatePriceTriggeredFuturesOrder(ctx context.Context, settle st } var response *OrderID return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPlaceOrdersEPL, http.MethodPost, - futuresPath+settle+priceOrdersPaths, nil, &arg, &response) + futuresPath+settle.Item.Lower+priceOrdersPaths, nil, &arg, &response) } // ListAllFuturesAutoOrders lists all open orders -func (g *Gateio) ListAllFuturesAutoOrders(ctx context.Context, status, settle string, contract currency.Pair, limit, offset uint64) ([]PriceTriggeredOrder, error) { +func (g *Gateio) ListAllFuturesAutoOrders(ctx context.Context, status string, settle currency.Code, contract currency.Pair, limit, offset uint64) ([]PriceTriggeredOrder, error) { if status != statusOpen && status != statusFinished { return nil, fmt.Errorf("%w status: %s", errInvalidOrderStatus, status) } - if settle == "" { - return nil, errEmptySettlementCurrency + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} params.Set("status", status) @@ -2663,15 +2651,14 @@ func (g *Gateio) ListAllFuturesAutoOrders(ctx context.Context, status, settle st var response []PriceTriggeredOrder return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, - futuresPath+settle+priceOrdersPaths, + futuresPath+settle.Item.Lower+priceOrdersPaths, params, nil, &response) } // CancelAllFuturesOpenOrders cancels all futures open orders -func (g *Gateio) CancelAllFuturesOpenOrders(ctx context.Context, settle string, contract currency.Pair) ([]PriceTriggeredOrder, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) CancelAllFuturesOpenOrders(ctx context.Context, settle currency.Code, contract currency.Pair) ([]PriceTriggeredOrder, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) @@ -2680,13 +2667,13 @@ func (g *Gateio) CancelAllFuturesOpenOrders(ctx context.Context, settle string, params.Set("contract", contract.String()) var response []PriceTriggeredOrder return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapCancelOrdersEPL, http.MethodDelete, - futuresPath+settle+priceOrdersPaths, params, nil, &response) + futuresPath+settle.Item.Lower+priceOrdersPaths, params, nil, &response) } // GetSingleFuturesPriceTriggeredOrder retrieves a single price triggered order -func (g *Gateio) GetSingleFuturesPriceTriggeredOrder(ctx context.Context, settle, orderID string) (*PriceTriggeredOrder, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetSingleFuturesPriceTriggeredOrder(ctx context.Context, settle currency.Code, orderID string) (*PriceTriggeredOrder, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if orderID == "" { return nil, errInvalidOrderID @@ -2694,50 +2681,48 @@ func (g *Gateio) GetSingleFuturesPriceTriggeredOrder(ctx context.Context, settle var response *PriceTriggeredOrder return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, - futuresPath+settle+"/price_orders/"+orderID, nil, nil, &response) + futuresPath+settle.Item.Lower+"/price_orders/"+orderID, nil, nil, &response) } // CancelFuturesPriceTriggeredOrder cancel a price-triggered order -func (g *Gateio) CancelFuturesPriceTriggeredOrder(ctx context.Context, settle, orderID string) (*PriceTriggeredOrder, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) CancelFuturesPriceTriggeredOrder(ctx context.Context, settle currency.Code, orderID string) (*PriceTriggeredOrder, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if orderID == "" { return nil, errInvalidOrderID } var response *PriceTriggeredOrder return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapCancelOrdersEPL, http.MethodDelete, - futuresPath+settle+"/price_orders/"+orderID, nil, nil, &response) + futuresPath+settle.Item.Lower+"/price_orders/"+orderID, nil, nil, &response) } // *************************************** Delivery *************************************** // GetAllDeliveryContracts retrieves all futures contracts -func (g *Gateio) GetAllDeliveryContracts(ctx context.Context, settle string) ([]DeliveryContract, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetAllDeliveryContracts(ctx context.Context, settle currency.Code) ([]DeliveryContract, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } var contracts []DeliveryContract return contracts, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, - deliveryPath+settle+"/contracts", &contracts) + deliveryPath+settle.Item.Lower+"/contracts", &contracts) } // GetSingleDeliveryContracts retrieves a single delivery contract instance. -func (g *Gateio) GetSingleDeliveryContracts(ctx context.Context, settle string, contract currency.Pair) (*DeliveryContract, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetSingleDeliveryContracts(ctx context.Context, settle currency.Code, contract currency.Pair) (*DeliveryContract, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } var deliveryContract *DeliveryContract return deliveryContract, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, - deliveryPath+settle+"/contracts/"+contract.String(), &deliveryContract) + deliveryPath+settle.Item.Lower+"/contracts/"+contract.String(), &deliveryContract) } // GetDeliveryOrderbook delivery orderbook -func (g *Gateio) GetDeliveryOrderbook(ctx context.Context, settle, interval string, contract currency.Pair, limit uint64, withOrderbookID bool) (*Orderbook, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetDeliveryOrderbook(ctx context.Context, settle currency.Code, interval string, contract currency.Pair, limit uint64, withOrderbookID bool) (*Orderbook, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, errInvalidOrMissingContractParam @@ -2754,14 +2739,13 @@ func (g *Gateio) GetDeliveryOrderbook(ctx context.Context, settle, interval stri params.Set("with_id", strconv.FormatBool(withOrderbookID)) } var orderbook *Orderbook - return orderbook, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, common.EncodeURLValues(deliveryPath+settle+"/order_book", params), &orderbook) + return orderbook, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, common.EncodeURLValues(deliveryPath+settle.Item.Lower+"/order_book", params), &orderbook) } // GetDeliveryTradingHistory retrieves futures trading history -func (g *Gateio) GetDeliveryTradingHistory(ctx context.Context, settle, lastID string, contract currency.Pair, limit uint64, from, to time.Time) ([]DeliveryTradingHistory, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetDeliveryTradingHistory(ctx context.Context, settle currency.Code, lastID string, contract currency.Pair, limit uint64, from, to time.Time) ([]DeliveryTradingHistory, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, errInvalidOrMissingContractParam @@ -2782,14 +2766,13 @@ func (g *Gateio) GetDeliveryTradingHistory(ctx context.Context, settle, lastID s } var histories []DeliveryTradingHistory return histories, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, - common.EncodeURLValues(deliveryPath+settle+"/trades", params), &histories) + common.EncodeURLValues(deliveryPath+settle.Item.Lower+"/trades", params), &histories) } // GetDeliveryFuturesCandlesticks retrieves specified contract candlesticks -func (g *Gateio) GetDeliveryFuturesCandlesticks(ctx context.Context, settle string, contract currency.Pair, from, to time.Time, limit uint64, interval kline.Interval) ([]FuturesCandlestick, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetDeliveryFuturesCandlesticks(ctx context.Context, settle currency.Code, contract currency.Pair, from, to time.Time, limit uint64, interval kline.Interval) ([]FuturesCandlestick, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, errInvalidOrMissingContractParam @@ -2815,29 +2798,27 @@ func (g *Gateio) GetDeliveryFuturesCandlesticks(ctx context.Context, settle stri var candlesticks []FuturesCandlestick return candlesticks, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, - common.EncodeURLValues(deliveryPath+settle+"/candlesticks", params), + common.EncodeURLValues(deliveryPath+settle.Item.Lower+"/candlesticks", params), &candlesticks) } // GetDeliveryFutureTickers retrieves futures ticker information for a specific settle and contract info. -func (g *Gateio) GetDeliveryFutureTickers(ctx context.Context, settle string, contract currency.Pair) ([]FuturesTicker, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetDeliveryFutureTickers(ctx context.Context, settle currency.Code, contract currency.Pair) ([]FuturesTicker, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} if contract.IsPopulated() { params.Set("contract", contract.String()) } var tickers []FuturesTicker - return tickers, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, common.EncodeURLValues(deliveryPath+settle+"/tickers", params), &tickers) + return tickers, g.SendHTTPRequest(ctx, exchange.RestSpot, perpetualSwapDefaultEPL, common.EncodeURLValues(deliveryPath+settle.Item.Lower+"/tickers", params), &tickers) } // GetDeliveryInsuranceBalanceHistory retrieves delivery futures insurance balance history -func (g *Gateio) GetDeliveryInsuranceBalanceHistory(ctx context.Context, settle string, limit uint64) ([]InsuranceBalance, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetDeliveryInsuranceBalanceHistory(ctx context.Context, settle currency.Code, limit uint64) ([]InsuranceBalance, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} if limit > 0 { @@ -2845,24 +2826,23 @@ func (g *Gateio) GetDeliveryInsuranceBalanceHistory(ctx context.Context, settle } var balances []InsuranceBalance return balances, g.SendHTTPRequest(ctx, exchange.RestSpot, spotDefaultEPL, - common.EncodeURLValues(deliveryPath+settle+"/insurance", params), + common.EncodeURLValues(deliveryPath+settle.Item.Lower+"/insurance", params), &balances) } // GetDeliveryFuturesAccounts retrieves futures account -func (g *Gateio) GetDeliveryFuturesAccounts(ctx context.Context, settle string) (*FuturesAccount, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetDeliveryFuturesAccounts(ctx context.Context, settle currency.Code) (*FuturesAccount, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } var response *FuturesAccount - return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, deliveryPath+settle+"/accounts", nil, nil, &response) + return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, deliveryPath+settle.Item.Lower+"/accounts", nil, nil, &response) } // GetDeliveryAccountBooks retrieves account books -func (g *Gateio) GetDeliveryAccountBooks(ctx context.Context, settle string, limit uint64, from, to time.Time, changingType string) ([]AccountBookItem, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetDeliveryAccountBooks(ctx context.Context, settle currency.Code, limit uint64, from, to time.Time, changingType string) ([]AccountBookItem, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} if limit > 0 { @@ -2880,39 +2860,38 @@ func (g *Gateio) GetDeliveryAccountBooks(ctx context.Context, settle string, lim var response []AccountBookItem return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, - deliveryPath+settle+"/account_book", + deliveryPath+settle.Item.Lower+"/account_book", params, nil, &response) } // GetAllDeliveryPositionsOfUser retrieves all positions of user -func (g *Gateio) GetAllDeliveryPositionsOfUser(ctx context.Context, settle string) (*Position, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetAllDeliveryPositionsOfUser(ctx context.Context, settle currency.Code) (*Position, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } var response *Position return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, - deliveryPath+settle+"/positions", nil, nil, &response) + deliveryPath+settle.Item.Lower+"/positions", nil, nil, &response) } // GetSingleDeliveryPosition get single position -func (g *Gateio) GetSingleDeliveryPosition(ctx context.Context, settle string, contract currency.Pair) (*Position, error) { - settle = strings.ToLower(settle) - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetSingleDeliveryPosition(ctx context.Context, settle currency.Code, contract currency.Pair) (*Position, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) } var response *Position return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, - deliveryPath+settle+positionsPath+contract.String(), + deliveryPath+settle.Item.Lower+positionsPath+contract.String(), nil, nil, &response) } // UpdateDeliveryPositionMargin updates position margin -func (g *Gateio) UpdateDeliveryPositionMargin(ctx context.Context, settle string, change float64, contract currency.Pair) (*Position, error) { - if settle != settleBTC && settle != settleUSDT { - return nil, errEmptySettlementCurrency +func (g *Gateio) UpdateDeliveryPositionMargin(ctx context.Context, settle currency.Code, change float64, contract currency.Pair) (*Position, error) { + if !slices.Contains(settlementCurrencies, settle) { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) @@ -2924,13 +2903,13 @@ func (g *Gateio) UpdateDeliveryPositionMargin(ctx context.Context, settle string params.Set("change", strconv.FormatFloat(change, 'f', -1, 64)) var response *Position return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPlaceOrdersEPL, http.MethodPost, - deliveryPath+settle+positionsPath+contract.String()+"/margin", params, nil, &response) + deliveryPath+settle.Item.Lower+positionsPath+contract.String()+"/margin", params, nil, &response) } // UpdateDeliveryPositionLeverage updates position leverage -func (g *Gateio) UpdateDeliveryPositionLeverage(ctx context.Context, settle string, contract currency.Pair, leverage float64) (*Position, error) { - if settle != settleBTC && settle != settleUSDT { - return nil, errEmptySettlementCurrency +func (g *Gateio) UpdateDeliveryPositionLeverage(ctx context.Context, settle currency.Code, contract currency.Pair, leverage float64) (*Position, error) { + if !slices.Contains(settlementCurrencies, settle) { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) @@ -2943,14 +2922,14 @@ func (g *Gateio) UpdateDeliveryPositionLeverage(ctx context.Context, settle stri var response *Position return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPlaceOrdersEPL, http.MethodPost, - deliveryPath+settle+positionsPath+contract.String()+"/leverage", + deliveryPath+settle.Item.Lower+positionsPath+contract.String()+"/leverage", params, nil, &response) } // UpdateDeliveryPositionRiskLimit update position risk limit -func (g *Gateio) UpdateDeliveryPositionRiskLimit(ctx context.Context, settle string, contract currency.Pair, riskLimit uint64) (*Position, error) { - if settle != settleBTC && settle != settleUSDT { - return nil, errEmptySettlementCurrency +func (g *Gateio) UpdateDeliveryPositionRiskLimit(ctx context.Context, settle currency.Code, contract currency.Pair, riskLimit uint64) (*Position, error) { + if !slices.Contains(settlementCurrencies, settle) { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) @@ -2959,7 +2938,7 @@ func (g *Gateio) UpdateDeliveryPositionRiskLimit(ctx context.Context, settle str params.Set("risk_limit", strconv.FormatUint(riskLimit, 10)) var response *Position return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPlaceOrdersEPL, http.MethodPost, - deliveryPath+settle+positionsPath+contract.String()+"/risk_limit", params, nil, &response) + deliveryPath+settle.Item.Lower+positionsPath+contract.String()+"/risk_limit", params, nil, &response) } // PlaceDeliveryOrder create a futures order @@ -2983,20 +2962,19 @@ func (g *Gateio) PlaceDeliveryOrder(ctx context.Context, arg *OrderCreateParams) if arg.AutoSize != "" && (arg.AutoSize == "close_long" || arg.AutoSize == "close_short") { return nil, errInvalidAutoSizeValue } - arg.Settle = strings.ToLower(arg.Settle) - if arg.Settle == "" { - return nil, errEmptySettlementCurrency + if arg.Settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } var response *Order return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPlaceOrdersEPL, http.MethodPost, - deliveryPath+arg.Settle+ordersPath, nil, &arg, &response) + deliveryPath+arg.Settle.Item.Lower+ordersPath, nil, &arg, &response) } // GetDeliveryOrders list futures orders // Zero-filled order cannot be retrieved 10 minutes after order cancellation -func (g *Gateio) GetDeliveryOrders(ctx context.Context, contract currency.Pair, status, settle, lastID string, limit, offset uint64, countTotal int64) ([]Order, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetDeliveryOrders(ctx context.Context, contract currency.Pair, status string, settle currency.Code, lastID string, limit, offset uint64, countTotal int64) ([]Order, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} if !contract.IsEmpty() { @@ -3022,14 +3000,14 @@ func (g *Gateio) GetDeliveryOrders(ctx context.Context, contract currency.Pair, } var response []Order return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, - deliveryPath+settle+ordersPath, params, nil, &response) + deliveryPath+settle.Item.Lower+ordersPath, params, nil, &response) } // CancelMultipleDeliveryOrders cancel all open orders matched // Zero-filled order cannot be retrieved 10 minutes after order cancellation -func (g *Gateio) CancelMultipleDeliveryOrders(ctx context.Context, contract currency.Pair, side, settle string) ([]Order, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) CancelMultipleDeliveryOrders(ctx context.Context, contract currency.Pair, side string, settle currency.Code) ([]Order, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) @@ -3041,40 +3019,40 @@ func (g *Gateio) CancelMultipleDeliveryOrders(ctx context.Context, contract curr params.Set("contract", contract.String()) var response []Order return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapCancelOrdersEPL, http.MethodDelete, - deliveryPath+settle+ordersPath, params, nil, &response) + deliveryPath+settle.Item.Lower+ordersPath, params, nil, &response) } // GetSingleDeliveryOrder Get a single order // Zero-filled order cannot be retrieved 10 minutes after order cancellation -func (g *Gateio) GetSingleDeliveryOrder(ctx context.Context, settle, orderID string) (*Order, error) { - if settle != settleBTC && settle != settleUSDT { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetSingleDeliveryOrder(ctx context.Context, settle currency.Code, orderID string) (*Order, error) { + if !slices.Contains(settlementCurrencies, settle) { + return nil, errEmptyOrInvalidSettlementCurrency } if orderID == "" { return nil, fmt.Errorf("%w, 'order_id' cannot be empty", errInvalidOrderID) } var response *Order return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, - deliveryPath+settle+"/orders/"+orderID, nil, nil, &response) + deliveryPath+settle.Item.Lower+"/orders/"+orderID, nil, nil, &response) } // CancelSingleDeliveryOrder cancel a single order -func (g *Gateio) CancelSingleDeliveryOrder(ctx context.Context, settle, orderID string) (*Order, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) CancelSingleDeliveryOrder(ctx context.Context, settle currency.Code, orderID string) (*Order, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if orderID == "" { return nil, fmt.Errorf("%w, 'order_id' cannot be empty", errInvalidOrderID) } var response *Order return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapCancelOrdersEPL, http.MethodDelete, - deliveryPath+settle+"/orders/"+orderID, nil, nil, &response) + deliveryPath+settle.Item.Lower+"/orders/"+orderID, nil, nil, &response) } // GetDeliveryPersonalTradingHistory retrieves personal trading history -func (g *Gateio) GetDeliveryPersonalTradingHistory(ctx context.Context, settle, orderID string, contract currency.Pair, limit, offset, countTotal uint64, lastID string) ([]TradingHistoryItem, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetDeliveryPersonalTradingHistory(ctx context.Context, settle currency.Code, orderID string, contract currency.Pair, limit, offset, countTotal uint64, lastID string) ([]TradingHistoryItem, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} if contract.IsPopulated() { @@ -3097,13 +3075,13 @@ func (g *Gateio) GetDeliveryPersonalTradingHistory(ctx context.Context, settle, } var response []TradingHistoryItem return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, - deliveryPath+settle+"/my_trades", params, nil, &response) + deliveryPath+settle.Item.Lower+"/my_trades", params, nil, &response) } // GetDeliveryPositionCloseHistory retrieves position history -func (g *Gateio) GetDeliveryPositionCloseHistory(ctx context.Context, settle string, contract currency.Pair, limit, offset uint64, from, to time.Time) ([]PositionCloseHistoryResponse, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetDeliveryPositionCloseHistory(ctx context.Context, settle currency.Code, contract currency.Pair, limit, offset uint64, from, to time.Time) ([]PositionCloseHistoryResponse, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} if contract.IsPopulated() { @@ -3123,13 +3101,13 @@ func (g *Gateio) GetDeliveryPositionCloseHistory(ctx context.Context, settle str } var response []PositionCloseHistoryResponse return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, - deliveryPath+settle+"/position_close", params, nil, &response) + deliveryPath+settle.Item.Lower+"/position_close", params, nil, &response) } // GetDeliveryLiquidationHistory lists liquidation history -func (g *Gateio) GetDeliveryLiquidationHistory(ctx context.Context, settle string, contract currency.Pair, limit uint64, at time.Time) ([]LiquidationHistoryItem, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetDeliveryLiquidationHistory(ctx context.Context, settle currency.Code, contract currency.Pair, limit uint64, at time.Time) ([]LiquidationHistoryItem, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} if contract.IsPopulated() { @@ -3143,13 +3121,13 @@ func (g *Gateio) GetDeliveryLiquidationHistory(ctx context.Context, settle strin } var response []LiquidationHistoryItem return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, - deliveryPath+settle+"/liquidates", params, nil, &response) + deliveryPath+settle.Item.Lower+"/liquidates", params, nil, &response) } // GetDeliverySettlementHistory retrieves settlement history -func (g *Gateio) GetDeliverySettlementHistory(ctx context.Context, settle string, contract currency.Pair, limit uint64, at time.Time) ([]SettlementHistoryItem, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetDeliverySettlementHistory(ctx context.Context, settle currency.Code, contract currency.Pair, limit uint64, at time.Time) ([]SettlementHistoryItem, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} if contract.IsPopulated() { @@ -3163,16 +3141,16 @@ func (g *Gateio) GetDeliverySettlementHistory(ctx context.Context, settle string } var response []SettlementHistoryItem return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, - deliveryPath+settle+"/settlements", params, nil, &response) + deliveryPath+settle.Item.Lower+"/settlements", params, nil, &response) } // GetDeliveryPriceTriggeredOrder creates a price-triggered order -func (g *Gateio) GetDeliveryPriceTriggeredOrder(ctx context.Context, settle string, arg *FuturesPriceTriggeredOrderParam) (*OrderID, error) { +func (g *Gateio) GetDeliveryPriceTriggeredOrder(ctx context.Context, settle currency.Code, arg *FuturesPriceTriggeredOrderParam) (*OrderID, error) { if arg == nil { return nil, errNilArgument } - if settle == "" { - return nil, errEmptySettlementCurrency + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if arg.Initial.Contract.IsEmpty() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) @@ -3210,16 +3188,16 @@ func (g *Gateio) GetDeliveryPriceTriggeredOrder(ctx context.Context, settle stri } var response *OrderID return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodPost, - deliveryPath+settle+priceOrdersPaths, nil, &arg, &response) + deliveryPath+settle.Item.Lower+priceOrdersPaths, nil, &arg, &response) } // GetDeliveryAllAutoOrder retrieves all auto orders -func (g *Gateio) GetDeliveryAllAutoOrder(ctx context.Context, status, settle string, contract currency.Pair, limit, offset uint64) ([]PriceTriggeredOrder, error) { +func (g *Gateio) GetDeliveryAllAutoOrder(ctx context.Context, status string, settle currency.Code, contract currency.Pair, limit, offset uint64) ([]PriceTriggeredOrder, error) { if status != statusOpen && status != statusFinished { return nil, fmt.Errorf("%w status %s", errInvalidOrderStatus, status) } - if settle == "" { - return nil, errEmptySettlementCurrency + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } params := url.Values{} params.Set("status", status) @@ -3234,13 +3212,13 @@ func (g *Gateio) GetDeliveryAllAutoOrder(ctx context.Context, status, settle str } var response []PriceTriggeredOrder return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, - deliveryPath+settle+priceOrdersPaths, params, nil, &response) + deliveryPath+settle.Item.Lower+priceOrdersPaths, params, nil, &response) } // CancelAllDeliveryPriceTriggeredOrder cancels all delivery price triggered orders -func (g *Gateio) CancelAllDeliveryPriceTriggeredOrder(ctx context.Context, settle string, contract currency.Pair) ([]PriceTriggeredOrder, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) CancelAllDeliveryPriceTriggeredOrder(ctx context.Context, settle currency.Code, contract currency.Pair) ([]PriceTriggeredOrder, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if contract.IsInvalid() { return nil, fmt.Errorf("%w, currency pair for contract must not be empty", errInvalidOrMissingContractParam) @@ -3249,33 +3227,33 @@ func (g *Gateio) CancelAllDeliveryPriceTriggeredOrder(ctx context.Context, settl params.Set("contract", contract.String()) var response []PriceTriggeredOrder return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapCancelOrdersEPL, http.MethodDelete, - deliveryPath+settle+priceOrdersPaths, params, nil, &response) + deliveryPath+settle.Item.Lower+priceOrdersPaths, params, nil, &response) } // GetSingleDeliveryPriceTriggeredOrder retrieves a single price triggered order -func (g *Gateio) GetSingleDeliveryPriceTriggeredOrder(ctx context.Context, settle, orderID string) (*PriceTriggeredOrder, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) GetSingleDeliveryPriceTriggeredOrder(ctx context.Context, settle currency.Code, orderID string) (*PriceTriggeredOrder, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if orderID == "" { return nil, errInvalidOrderID } var response *PriceTriggeredOrder return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapPrivateEPL, http.MethodGet, - deliveryPath+settle+"/price_orders/"+orderID, nil, nil, &response) + deliveryPath+settle.Item.Lower+"/price_orders/"+orderID, nil, nil, &response) } // CancelDeliveryPriceTriggeredOrder cancel a price-triggered order -func (g *Gateio) CancelDeliveryPriceTriggeredOrder(ctx context.Context, settle, orderID string) (*PriceTriggeredOrder, error) { - if settle == "" { - return nil, errEmptySettlementCurrency +func (g *Gateio) CancelDeliveryPriceTriggeredOrder(ctx context.Context, settle currency.Code, orderID string) (*PriceTriggeredOrder, error) { + if settle.IsEmpty() { + return nil, errEmptyOrInvalidSettlementCurrency } if orderID == "" { return nil, errInvalidOrderID } var response *PriceTriggeredOrder return response, g.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, perpetualSwapCancelOrdersEPL, http.MethodDelete, - deliveryPath+settle+"/price_orders/"+orderID, nil, nil, &response) + deliveryPath+settle.Item.Lower+"/price_orders/"+orderID, nil, nil, &response) } // ********************************** Options *************************************************** @@ -3780,7 +3758,7 @@ func (g *Gateio) IsValidPairString(currencyPair string) bool { func (g *Gateio) GetFee(ctx context.Context, feeBuilder *exchange.FeeBuilder) (fee float64, err error) { switch feeBuilder.FeeType { case exchange.CryptocurrencyTradeFee: - feePairs, err := g.GetPersonalTradingFee(ctx, feeBuilder.Pair, "") + feePairs, err := g.GetPersonalTradingFee(ctx, feeBuilder.Pair, currency.EMPTYCODE) if err != nil { return 0, err } @@ -3826,22 +3804,15 @@ func (g *Gateio) GetUnderlyingFromCurrencyPair(p currency.Pair) (currency.Pair, } return currency.Pair{Base: currency.NewCode(ccies[0]), Delimiter: currency.UnderscoreDelimiter, Quote: currency.NewCode(ccies[1])}, nil } -func (g *Gateio) getSettlementFromCurrency(currencyPair currency.Pair, ignoreUSDSettles bool) (settlement string, err error) { +func getSettlementFromCurrency(currencyPair currency.Pair) (settlement currency.Code, err error) { quote := currencyPair.Quote.Upper().String() + switch { case strings.HasPrefix(quote, currency.USDT.String()): - return currency.USDT.Item.Lower, nil - case strings.HasPrefix(quote, currency.BTC.String()): - return currency.BTC.Item.Lower, nil + return currency.USDT, nil case strings.HasPrefix(quote, currency.USD.String()): - if ignoreUSDSettles { - return currency.BTC.Item.Lower, nil - } - return currency.USD.Item.Lower, nil - case strings.HasPrefix(currencyPair.Base.Upper().String(), currency.BTC.String()): - // some instruments having a BTC base currency uses a BTC settlement - return currency.BTC.Item.Lower, nil + return currency.BTC, nil default: - return "", fmt.Errorf("%w %v", errCannotParseSettlementCurrency, currencyPair) + return currency.EMPTYCODE, fmt.Errorf("%w %v", errCannotParseSettlementCurrency, currencyPair) } } diff --git a/exchanges/gateio/gateio_test.go b/exchanges/gateio/gateio_test.go index 5e8ee348..477e0d16 100644 --- a/exchanges/gateio/gateio_test.go +++ b/exchanges/gateio/gateio_test.go @@ -262,26 +262,17 @@ func TestGetTicker(t *testing.T) { func TestGetOrderbook(t *testing.T) { t.Parallel() _, err := g.GetOrderbook(context.Background(), getPair(t, asset.Spot).String(), "0.1", 10, false) - if err != nil { - t.Errorf("%s GetOrderbook() error %v", g.Name, err) - } - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Fatal(err) - } - if _, err = g.GetFuturesOrderbook(context.Background(), settle, getPair(t, asset.Futures).String(), "", 10, false); err != nil { - t.Errorf("%s GetOrderbook() error %v", g.Name, err) - } - settle, err = g.getSettlementFromCurrency(getPair(t, asset.DeliveryFutures), false) - if err != nil { - t.Fatal(err) - } - if _, err = g.GetDeliveryOrderbook(context.Background(), settle, "0.1", getPair(t, asset.DeliveryFutures), 10, false); err != nil { - t.Errorf("%s GetOrderbook() error %v", g.Name, err) - } - if _, err = g.GetOptionsOrderbook(context.Background(), getPair(t, asset.Options), "0.1", 10, false); err != nil { - t.Errorf("%s GetOrderbook() error %v", g.Name, err) - } + assert.NoError(t, err, "GetOrderbook should not error") + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + assert.NoError(t, err, "getSettlementFromCurrency should not error") + _, err = g.GetFuturesOrderbook(context.Background(), settle, getPair(t, asset.Futures).String(), "", 10, false) + assert.NoError(t, err, "GetFuturesOrderbook should not error") + settle, err = getSettlementFromCurrency(getPair(t, asset.DeliveryFutures)) + assert.NoError(t, err, "getSettlementFromCurrency should not error") + _, err = g.GetDeliveryOrderbook(context.Background(), settle, "0.1", getPair(t, asset.DeliveryFutures), 10, false) + assert.NoError(t, err, "GetDeliveryOrderbook should not error") + _, err = g.GetOptionsOrderbook(context.Background(), getPair(t, asset.Options), "0.1", 10, false) + assert.NoError(t, err, "GetOptionsOrderbook should not error") } func TestGetMarketTrades(t *testing.T) { @@ -911,9 +902,8 @@ func TestGetSubAccountMarginBalances(t *testing.T) { func TestGetSubAccountFuturesBalances(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetSubAccountFuturesBalances(context.Background(), "", ""); err != nil { - t.Errorf("%s GetSubAccountFuturesBalance() error %v", g.Name, err) - } + _, err := g.GetSubAccountFuturesBalances(context.Background(), "", currency.EMPTYCODE) + assert.Error(t, err, "GetSubAccountFuturesBalances should not error") } func TestGetSubAccountCrossMarginBalances(t *testing.T) { @@ -935,9 +925,8 @@ func TestGetSavedAddresses(t *testing.T) { func TestGetPersonalTradingFee(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetPersonalTradingFee(context.Background(), currency.Pair{Base: currency.BTC, Quote: currency.USDT, Delimiter: currency.UnderscoreDelimiter}, ""); err != nil { - t.Errorf("%s GetPersonalTradingFee() error %v", g.Name, err) - } + _, err := g.GetPersonalTradingFee(context.Background(), currency.Pair{Base: currency.BTC, Quote: currency.USDT, Delimiter: currency.UnderscoreDelimiter}, currency.EMPTYCODE) + assert.NoError(t, err, "GetPersonalTradingFee should not error") } func TestGetUsersTotalBalance(t *testing.T) { @@ -971,205 +960,156 @@ func TestGetOrderbookOfLendingLoans(t *testing.T) { func TestGetAllFutureContracts(t *testing.T) { t.Parallel() - _, err := g.GetAllFutureContracts(context.Background(), settleUSD) - if err != nil { - t.Errorf("%s GetAllFutureContracts() error %v", g.Name, err) - } - if _, err = g.GetAllFutureContracts(context.Background(), settleUSDT); err != nil { - t.Errorf("%s GetAllFutureContracts() error %v", g.Name, err) - } - if _, err = g.GetAllFutureContracts(context.Background(), settleBTC); err != nil { - t.Errorf("%s GetAllFutureContracts() error %v", g.Name, err) + for _, settlementCurrency := range settlementCurrencies { + if _, err := g.GetAllFutureContracts(context.Background(), settlementCurrency); err != nil { + assert.Errorf(t, err, "GetAllFutureContracts %s should not error", settlementCurrency) + } } } + func TestGetSingleContract(t *testing.T) { t.Parallel() - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Fatal(err) - } - if _, err = g.GetSingleContract(context.Background(), settle, getPair(t, asset.Futures).String()); err != nil { - t.Errorf("%s GetSingleContract() error %s", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.GetSingleContract(context.Background(), settle, getPair(t, asset.Futures).String()) + assert.NoError(t, err, "GetSingleContract should not error") } func TestGetFuturesOrderbook(t *testing.T) { t.Parallel() - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Fatal(err) - } - if _, err := g.GetFuturesOrderbook(context.Background(), settle, getPair(t, asset.Futures).String(), "", 0, false); err != nil { - t.Errorf("%s GetFuturesOrderbook() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.GetFuturesOrderbook(context.Background(), settle, getPair(t, asset.Futures).String(), "", 0, false) + assert.NoError(t, err, "GetFuturesOrderbook should not error") } func TestGetFuturesTradingHistory(t *testing.T) { t.Parallel() - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Fatal(err) - } - if _, err := g.GetFuturesTradingHistory(context.Background(), settle, getPair(t, asset.Futures), 0, 0, "", time.Time{}, time.Time{}); err != nil { - t.Errorf("%s GetFuturesTradingHistory() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.GetFuturesTradingHistory(context.Background(), settle, getPair(t, asset.Futures), 0, 0, "", time.Time{}, time.Time{}) + assert.NoError(t, err, "GetFuturesTradingHistory should not error") } func TestGetFuturesCandlesticks(t *testing.T) { t.Parallel() - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Fatal(err) - } - if _, err := g.GetFuturesCandlesticks(context.Background(), settle, getPair(t, asset.Futures).String(), time.Time{}, time.Time{}, 0, kline.OneWeek); err != nil { - t.Errorf("%s GetFuturesCandlesticks() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.GetFuturesCandlesticks(context.Background(), settle, getPair(t, asset.Futures).String(), time.Time{}, time.Time{}, 0, kline.OneWeek) + assert.NoError(t, err, "GetFuturesCandlesticks should not error") } func TestPremiumIndexKLine(t *testing.T) { t.Parallel() - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Error(err) - } - if _, err := g.PremiumIndexKLine(context.Background(), settle, getPair(t, asset.Futures), time.Time{}, time.Time{}, 0, kline.OneWeek); err != nil { - t.Errorf("%s PremiumIndexKLine() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.PremiumIndexKLine(context.Background(), settle, getPair(t, asset.Futures), time.Time{}, time.Time{}, 0, kline.OneWeek) + assert.NoError(t, err, "PremiumIndexKLine should not error") } func TestGetFutureTickers(t *testing.T) { t.Parallel() - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Fatal(err) - } - if _, err := g.GetFuturesTickers(context.Background(), settle, getPair(t, asset.Futures)); err != nil { - t.Errorf("%s GetFuturesTickers() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.GetFuturesTickers(context.Background(), settle, getPair(t, asset.Futures)) + assert.NoError(t, err, "GetFutureTickers should not error") } func TestGetFutureFundingRates(t *testing.T) { t.Parallel() - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Fatal(err) - } - if _, err := g.GetFutureFundingRates(context.Background(), settle, getPair(t, asset.Futures), 0); err != nil { - t.Errorf("%s GetFutureFundingRates() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.GetFutureFundingRates(context.Background(), settle, getPair(t, asset.Futures), 0) + assert.NoError(t, err, "GetFutureFundingRates should not error") } func TestGetFuturesInsuranceBalanceHistory(t *testing.T) { t.Parallel() - if _, err := g.GetFuturesInsuranceBalanceHistory(context.Background(), settleUSDT, 0); err != nil { - t.Errorf("%s GetFuturesInsuranceBalanceHistory() error %v", g.Name, err) - } + _, err := g.GetFuturesInsuranceBalanceHistory(context.Background(), currency.USDT, 0) + assert.NoError(t, err, "GetFuturesInsuranceBalanceHistory should not error") } func TestGetFutureStats(t *testing.T) { t.Parallel() - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Error(err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") _, err = g.GetFutureStats(context.Background(), settle, getPair(t, asset.Futures), time.Time{}, 0, 0) - if err != nil { - t.Errorf("%s GetFutureStats() error %v", g.Name, err) - } + assert.NoError(t, err, "GetFutureStats should not error") } func TestGetIndexConstituent(t *testing.T) { t.Parallel() - if _, err := g.GetIndexConstituent(context.Background(), settleUSDT, currency.Pair{Base: currency.BTC, Quote: currency.USDT, Delimiter: currency.UnderscoreDelimiter}.String()); err != nil { - t.Errorf("%s GetIndexConstituent() error %v", g.Name, err) - } + _, err := g.GetIndexConstituent(context.Background(), currency.USDT, currency.Pair{Base: currency.BTC, Quote: currency.USDT, Delimiter: currency.UnderscoreDelimiter}.String()) + assert.NoError(t, err, "GetIndexConstituent should not error") } func TestGetLiquidationHistory(t *testing.T) { t.Parallel() - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Error(err) - } - if _, err := g.GetLiquidationHistory(context.Background(), settle, getPair(t, asset.Futures), time.Time{}, time.Time{}, 0); err != nil { - t.Errorf("%s GetLiquidationHistory() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.GetLiquidationHistory(context.Background(), settle, getPair(t, asset.Futures), time.Time{}, time.Time{}, 0) + assert.NoError(t, err, "GetLiquidationHistory should not error") } func TestQueryFuturesAccount(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.QueryFuturesAccount(context.Background(), settleUSDT); err != nil { - t.Errorf("%s QueryFuturesAccount() error %v", g.Name, err) - } + _, err := g.QueryFuturesAccount(context.Background(), currency.USDT) + assert.NoError(t, err, "QueryFuturesAccount should not error") } func TestGetFuturesAccountBooks(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetFuturesAccountBooks(context.Background(), settleUSDT, 0, time.Time{}, time.Time{}, "dnw"); err != nil { - t.Errorf("%s GetFuturesAccountBooks() error %v", g.Name, err) - } + _, err := g.GetFuturesAccountBooks(context.Background(), currency.USDT, 0, time.Time{}, time.Time{}, "dnw") + assert.NoError(t, err, "GetFuturesAccountBooks should not error") } -func TestGetAllPositionsOfUsers(t *testing.T) { +func TestGetAllFuturesPositionsOfUsers(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetAllFuturesPositionsOfUsers(context.Background(), settleUSDT, true); err != nil { - t.Errorf("%s GetAllPositionsOfUsers() error %v", g.Name, err) - } + _, err := g.GetAllFuturesPositionsOfUsers(context.Background(), currency.USDT, true) + assert.NoError(t, err, "GetAllPositionsOfUsers should not error") } func TestGetSinglePosition(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetSinglePosition(context.Background(), settleUSDT, currency.Pair{Quote: currency.BTC, Base: currency.USDT}); err != nil { - t.Errorf("%s GetSinglePosition() error %v", g.Name, err) - } + _, err := g.GetSinglePosition(context.Background(), currency.USDT, currency.Pair{Quote: currency.BTC, Base: currency.USDT}) + assert.NoError(t, err, "GetSinglePosition should not error") } -func TestUpdatePositionMargin(t *testing.T) { +func TestUpdateFuturesPositionMargin(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Fatal(err) - } - if _, err := g.UpdateFuturesPositionMargin(context.Background(), settle, 0.01, getPair(t, asset.Futures)); err != nil { - t.Errorf("%s UpdatePositionMargin() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.UpdateFuturesPositionMargin(context.Background(), settle, 0.01, getPair(t, asset.Futures)) + assert.NoError(t, err, "UpdateFuturesPositionMargin should not error") } -func TestUpdatePositionLeverage(t *testing.T) { +func TestUpdateFuturesPositionLeverage(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Fatal(err) - } - if _, err := g.UpdateFuturesPositionLeverage(context.Background(), settle, getPair(t, asset.Futures), 1, 0); err != nil { - t.Errorf("%s UpdatePositionLeverage() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.UpdateFuturesPositionLeverage(context.Background(), settle, getPair(t, asset.Futures), 1, 0) + assert.NoError(t, err, "UpdateFuturesPositionLeverage should not error") } -func TestUpdatePositionRiskLimit(t *testing.T) { +func TestUpdateFuturesPositionRiskLimit(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Fatal(err) - } - if _, err := g.UpdateFuturesPositionRiskLimit(context.Background(), settle, getPair(t, asset.Futures), 10); err != nil { - t.Errorf("%s UpdatePositionRiskLimit() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.UpdateFuturesPositionRiskLimit(context.Background(), settle, getPair(t, asset.Futures), 10) + assert.NoError(t, err, "UpdateFuturesPositionRiskLimit should not error") } -func TestCreateDeliveryOrder(t *testing.T) { +func TestPlaceDeliveryOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - settle, err := g.getSettlementFromCurrency(getPair(t, asset.DeliveryFutures), false) - if err != nil { - t.Fatal(err) - } - if _, err := g.PlaceDeliveryOrder(context.Background(), &OrderCreateParams{ + settle, err := getSettlementFromCurrency(getPair(t, asset.DeliveryFutures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.PlaceDeliveryOrder(context.Background(), &OrderCreateParams{ Contract: getPair(t, asset.DeliveryFutures), Size: 6024, Iceberg: 0, @@ -1177,96 +1117,80 @@ func TestCreateDeliveryOrder(t *testing.T) { Text: "t-my-custom-id", Settle: settle, TimeInForce: gtcTIF, - }); err != nil { - t.Errorf("%s CreateDeliveryOrder() error %v", g.Name, err) - } + }) + assert.NoError(t, err, "CreateDeliveryOrder should not error") } func TestGetDeliveryOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - settle, err := g.getSettlementFromCurrency(getPair(t, asset.DeliveryFutures), false) - if err != nil { - t.Fatal(err) - } - if _, err := g.GetDeliveryOrders(context.Background(), getPair(t, asset.DeliveryFutures), "open", settle, "", 0, 0, 1); err != nil { - t.Errorf("%s GetDeliveryOrders() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.DeliveryFutures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.GetDeliveryOrders(context.Background(), getPair(t, asset.DeliveryFutures), "open", settle, "", 0, 0, 1) + assert.NoError(t, err, "GetDeliveryOrders should not error") } -func TestCancelAllDeliveryOrders(t *testing.T) { +func TestCancelMultipleDeliveryOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - settle, err := g.getSettlementFromCurrency(getPair(t, asset.DeliveryFutures), false) - if err != nil { - t.Fatal(err) - } - if _, err := g.CancelMultipleDeliveryOrders(context.Background(), getPair(t, asset.DeliveryFutures), "ask", settle); err != nil { - t.Errorf("%s CancelAllDeliveryOrders() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.DeliveryFutures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.CancelMultipleDeliveryOrders(context.Background(), getPair(t, asset.DeliveryFutures), "ask", settle) + assert.NoError(t, err, "CancelMultipleDeliveryOrders should not error") } func TestGetSingleDeliveryOrder(t *testing.T) { t.Parallel() + _, err := g.GetSingleDeliveryOrder(context.Background(), currency.USD, "123456") + assert.ErrorIs(t, err, errEmptyOrInvalidSettlementCurrency, "GetSingleDeliveryOrder should return errEmptyOrInvalidSettlementCurrency") sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetSingleDeliveryOrder(context.Background(), settleUSDT, "123456"); err != nil { - t.Errorf("%s GetSingleDeliveryOrder() error %v", g.Name, err) - } - if _, err := g.GetSingleDeliveryOrder(context.Background(), settleBTC, "123456"); err != nil { - t.Errorf("%s GetSingleDeliveryOrder() error %v", g.Name, err) - } - if _, err := g.GetSingleDeliveryOrder(context.Background(), settleUSD, "123456"); !errors.Is(err, errEmptySettlementCurrency) { - t.Errorf("%s GetSingleDeliveryOrder() expected %v, but found %v", g.Name, errEmptySettlementCurrency, err) + for _, settle := range settlementCurrencies { + _, err := g.GetSingleDeliveryOrder(context.Background(), settle, "123456") + assert.NoErrorf(t, err, "GetSingleDeliveryOrder %s should not error", settle) } } func TestCancelSingleDeliveryOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - if _, err := g.CancelSingleDeliveryOrder(context.Background(), settleUSDT, "123456"); err != nil { - t.Errorf("%s CancelSingleDeliveryOrder() error %v", g.Name, err) - } - if _, err := g.CancelSingleDeliveryOrder(context.Background(), settleBTC, "123456"); err != nil { - t.Errorf("%s CancelSingleDeliveryOrder() error %v", g.Name, err) + for _, settle := range settlementCurrencies { + _, err := g.CancelSingleDeliveryOrder(context.Background(), settle, "123456") + assert.NoErrorf(t, err, "CancelSingleDeliveryOrder %s should not error", settle) } } func TestGetDeliveryPersonalTradingHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetDeliveryPersonalTradingHistory(context.Background(), settleUSDT, "", getPair(t, asset.DeliveryFutures), 0, 0, 1, ""); err != nil { - t.Errorf("%s GetDeliveryPersonalTradingHistory() error %v", g.Name, err) - } + _, err := g.GetDeliveryPersonalTradingHistory(context.Background(), currency.USDT, "", getPair(t, asset.DeliveryFutures), 0, 0, 1, "") + assert.NoError(t, err, "GetDeliveryPersonalTradingHistory should not error") } func TestGetDeliveryPositionCloseHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetDeliveryPositionCloseHistory(context.Background(), settleUSDT, getPair(t, asset.DeliveryFutures), 0, 0, time.Time{}, time.Time{}); err != nil { - t.Errorf("%s GetDeliveryPositionCloseHistory() error %v", g.Name, err) - } + _, err := g.GetDeliveryPositionCloseHistory(context.Background(), currency.USDT, getPair(t, asset.DeliveryFutures), 0, 0, time.Time{}, time.Time{}) + assert.NoError(t, err, "GetDeliveryPositionCloseHistory should not error") } func TestGetDeliveryLiquidationHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetDeliveryLiquidationHistory(context.Background(), settleUSDT, getPair(t, asset.DeliveryFutures), 0, time.Now()); err != nil { - t.Errorf("%s GetDeliveryLiquidationHistory() error %v", g.Name, err) - } + _, err := g.GetDeliveryLiquidationHistory(context.Background(), currency.USDT, getPair(t, asset.DeliveryFutures), 0, time.Now()) + assert.NoError(t, err, "GetDeliveryLiquidationHistory should not error") } func TestGetDeliverySettlementHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetDeliverySettlementHistory(context.Background(), settleUSDT, getPair(t, asset.DeliveryFutures), 0, time.Now()); err != nil { - t.Errorf("%s GetDeliverySettlementHistory() error %v", g.Name, err) - } + _, err := g.GetDeliverySettlementHistory(context.Background(), currency.USDT, getPair(t, asset.DeliveryFutures), 0, time.Now()) + assert.NoError(t, err, "GetDeliverySettlementHistory should not error") } func TestGetDeliveryPriceTriggeredOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetDeliveryPriceTriggeredOrder(context.Background(), settleUSDT, &FuturesPriceTriggeredOrderParam{ + _, err := g.GetDeliveryPriceTriggeredOrder(context.Background(), currency.USDT, &FuturesPriceTriggeredOrderParam{ Initial: FuturesInitial{ Price: 1234., Size: 12, @@ -1277,110 +1201,88 @@ func TestGetDeliveryPriceTriggeredOrder(t *testing.T) { OrderType: "close-short-position", Price: 123400, }, - }); err != nil { - t.Errorf("%s GetDeliveryPriceTriggeredOrder() error %v", g.Name, err) - } + }) + assert.NoError(t, err, "GetDeliveryPriceTriggeredOrder should not error") } func TestGetDeliveryAllAutoOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetDeliveryAllAutoOrder(context.Background(), "open", settleUSDT, getPair(t, asset.DeliveryFutures), 0, 1); err != nil { - t.Errorf("%s GetDeliveryAllAutoOrder() error %v", g.Name, err) - } + _, err := g.GetDeliveryAllAutoOrder(context.Background(), "open", currency.USDT, getPair(t, asset.DeliveryFutures), 0, 1) + assert.NoError(t, err, "GetDeliveryAllAutoOrder should not error") } func TestCancelAllDeliveryPriceTriggeredOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - settle, err := g.getSettlementFromCurrency(getPair(t, asset.DeliveryFutures), false) - if err != nil { - t.Fatal(err) - } - if _, err := g.CancelAllDeliveryPriceTriggeredOrder(context.Background(), settle, getPair(t, asset.DeliveryFutures)); err != nil { - t.Errorf("%s CancelAllDeliveryPriceTriggeredOrder() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.DeliveryFutures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.CancelAllDeliveryPriceTriggeredOrder(context.Background(), settle, getPair(t, asset.DeliveryFutures)) + assert.NoError(t, err, "CancelAllDeliveryPriceTriggeredOrder should not error") } func TestGetSingleDeliveryPriceTriggeredOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetSingleDeliveryPriceTriggeredOrder(context.Background(), settleBTC, "12345"); err != nil { - t.Errorf("%s GetSingleDeliveryPriceTriggeredOrder() error %v", g.Name, err) - } + _, err := g.GetSingleDeliveryPriceTriggeredOrder(context.Background(), currency.BTC, "12345") + assert.NoError(t, err, "GetSingleDeliveryPriceTriggeredOrder should not error") } func TestCancelDeliveryPriceTriggeredOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - if _, err := g.CancelDeliveryPriceTriggeredOrder(context.Background(), settleUSDT, "12345"); err != nil { - t.Errorf("%s CancelDeliveryPriceTriggeredOrder() error %v", g.Name, err) - } + _, err := g.CancelDeliveryPriceTriggeredOrder(context.Background(), currency.USDT, "12345") + assert.NoError(t, err, "CancelDeliveryPriceTriggeredOrder should not error") } func TestEnableOrDisableDualMode(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.EnableOrDisableDualMode(context.Background(), settleBTC, true); err != nil { - t.Errorf("%s EnableOrDisableDualMode() error %v", g.Name, err) - } + _, err := g.EnableOrDisableDualMode(context.Background(), currency.BTC, true) + assert.NoError(t, err, "EnableOrDisableDualMode should not error") } func TestRetrivePositionDetailInDualMode(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Fatal(err) - } - if _, err = g.RetrivePositionDetailInDualMode(context.Background(), settle, getPair(t, asset.Futures)); err != nil { - t.Errorf("%s RetrivePositionDetailInDualMode() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.RetrivePositionDetailInDualMode(context.Background(), settle, getPair(t, asset.Futures)) + assert.NoError(t, err, "RetrivePositionDetailInDualMode should not error") } func TestUpdatePositionMarginInDualMode(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Fatal(err) - } - if _, err = g.UpdatePositionMarginInDualMode(context.Background(), settle, getPair(t, asset.Futures), 0.001, "dual_long"); err != nil { - t.Errorf("%s UpdatePositionMarginInDualMode() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.UpdatePositionMarginInDualMode(context.Background(), settle, getPair(t, asset.Futures), 0.001, "dual_long") + assert.NoError(t, err, "UpdatePositionMarginInDualMode should not error") } func TestUpdatePositionLeverageInDualMode(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Fatal(err) - } - if _, err = g.UpdatePositionLeverageInDualMode(context.Background(), settle, getPair(t, asset.Futures), 0.001, 0.001); err != nil { - t.Errorf("%s UpdatePositionLeverageInDualMode() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.UpdatePositionLeverageInDualMode(context.Background(), settle, getPair(t, asset.Futures), 0.001, 0.001) + assert.NoError(t, err, "UpdatePositionLeverageInDualMode should not error") } -func TestUpdatePositionRiskLimitinDualMode(t *testing.T) { +func TestUpdatePositionRiskLimitInDualMode(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Fatal(err) - } - if _, err = g.UpdatePositionRiskLimitInDualMode(context.Background(), settle, getPair(t, asset.Futures), 10); err != nil { - t.Errorf("%s UpdatePositionRiskLimitinDualMode() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.UpdatePositionRiskLimitInDualMode(context.Background(), settle, getPair(t, asset.Futures), 10) + assert.NoError(t, err, "UpdatePositionRiskLimitInDualMode should not error") } -func TestCreateFuturesOrder(t *testing.T) { +func TestPlaceFuturesOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Fatal(err) - } - if _, err := g.PlaceFuturesOrder(context.Background(), &OrderCreateParams{ + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.PlaceFuturesOrder(context.Background(), &OrderCreateParams{ Contract: getPair(t, asset.Futures), Size: 6024, Iceberg: 0, @@ -1388,51 +1290,44 @@ func TestCreateFuturesOrder(t *testing.T) { TimeInForce: "gtc", Text: "t-my-custom-id", Settle: settle, - }); err != nil { - t.Errorf("%s CreateFuturesOrder() error %v", g.Name, err) - } + }) + assert.NoError(t, err, "PlaceFuturesOrder should not error") } func TestGetFuturesOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetFuturesOrders(context.Background(), currency.NewPair(currency.BTC, currency.USD), "open", "", settleBTC, 0, 0, 1); err != nil { - t.Errorf("%s GetFuturesOrders() error %v", g.Name, err) - } + _, err := g.GetFuturesOrders(context.Background(), currency.NewPair(currency.BTC, currency.USD), "open", "", currency.BTC, 0, 0, 1) + assert.NoError(t, err, "GetFuturesOrders should not error") } func TestCancelMultipleFuturesOpenOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - if _, err := g.CancelMultipleFuturesOpenOrders(context.Background(), getPair(t, asset.Futures), "ask", settleUSDT); err != nil { - t.Errorf("%s CancelAllOpenOrdersMatched() error %v", g.Name, err) - } + _, err := g.CancelMultipleFuturesOpenOrders(context.Background(), getPair(t, asset.Futures), "ask", currency.USDT) + assert.NoError(t, err, "CancelMultipleFuturesOpenOrders should not error") } func TestGetSingleFuturesPriceTriggeredOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetSingleFuturesPriceTriggeredOrder(context.Background(), settleBTC, "12345"); err != nil { - t.Errorf("%s GetSingleFuturesPriceTriggeredOrder() error %v", g.Name, err) - } + _, err := g.GetSingleFuturesPriceTriggeredOrder(context.Background(), currency.BTC, "12345") + assert.NoError(t, err, "GetSingleFuturesPriceTriggeredOrder should not error") } func TestCancelFuturesPriceTriggeredOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - if _, err := g.CancelFuturesPriceTriggeredOrder(context.Background(), settleUSDT, "12345"); err != nil { - t.Errorf("%s CancelFuturesPriceTriggeredOrder() error %v", g.Name, err) - } + _, err := g.CancelFuturesPriceTriggeredOrder(context.Background(), currency.USDT, "12345") + assert.NoError(t, err, "CancelFuturesPriceTriggeredOrder should not error") } -func TestCreateBatchFuturesOrders(t *testing.T) { +func TestPlaceBatchFuturesOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), true) - if err != nil { - t.Fatal(err) - } - if _, err := g.PlaceBatchFuturesOrders(context.Background(), settleBTC, []OrderCreateParams{ + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.PlaceBatchFuturesOrders(context.Background(), currency.BTC, []OrderCreateParams{ { Contract: getPair(t, asset.Futures), Size: 6024, @@ -1449,79 +1344,69 @@ func TestCreateBatchFuturesOrders(t *testing.T) { Price: "376225", TimeInForce: "gtc", Text: "t-my-custom-id", - Settle: settleBTC, + Settle: currency.BTC, }, - }); err != nil { - t.Errorf("%s CreateBatchFuturesOrders() error %v", g.Name, err) - } + }) + assert.NoError(t, err, "PlaceBatchFuturesOrders should not error") } func TestGetSingleFuturesOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetSingleFuturesOrder(context.Background(), settleBTC, "12345"); err != nil { - t.Errorf("%s GetSingleFuturesOrder() error %v", g.Name, err) - } + _, err := g.GetSingleFuturesOrder(context.Background(), currency.BTC, "12345") + assert.NoError(t, err, "GetSingleFuturesOrder should not error") } func TestCancelSingleFuturesOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - if _, err := g.CancelSingleFuturesOrder(context.Background(), settleBTC, "12345"); err != nil { - t.Errorf("%s CancelSingleFuturesOrder() error %v", g.Name, err) - } + _, err := g.CancelSingleFuturesOrder(context.Background(), currency.BTC, "12345") + assert.NoError(t, err, "CancelSingleFuturesOrder should not error") } func TestAmendFuturesOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - if _, err := g.AmendFuturesOrder(context.Background(), settleBTC, "1234", AmendFuturesOrderParam{ + _, err := g.AmendFuturesOrder(context.Background(), currency.BTC, "1234", AmendFuturesOrderParam{ Price: 12345.990, - }); err != nil { - t.Errorf("%s AmendFuturesOrder() error %v", g.Name, err) - } + }) + assert.NoError(t, err, "AmendFuturesOrder should not error") } func TestGetMyPersonalTradingHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetMyPersonalTradingHistory(context.Background(), settleBTC, "", "", getPair(t, asset.Futures), 0, 0, 0); err != nil { - t.Errorf("%s GetMyPersonalTradingHistory() error %v", g.Name, err) - } + _, err := g.GetMyPersonalTradingHistory(context.Background(), currency.BTC, "", "", getPair(t, asset.Futures), 0, 0, 0) + assert.NoError(t, err, "GetMyPersonalTradingHistory should not error") } -func TestGetPositionCloseHistory(t *testing.T) { +func TestGetFuturesPositionCloseHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetFuturesPositionCloseHistory(context.Background(), settleBTC, getPair(t, asset.Futures), 0, 0, time.Time{}, time.Time{}); err != nil { - t.Errorf("%s GetPositionCloseHistory() error %v", g.Name, err) - } + _, err := g.GetFuturesPositionCloseHistory(context.Background(), currency.BTC, getPair(t, asset.Futures), 0, 0, time.Time{}, time.Time{}) + assert.NoError(t, err, "GetFuturesPositionCloseHistory should not error") } func TestGetFuturesLiquidationHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetFuturesLiquidationHistory(context.Background(), settleBTC, getPair(t, asset.Futures), 0, time.Time{}); err != nil { - t.Errorf("%s GetFuturesLiquidationHistory() error %v", g.Name, err) - } + _, err := g.GetFuturesLiquidationHistory(context.Background(), currency.BTC, getPair(t, asset.Futures), 0, time.Time{}) + assert.NoError(t, err, "GetFuturesLiquidationHistory should not error") } func TestCountdownCancelOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - if _, err := g.CountdownCancelOrders(context.Background(), settleBTC, CountdownParams{ + _, err := g.CountdownCancelOrders(context.Background(), currency.BTC, CountdownParams{ Timeout: 8, - }); err != nil { - t.Errorf("%s CountdownCancelOrders() error %v", g.Name, err) - } + }) + assert.NoError(t, err, "CountdownCancelOrders should not error") } func TestCreatePriceTriggeredFuturesOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), false) - if err != nil { - t.Fatal(err) - } - if _, err := g.CreatePriceTriggeredFuturesOrder(context.Background(), settle, &FuturesPriceTriggeredOrderParam{ + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.CreatePriceTriggeredFuturesOrder(context.Background(), settle, &FuturesPriceTriggeredOrderParam{ Initial: FuturesInitial{ Price: 1234., Size: 2, @@ -1531,10 +1416,9 @@ func TestCreatePriceTriggeredFuturesOrder(t *testing.T) { Rule: 1, OrderType: "close-short-position", }, - }); err != nil { - t.Errorf("%s CreatePriceTriggeredFuturesOrder() error %v", g.Name, err) - } - if _, err := g.CreatePriceTriggeredFuturesOrder(context.Background(), settle, &FuturesPriceTriggeredOrderParam{ + }) + assert.NoError(t, err, "CreatePriceTriggeredFuturesOrder should not error") + _, err = g.CreatePriceTriggeredFuturesOrder(context.Background(), settle, &FuturesPriceTriggeredOrderParam{ Initial: FuturesInitial{ Price: 1234., Size: 1, @@ -1543,152 +1427,124 @@ func TestCreatePriceTriggeredFuturesOrder(t *testing.T) { Trigger: FuturesTrigger{ Rule: 1, }, - }); err != nil { - t.Errorf("%s CreatePriceTriggeredFuturesOrder() error %v", g.Name, err) - } + }) + assert.NoError(t, err, "CreatePriceTriggeredFuturesOrder should not error") } func TestListAllFuturesAutoOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.ListAllFuturesAutoOrders(context.Background(), "open", settleBTC, currency.EMPTYPAIR, 0, 0); err != nil { - t.Errorf("%s ListAllFuturesAutoOrders() error %v", g.Name, err) - } + _, err := g.ListAllFuturesAutoOrders(context.Background(), "open", currency.BTC, currency.EMPTYPAIR, 0, 0) + assert.NoError(t, err, "ListAllFuturesAutoOrders should not error") } func TestCancelAllFuturesOpenOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - settle, err := g.getSettlementFromCurrency(getPair(t, asset.Futures), false) - if err != nil { - t.Fatal(err) - } - if _, err := g.CancelAllFuturesOpenOrders(context.Background(), settle, getPair(t, asset.Futures)); err != nil { - t.Errorf("%s CancelAllFuturesOpenOrders() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.Futures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.CancelAllFuturesOpenOrders(context.Background(), settle, getPair(t, asset.Futures)) + assert.NoError(t, err, "CancelAllFuturesOpenOrders should not error") } func TestGetAllDeliveryContracts(t *testing.T) { t.Parallel() - if _, err := g.GetAllDeliveryContracts(context.Background(), settleUSDT); err != nil { - t.Errorf("%s GetAllDeliveryContracts() error %v", g.Name, err) - } + _, err := g.GetAllDeliveryContracts(context.Background(), currency.USDT) + assert.NoError(t, err, "GetAllDeliveryContracts should not error") } func TestGetSingleDeliveryContracts(t *testing.T) { t.Parallel() - settle, err := g.getSettlementFromCurrency(getPair(t, asset.DeliveryFutures), false) - if err != nil { - t.Skip(err) - } - if _, err := g.GetSingleDeliveryContracts(context.Background(), settle, getPair(t, asset.DeliveryFutures)); err != nil { - t.Errorf("%s GetSingleDeliveryContracts() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.DeliveryFutures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.GetSingleDeliveryContracts(context.Background(), settle, getPair(t, asset.DeliveryFutures)) + assert.NoError(t, err, "GetSingleDeliveryContracts should not error") } func TestGetDeliveryOrderbook(t *testing.T) { t.Parallel() - if _, err := g.GetDeliveryOrderbook(context.Background(), settleUSDT, "0", getPair(t, asset.DeliveryFutures), 0, false); err != nil { - t.Errorf("%s GetDeliveryOrderbook() error %v", g.Name, err) - } + _, err := g.GetDeliveryOrderbook(context.Background(), currency.USDT, "0", getPair(t, asset.DeliveryFutures), 0, false) + assert.NoError(t, err, "GetDeliveryOrderbook should not error") } func TestGetDeliveryTradingHistory(t *testing.T) { t.Parallel() - settle, err := g.getSettlementFromCurrency(getPair(t, asset.DeliveryFutures), false) - if err != nil { - t.Skip(err) - } - if _, err := g.GetDeliveryTradingHistory(context.Background(), settle, "", getPair(t, asset.DeliveryFutures), 0, time.Time{}, time.Time{}); err != nil { - t.Errorf("%s GetDeliveryTradingHistory() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.DeliveryFutures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.GetDeliveryTradingHistory(context.Background(), settle, "", getPair(t, asset.DeliveryFutures), 0, time.Time{}, time.Time{}) + assert.NoError(t, err, "GetDeliveryTradingHistory should not error") } + func TestGetDeliveryFuturesCandlesticks(t *testing.T) { t.Parallel() - settle, err := g.getSettlementFromCurrency(getPair(t, asset.DeliveryFutures), false) - if err != nil { - t.Skip(err) - } - if _, err := g.GetDeliveryFuturesCandlesticks(context.Background(), settle, getPair(t, asset.DeliveryFutures), time.Time{}, time.Time{}, 0, kline.OneWeek); err != nil { - t.Errorf("%s GetFuturesCandlesticks() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.DeliveryFutures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.GetDeliveryFuturesCandlesticks(context.Background(), settle, getPair(t, asset.DeliveryFutures), time.Time{}, time.Time{}, 0, kline.OneWeek) + assert.NoError(t, err, "GetDeliveryFuturesCandlesticks should not error") } func TestGetDeliveryFutureTickers(t *testing.T) { t.Parallel() - settle, err := g.getSettlementFromCurrency(getPair(t, asset.DeliveryFutures), false) - if err != nil { - t.Skip(err) - } - if _, err := g.GetDeliveryFutureTickers(context.Background(), settle, getPair(t, asset.DeliveryFutures)); err != nil { - t.Errorf("%s GetDeliveryFutureTickers() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.DeliveryFutures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.GetDeliveryFutureTickers(context.Background(), settle, getPair(t, asset.DeliveryFutures)) + assert.NoError(t, err, "GetDeliveryFutureTickers should not error") } func TestGetDeliveryInsuranceBalanceHistory(t *testing.T) { t.Parallel() - if _, err := g.GetDeliveryInsuranceBalanceHistory(context.Background(), settleBTC, 0); err != nil { - t.Errorf("%s GetDeliveryInsuranceBalanceHistory() error %v", g.Name, err) - } + _, err := g.GetDeliveryInsuranceBalanceHistory(context.Background(), currency.BTC, 0) + assert.NoError(t, err, "GetDeliveryInsuranceBalanceHistory should not error") } func TestQueryDeliveryFuturesAccounts(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetDeliveryFuturesAccounts(context.Background(), settleUSDT); err != nil { - t.Errorf("%s QueryDeliveryFuturesAccounts() error %v", g.Name, err) - } + _, err := g.GetDeliveryFuturesAccounts(context.Background(), currency.USDT) + assert.NoError(t, err, "GetDeliveryFuturesAccounts should not error") } func TestGetDeliveryAccountBooks(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetDeliveryAccountBooks(context.Background(), settleUSDT, 0, time.Time{}, time.Now(), "dnw"); err != nil { - t.Errorf("%s GetDeliveryAccountBooks() error %v", g.Name, err) - } + _, err := g.GetDeliveryAccountBooks(context.Background(), currency.USDT, 0, time.Time{}, time.Now(), "dnw") + assert.NoError(t, err, "GetDeliveryAccountBooks should not error") } func TestGetAllDeliveryPositionsOfUser(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetAllDeliveryPositionsOfUser(context.Background(), settleUSDT); err != nil { - t.Errorf("%s GetAllDeliveryPositionsOfUser() error %v", g.Name, err) - } + _, err := g.GetAllDeliveryPositionsOfUser(context.Background(), currency.USDT) + assert.NoError(t, err, "GetAllDeliveryPositionsOfUser should not error") } func TestGetSingleDeliveryPosition(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g) - if _, err := g.GetSingleDeliveryPosition(context.Background(), settleUSDT, getPair(t, asset.DeliveryFutures)); err != nil { - t.Errorf("%s GetSingleDeliveryPosition() error %v", g.Name, err) - } + _, err := g.GetSingleDeliveryPosition(context.Background(), currency.USDT, getPair(t, asset.DeliveryFutures)) + assert.NoError(t, err, "GetSingleDeliveryPosition should not error") } func TestUpdateDeliveryPositionMargin(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - settle, err := g.getSettlementFromCurrency(getPair(t, asset.DeliveryFutures), false) - if err != nil { - t.Fatal(err) - } - if _, err := g.UpdateDeliveryPositionMargin(context.Background(), settle, 0.001, getPair(t, asset.DeliveryFutures)); err != nil { - t.Errorf("%s UpdateDeliveryPositionMargin() error %v", g.Name, err) - } + settle, err := getSettlementFromCurrency(getPair(t, asset.DeliveryFutures)) + require.NoError(t, err, "getSettlementFromCurrency must not error") + _, err = g.UpdateDeliveryPositionMargin(context.Background(), settle, 0.001, getPair(t, asset.DeliveryFutures)) + assert.NoError(t, err, "UpdateDeliveryPositionMargin should not error") } func TestUpdateDeliveryPositionLeverage(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - if _, err := g.UpdateDeliveryPositionLeverage(context.Background(), "usdt", getPair(t, asset.DeliveryFutures), 0.001); err != nil { - t.Errorf("%s UpdateDeliveryPositionLeverage() error %v", g.Name, err) - } + _, err := g.UpdateDeliveryPositionLeverage(context.Background(), currency.USDT, getPair(t, asset.DeliveryFutures), 0.001) + assert.NoError(t, err, "UpdateDeliveryPositionLeverage should not error") } func TestUpdateDeliveryPositionRiskLimit(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders) - if _, err := g.UpdateDeliveryPositionRiskLimit(context.Background(), "usdt", getPair(t, asset.DeliveryFutures), 30); err != nil { - t.Errorf("%s UpdateDeliveryPositionRiskLimit() error %v", g.Name, err) - } + _, err := g.UpdateDeliveryPositionRiskLimit(context.Background(), currency.USDT, getPair(t, asset.DeliveryFutures), 30) + assert.NoError(t, err, "UpdateDeliveryPositionRiskLimit should not error") } func TestGetAllOptionsUnderlyings(t *testing.T) { @@ -3148,42 +3004,20 @@ func TestUnlockSubAccount(t *testing.T) { } } -func TestSettlement(t *testing.T) { - availablePairs, err := g.GetAvailablePairs(asset.Futures) - if err != nil { - t.Fatal(err) - } - for x := range availablePairs { - t.Run(strconv.Itoa(x), func(t *testing.T) { - _, err = g.getSettlementFromCurrency(availablePairs[x], true) - if err != nil { - t.Fatal(err) - } - }) - } - availablePairs, err = g.GetAvailablePairs(asset.DeliveryFutures) - if err != nil { - t.Fatal(err) - } - for x := range availablePairs { - t.Run(strconv.Itoa(x), func(t *testing.T) { - _, err = g.getSettlementFromCurrency(availablePairs[x], false) - if err != nil { - t.Fatal(err) - } - }) - } - availablePairs, err = g.GetAvailablePairs(asset.Options) - if err != nil { - t.Fatal(err) - } - for x := range availablePairs { - t.Run(strconv.Itoa(x), func(t *testing.T) { - _, err := g.getSettlementFromCurrency(availablePairs[x], false) - if err != nil { - t.Fatal(err) - } - }) +func TestGetSettlementFromCurrency(t *testing.T) { + t.Parallel() + g := new(Gateio) //nolint:govet // Intentional shadow to avoid future copy/paste mistakes + require.NoError(t, testexch.Setup(g), "Setup must not error") + for _, assetType := range []asset.Item{asset.Futures, asset.DeliveryFutures, asset.Options} { + availPairs, err := g.GetAvailablePairs(assetType) + require.NoErrorf(t, err, "GetAvailablePairs for asset %s must not error", assetType) + for x := range availPairs { + t.Run(strconv.Itoa(x), func(t *testing.T) { + t.Parallel() + _, err = getSettlementFromCurrency(availPairs[x]) + assert.NoErrorf(t, err, "getSettlementFromCurrency should not error for pair %s and asset %s", availPairs[x], assetType) + }) + } } } diff --git a/exchanges/gateio/gateio_types.go b/exchanges/gateio/gateio_types.go index 58249866..c8216778 100644 --- a/exchanges/gateio/gateio_types.go +++ b/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 diff --git a/exchanges/gateio/gateio_wrapper.go b/exchanges/gateio/gateio_wrapper.go index 6c337706..02d2b760 100644 --- a/exchanges/gateio/gateio_wrapper.go +++ b/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