d0zingcat/gocryptotrader
1
0
Fork 0
mirror of https://github.com/d0zingcat/gocryptotrader.git synced 2026-05-29 15:10:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

exchanges: Initial context propagation (#744)

Browse Source 
* gct: phase one context awareness pass

* exchanges: context propagation pass

* common/requester: force context requirement

* gctcli/exchanges: linter fix

* rpcserver: fix test using dummy rpc server

* backtester: fix comments

* grpc: add correct cancel and timeout for commands

* rpcserver_test: add comment on dummy server

* common: deprecated SendHTTPGetRequest

* linter: fix

* linter: turn on no context check

* apichecker: fix context linter issue

* binance: use param context

* common: remove checks as this gets executed before main

* common: change mutex to RW as clients can be used by multiple go routines.

* common: remove init and JIT default client. Unexport global variables and add protection.

* common: Add comments

* bithumb: after dinner mints fix
This commit is contained in:
Ryan O'Hara-Reid
2021-09-11 13:52:07 +10:00
committed by GitHub
parent 72516f7268
commit d636049fb2
168 changed files with 8085 additions and 6996 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
exchanges/bittrex/bittrex.go
View File

@@ -67,48 +67,48 @@ const (
// GetMarkets is used to get the open and available trading markets at Bittrex
// along with other meta data.
func (b *Bittrex) GetMarkets() ([]MarketData, error) {
func (b *Bittrex) GetMarkets(ctx context.Context) ([]MarketData, error) {
var resp []MarketData
return resp, b.SendHTTPRequest(exchange.RestSpot, getMarkets, &resp, nil)
return resp, b.SendHTTPRequest(ctx, exchange.RestSpot, getMarkets, &resp, nil)
}
// GetCurrencies is used to get all supported currencies at Bittrex
func (b *Bittrex) GetCurrencies() ([]CurrencyData, error) {
func (b *Bittrex) GetCurrencies(ctx context.Context) ([]CurrencyData, error) {
var resp []CurrencyData
return resp, b.SendHTTPRequest(exchange.RestSpot, getCurrencies, &resp, nil)
return resp, b.SendHTTPRequest(ctx, exchange.RestSpot, getCurrencies, &resp, nil)
}
// GetTicker sends a public get request and returns current ticker information
// on the supplied currency. Example currency input param "ltc-btc".
func (b *Bittrex) GetTicker(marketName string) (TickerData, error) {
func (b *Bittrex) GetTicker(ctx context.Context, marketName string) (TickerData, error) {
var resp TickerData
return resp, b.SendHTTPRequest(exchange.RestSpot, fmt.Sprintf(getTicker, marketName), &resp, nil)
return resp, b.SendHTTPRequest(ctx, exchange.RestSpot, fmt.Sprintf(getTicker, marketName), &resp, nil)
}
// GetMarketSummaries is used to get the last 24 hour summary of all active
// exchanges
func (b *Bittrex) GetMarketSummaries() ([]MarketSummaryData, error) {
func (b *Bittrex) GetMarketSummaries(ctx context.Context) ([]MarketSummaryData, error) {
var resp []MarketSummaryData
return resp, b.SendHTTPRequest(exchange.RestSpot, getMarketSummaries, &resp, nil)
return resp, b.SendHTTPRequest(ctx, exchange.RestSpot, getMarketSummaries, &resp, nil)
}
// GetMarketSummary is used to get the last 24 hour summary of all active
// exchanges by currency pair (ltc-btc).
func (b *Bittrex) GetMarketSummary(marketName string) (MarketSummaryData, error) {
func (b *Bittrex) GetMarketSummary(ctx context.Context, marketName string) (MarketSummaryData, error) {
var resp MarketSummaryData
return resp, b.SendHTTPRequest(exchange.RestSpot, fmt.Sprintf(getMarketSummary, marketName), &resp, nil)
return resp, b.SendHTTPRequest(ctx, exchange.RestSpot, fmt.Sprintf(getMarketSummary, marketName), &resp, nil)
}
// GetOrderbook method returns current order book information by currency and depth.
// "marketSymbol" ie ltc-btc
// "depth" is either 1, 25 or 500. Server side, the depth defaults to 25.
func (b *Bittrex) GetOrderbook(marketName string, depth int64) (OrderbookData, int64, error) {
func (b *Bittrex) GetOrderbook(ctx context.Context, marketName string, depth int64) (OrderbookData, int64, error) {
strDepth := strconv.FormatInt(depth, 10)
var resp OrderbookData
var sequence int64
resultHeader := http.Header{}
err := b.SendHTTPRequest(exchange.RestSpot, fmt.Sprintf(getOrderbook, marketName, strDepth), &resp, &resultHeader)
err := b.SendHTTPRequest(ctx, exchange.RestSpot, fmt.Sprintf(getOrderbook, marketName, strDepth), &resp, &resultHeader)
if err != nil {
return OrderbookData{}, 0, err
}
@@ -121,13 +121,13 @@ func (b *Bittrex) GetOrderbook(marketName string, depth int64) (OrderbookData, i
}
// GetMarketHistory retrieves the latest trades that have occurred for a specific market
func (b *Bittrex) GetMarketHistory(currency string) ([]TradeData, error) {
func (b *Bittrex) GetMarketHistory(ctx context.Context, currency string) ([]TradeData, error) {
var resp []TradeData
return resp, b.SendHTTPRequest(exchange.RestSpot, fmt.Sprintf(getMarketTrades, currency), &resp, nil)
return resp, b.SendHTTPRequest(ctx, exchange.RestSpot, fmt.Sprintf(getMarketTrades, currency), &resp, nil)
}
// Order places an order
func (b *Bittrex) Order(marketName, side, orderType string, timeInForce TimeInForce, price, amount, ceiling float64) (OrderData, error) {
func (b *Bittrex) Order(ctx context.Context, marketName, side, orderType string, timeInForce TimeInForce, price, amount, ceiling float64) (OrderData, error) {
req := make(map[string]interface{})
req["marketSymbol"] = marketName
req["direction"] = side
@@ -145,12 +145,12 @@ func (b *Bittrex) Order(marketName, side, orderType string, timeInForce TimeInFo
req["timeInForce"] = GoodTilCancelled
}
var resp OrderData
return resp, b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodPost, submitOrder, nil, req, &resp, nil)
return resp, b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodPost, submitOrder, nil, req, &resp, nil)
}
// GetOpenOrders returns all orders that you currently have opened.
// A specific market can be requested for example "ltc-btc"
func (b *Bittrex) GetOpenOrders(marketName string) ([]OrderData, int64, error) {
func (b *Bittrex) GetOpenOrders(ctx context.Context, marketName string) ([]OrderData, int64, error) {
var path string
if marketName == "" || marketName == " " {
path = getAllOpenOrders
@@ -160,7 +160,7 @@ func (b *Bittrex) GetOpenOrders(marketName string) ([]OrderData, int64, error) {
var resp []OrderData
var sequence int64
resultHeader := http.Header{}
err := b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodGet, path, nil, nil, &resp, &resultHeader)
err := b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodGet, path, nil, nil, &resp, &resultHeader)
if err != nil {
return nil, 0, err
}
@@ -172,14 +172,14 @@ func (b *Bittrex) GetOpenOrders(marketName string) ([]OrderData, int64, error) {
}
// CancelExistingOrder is used to cancel a buy or sell order.
func (b *Bittrex) CancelExistingOrder(uuid string) (OrderData, error) {
func (b *Bittrex) CancelExistingOrder(ctx context.Context, uuid string) (OrderData, error) {
var resp OrderData
return resp, b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodDelete, fmt.Sprintf(cancelOrder, uuid), nil, nil, &resp, nil)
return resp, b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodDelete, fmt.Sprintf(cancelOrder, uuid), nil, nil, &resp, nil)
}
// CancelOpenOrders is used to cancel all open orders for a specific market
// Or cancel all orders for all markets if the parameter `markets` is set to ""
func (b *Bittrex) CancelOpenOrders(market string) ([]BulkCancelResultData, error) {
func (b *Bittrex) CancelOpenOrders(ctx context.Context, market string) ([]BulkCancelResultData, error) {
var resp []BulkCancelResultData
params := url.Values{}
@@ -187,21 +187,21 @@ func (b *Bittrex) CancelOpenOrders(market string) ([]BulkCancelResultData, error
params.Set("marketSymbol", market)
}
return resp, b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodDelete, cancelOpenOrders, params, nil, &resp, nil)
return resp, b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodDelete, cancelOpenOrders, params, nil, &resp, nil)
}
// GetRecentCandles retrieves recent candles;
// Interval: MINUTE_1, MINUTE_5, HOUR_1, or DAY_1
// Type: TRADE or MIDPOINT
func (b *Bittrex) GetRecentCandles(marketName, candleInterval, candleType string) ([]CandleData, error) {
func (b *Bittrex) GetRecentCandles(ctx context.Context, marketName, candleInterval, candleType string) ([]CandleData, error) {
var resp []CandleData
return resp, b.SendHTTPRequest(exchange.RestSpot, fmt.Sprintf(getRecentCandles, marketName, candleType, candleInterval), &resp, nil)
return resp, b.SendHTTPRequest(ctx, exchange.RestSpot, fmt.Sprintf(getRecentCandles, marketName, candleType, candleInterval), &resp, nil)
}
// GetHistoricalCandles retrieves recent candles
// Type: TRADE or MIDPOINT
func (b *Bittrex) GetHistoricalCandles(marketName, candleInterval, candleType string, year, month, day int) ([]CandleData, error) {
func (b *Bittrex) GetHistoricalCandles(ctx context.Context, marketName, candleInterval, candleType string, year, month, day int) ([]CandleData, error) {
var resp []CandleData
var start string
@@ -219,30 +219,30 @@ func (b *Bittrex) GetHistoricalCandles(marketName, candleInterval, candleType st
return resp, fmt.Errorf("invalid interval %v, not supported", candleInterval)
}
return resp, b.SendHTTPRequest(exchange.RestSpot, fmt.Sprintf(getHistoricalCandles, marketName, candleType, candleInterval, start), &resp, nil)
return resp, b.SendHTTPRequest(ctx, exchange.RestSpot, fmt.Sprintf(getHistoricalCandles, marketName, candleType, candleInterval, start), &resp, nil)
}
// GetBalances is used to retrieve all balances from your account
func (b *Bittrex) GetBalances() ([]BalanceData, error) {
func (b *Bittrex) GetBalances(ctx context.Context) ([]BalanceData, error) {
var resp []BalanceData
return resp, b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodGet, getBalances, nil, nil, &resp, nil)
return resp, b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodGet, getBalances, nil, nil, &resp, nil)
}
// GetAccountBalanceByCurrency is used to retrieve the balance from your account
// for a specific currency. ie. "btc" or "ltc"
func (b *Bittrex) GetAccountBalanceByCurrency(currency string) (BalanceData, error) {
func (b *Bittrex) GetAccountBalanceByCurrency(ctx context.Context, currency string) (BalanceData, error) {
var resp BalanceData
return resp, b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodGet, fmt.Sprintf(getBalance, currency), nil, nil, &resp, nil)
return resp, b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodGet, fmt.Sprintf(getBalance, currency), nil, nil, &resp, nil)
}
// GetCryptoDepositAddress is used to retrieve an address for a specific currency
func (b *Bittrex) GetCryptoDepositAddress(currency string) (AddressData, error) {
func (b *Bittrex) GetCryptoDepositAddress(ctx context.Context, currency string) (AddressData, error) {
var resp AddressData
return resp, b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodGet, fmt.Sprintf(getDepositAddress, currency), nil, nil, &resp, nil)
return resp, b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodGet, fmt.Sprintf(getDepositAddress, currency), nil, nil, &resp, nil)
}
// Withdraw is used to withdraw funds from your account.
func (b *Bittrex) Withdraw(currency, paymentID, address string, quantity float64) (WithdrawalData, error) {
func (b *Bittrex) Withdraw(ctx context.Context, currency, paymentID, address string, quantity float64) (WithdrawalData, error) {
req := make(map[string]interface{})
req["currencySymbol"] = currency
req["quantity"] = strconv.FormatFloat(quantity, 'f', -1, 64)
@@ -251,60 +251,60 @@ func (b *Bittrex) Withdraw(currency, paymentID, address string, quantity float64
req["cryptoAddressTag"] = paymentID
}
var resp WithdrawalData
return resp, b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodPost, submitWithdrawal, nil, req, &resp, nil)
return resp, b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodPost, submitWithdrawal, nil, req, &resp, nil)
}
// GetOrder is used to retrieve a single order by UUID.
func (b *Bittrex) GetOrder(uuid string) (OrderData, error) {
func (b *Bittrex) GetOrder(ctx context.Context, uuid string) (OrderData, error) {
var resp OrderData
return resp, b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodGet, fmt.Sprintf(getOrder, uuid), nil, nil, &resp, nil)
return resp, b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodGet, fmt.Sprintf(getOrder, uuid), nil, nil, &resp, nil)
}
// GetOrderHistoryForCurrency is used to retrieve your order history. If marketName
// is omitted it will return the entire order History.
func (b *Bittrex) GetOrderHistoryForCurrency(currency string) ([]OrderData, error) {
func (b *Bittrex) GetOrderHistoryForCurrency(ctx context.Context, currency string) ([]OrderData, error) {
var resp []OrderData
return resp, b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodGet, fmt.Sprintf(getClosedOrders, currency), nil, nil, &resp, nil)
return resp, b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodGet, fmt.Sprintf(getClosedOrders, currency), nil, nil, &resp, nil)
}
// GetClosedWithdrawals is used to retrieve your withdrawal history.
func (b *Bittrex) GetClosedWithdrawals() ([]WithdrawalData, error) {
func (b *Bittrex) GetClosedWithdrawals(ctx context.Context) ([]WithdrawalData, error) {
var resp []WithdrawalData
return resp, b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodGet, getClosedWithdrawals, nil, nil, &resp, nil)
return resp, b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodGet, getClosedWithdrawals, nil, nil, &resp, nil)
}
// GetClosedWithdrawalsForCurrency is used to retrieve your withdrawal history for the specified currency.
func (b *Bittrex) GetClosedWithdrawalsForCurrency(currency string) ([]WithdrawalData, error) {
func (b *Bittrex) GetClosedWithdrawalsForCurrency(ctx context.Context, currency string) ([]WithdrawalData, error) {
var resp []WithdrawalData
params := url.Values{}
params.Set("currencySymbol", currency)
return resp, b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodGet, getClosedWithdrawals, params, nil, &resp, nil)
return resp, b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodGet, getClosedWithdrawals, params, nil, &resp, nil)
}
// GetOpenWithdrawals is used to retrieve your withdrawal history. If currency
// omitted it will return the entire history
func (b *Bittrex) GetOpenWithdrawals() ([]WithdrawalData, error) {
func (b *Bittrex) GetOpenWithdrawals(ctx context.Context) ([]WithdrawalData, error) {
var resp []WithdrawalData
return resp, b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodGet, getOpenWithdrawals, nil, nil, &resp, nil)
return resp, b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodGet, getOpenWithdrawals, nil, nil, &resp, nil)
}
// GetClosedDeposits is used to retrieve your deposit history.
func (b *Bittrex) GetClosedDeposits() ([]DepositData, error) {
func (b *Bittrex) GetClosedDeposits(ctx context.Context) ([]DepositData, error) {
var resp []DepositData
return resp, b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodGet, getClosedDeposits, nil, nil, &resp, nil)
return resp, b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodGet, getClosedDeposits, nil, nil, &resp, nil)
}
// GetClosedDepositsForCurrency is used to retrieve your deposit history for the specified currency
func (b *Bittrex) GetClosedDepositsForCurrency(currency string) ([]DepositData, error) {
func (b *Bittrex) GetClosedDepositsForCurrency(ctx context.Context, currency string) ([]DepositData, error) {
var resp []DepositData
params := url.Values{}
params.Set("currencySymbol", currency)
return resp, b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodGet, getClosedDeposits, params, nil, &resp, nil)
return resp, b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodGet, getClosedDeposits, params, nil, &resp, nil)
}
// GetClosedDepositsPaginated is used to retrieve your deposit history.
@@ -312,7 +312,7 @@ func (b *Bittrex) GetClosedDepositsForCurrency(currency string) ([]DepositData,
// PreviousPageToken is the unique identifier of the item that the resulting
// query result should end before, in the sort order of the given endpoint. Used
// for traversing a paginated set in the reverse direction.
func (b *Bittrex) GetClosedDepositsPaginated(pageSize int, previousPageTokenOptional ...string) ([]DepositData, error) {
func (b *Bittrex) GetClosedDepositsPaginated(ctx context.Context, pageSize int, previousPageTokenOptional ...string) ([]DepositData, error) {
var resp []DepositData
params := url.Values{}
@@ -322,27 +322,27 @@ func (b *Bittrex) GetClosedDepositsPaginated(pageSize int, previousPageTokenOpti
params.Set("previousPageToken", previousPageTokenOptional[0])
}
return resp, b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodGet, getClosedDeposits, params, nil, &resp, nil)
return resp, b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodGet, getClosedDeposits, params, nil, &resp, nil)
}
// GetOpenDeposits is used to retrieve your open deposits.
func (b *Bittrex) GetOpenDeposits() ([]DepositData, error) {
func (b *Bittrex) GetOpenDeposits(ctx context.Context) ([]DepositData, error) {
var resp []DepositData
return resp, b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodGet, getOpenDeposits, nil, nil, &resp, nil)
return resp, b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodGet, getOpenDeposits, nil, nil, &resp, nil)
}
// GetOpenDepositsForCurrency is used to retrieve your open deposits for the specified currency
func (b *Bittrex) GetOpenDepositsForCurrency(currency string) ([]DepositData, error) {
func (b *Bittrex) GetOpenDepositsForCurrency(ctx context.Context, currency string) ([]DepositData, error) {
var resp []DepositData
params := url.Values{}
params.Set("currencySymbol", currency)
return resp, b.SendAuthHTTPRequest(exchange.RestSpot, http.MethodGet, getOpenDeposits, params, nil, &resp, nil)
return resp, b.SendAuthHTTPRequest(ctx, exchange.RestSpot, http.MethodGet, getOpenDeposits, params, nil, &resp, nil)
}
// SendHTTPRequest sends an unauthenticated HTTP request
func (b *Bittrex) SendHTTPRequest(ep exchange.URL, path string, result interface{}, resultHeader *http.Header) error {
func (b *Bittrex) SendHTTPRequest(ctx context.Context, ep exchange.URL, path string, result interface{}, resultHeader *http.Header) error {
endpoint, err := b.API.Endpoints.GetURL(ep)
if err != nil {
return err
@@ -356,11 +356,11 @@ func (b *Bittrex) SendHTTPRequest(ep exchange.URL, path string, result interface
HTTPRecording: b.HTTPRecording,
HeaderResponse: resultHeader,
}
return b.SendPayload(context.Background(), request.Unset, func() (*request.Item, error) { return item, nil })
return b.SendPayload(ctx, request.Unset, func() (*request.Item, error) { return item, nil })
}
// SendAuthHTTPRequest sends an authenticated request
func (b *Bittrex) SendAuthHTTPRequest(ep exchange.URL, method, action string, params url.Values, data, result interface{}, resultHeader *http.Header) error {
func (b *Bittrex) SendAuthHTTPRequest(ctx context.Context, ep exchange.URL, method, action string, params url.Values, data, result interface{}, resultHeader *http.Header) error {
if !b.AllowAuthenticatedRequest() {
return fmt.Errorf("%s %w", b.Name, exchange.ErrAuthenticatedRequestWithoutCredentialsSet)
}
@@ -421,11 +421,11 @@ func (b *Bittrex) SendAuthHTTPRequest(ep exchange.URL, method, action string, pa
}, nil
}
return b.SendPayload(context.Background(), request.Unset, newRequest)
return b.SendPayload(ctx, request.Unset, newRequest)
}
// GetFee returns an estimate of fee based on type of transaction
func (b *Bittrex) GetFee(feeBuilder *exchange.FeeBuilder) (float64, error) {
func (b *Bittrex) GetFee(ctx context.Context, feeBuilder *exchange.FeeBuilder) (float64, error) {
var fee float64
var err error
@@ -433,7 +433,7 @@ func (b *Bittrex) GetFee(feeBuilder *exchange.FeeBuilder) (float64, error) {
case exchange.CryptocurrencyTradeFee:
fee = calculateTradingFee(feeBuilder.PurchasePrice, feeBuilder.Amount)
case exchange.CryptocurrencyWithdrawalFee:
fee, err = b.GetWithdrawalFee(feeBuilder.Pair.Base)
fee, err = b.GetWithdrawalFee(ctx, feeBuilder.Pair.Base)
case exchange.OfflineTradeFee:
fee = calculateTradingFee(feeBuilder.PurchasePrice, feeBuilder.Amount)
}
@@ -444,10 +444,10 @@ func (b *Bittrex) GetFee(feeBuilder *exchange.FeeBuilder) (float64, error) {
}
// GetWithdrawalFee returns the fee for withdrawing from the exchange
func (b *Bittrex) GetWithdrawalFee(c currency.Code) (float64, error) {
func (b *Bittrex) GetWithdrawalFee(ctx context.Context, c currency.Code) (float64, error) {
var fee float64
currencies, err := b.GetCurrencies()
currencies, err := b.GetCurrencies(ctx)
if err != nil {
return 0, err
}

114
exchanges/bittrex/bittrex_test.go
View File

@@ -1,6 +1,7 @@
package bittrex
import (
"context"
"log"
"os"
"testing"
@@ -57,7 +58,7 @@ func TestMain(m *testing.M) {
func TestGetMarkets(t *testing.T) {
t.Parallel()
_, err := b.GetMarkets()
_, err := b.GetMarkets(context.Background())
if err != nil {
t.Error(err)
}
@@ -65,7 +66,7 @@ func TestGetMarkets(t *testing.T) {
func TestGetCurrencies(t *testing.T) {
t.Parallel()
_, err := b.GetCurrencies()
_, err := b.GetCurrencies(context.Background())
if err != nil {
t.Error(err)
}
@@ -73,7 +74,7 @@ func TestGetCurrencies(t *testing.T) {
func TestGetTicker(t *testing.T) {
t.Parallel()
_, err := b.GetTicker(currPair)
_, err := b.GetTicker(context.Background(), currPair)
if err != nil {
t.Error(err)
}
@@ -81,7 +82,7 @@ func TestGetTicker(t *testing.T) {
func TestGetMarketSummaries(t *testing.T) {
t.Parallel()
_, err := b.GetMarketSummaries()
_, err := b.GetMarketSummaries(context.Background())
if err != nil {
t.Error(err)
}
@@ -89,7 +90,7 @@ func TestGetMarketSummaries(t *testing.T) {
func TestGetMarketSummary(t *testing.T) {
t.Parallel()
_, err := b.GetMarketSummary(currPair)
_, err := b.GetMarketSummary(context.Background(), currPair)
if err != nil {
t.Error(err)
}
@@ -98,7 +99,7 @@ func TestGetMarketSummary(t *testing.T) {
func TestGetOrderbook(t *testing.T) {
t.Parallel()
_, _, err := b.GetOrderbook(currPair, 500)
_, _, err := b.GetOrderbook(context.Background(), currPair, 500)
if err != nil {
t.Error(err)
}
@@ -107,7 +108,7 @@ func TestGetOrderbook(t *testing.T) {
func TestGetMarketHistory(t *testing.T) {
t.Parallel()
_, err := b.GetMarketHistory(currPair)
_, err := b.GetMarketHistory(context.Background(), currPair)
if err != nil {
t.Error(err)
}
@@ -116,7 +117,8 @@ func TestGetMarketHistory(t *testing.T) {
func TestGetRecentCandles(t *testing.T) {
t.Parallel()
_, err := b.GetRecentCandles(currPair, "HOUR_1", "MIDPOINT")
_, err := b.GetRecentCandles(context.Background(),
currPair, "HOUR_1", "MIDPOINT")
if err != nil {
t.Error(err)
}
@@ -125,11 +127,13 @@ func TestGetRecentCandles(t *testing.T) {
func TestGetHistoricalCandles(t *testing.T) {
t.Parallel()
_, err := b.GetHistoricalCandles(currPair, "MINUTE_5", "MIDPOINT", 2020, 12, 31)
_, err := b.GetHistoricalCandles(context.Background(),
currPair, "MINUTE_5", "MIDPOINT", 2020, 12, 31)
if err != nil {
t.Error(err)
}
_, err = b.GetHistoricalCandles(currPair, "MINUTE_5", "MIDPOINT", 2020, 12, 32)
_, err = b.GetHistoricalCandles(context.Background(),
currPair, "MINUTE_5", "MIDPOINT", 2020, 12, 32)
if err == nil {
t.Error("invalid date should give an error")
}
@@ -138,7 +142,8 @@ func TestGetHistoricalCandles(t *testing.T) {
func TestOrder(t *testing.T) {
t.Parallel()
_, err := b.Order(currPair, order.Buy.String(), order.Limit.String(), "", 1, 1, 0.0)
_, err := b.Order(context.Background(),
currPair, order.Buy.String(), order.Limit.String(), "", 1, 1, 0.0)
if areTestAPIKeysSet() && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
@@ -149,13 +154,13 @@ func TestOrder(t *testing.T) {
func TestGetOpenOrders(t *testing.T) {
t.Parallel()
_, _, err := b.GetOpenOrders("")
_, _, err := b.GetOpenOrders(context.Background(), "")
if areTestAPIKeysSet() && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
t.Error("Expected error")
}
_, _, err = b.GetOpenOrders(currPair)
_, _, err = b.GetOpenOrders(context.Background(), currPair)
if areTestAPIKeysSet() && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
@@ -166,7 +171,7 @@ func TestGetOpenOrders(t *testing.T) {
func TestCancelExistingOrder(t *testing.T) {
t.Parallel()
_, err := b.CancelExistingOrder("invalid-order")
_, err := b.CancelExistingOrder(context.Background(), "invalid-order")
if err == nil {
t.Error("Expected error")
}
@@ -175,7 +180,7 @@ func TestCancelExistingOrder(t *testing.T) {
func TestGetAccountBalances(t *testing.T) {
t.Parallel()
_, err := b.GetBalances()
_, err := b.GetBalances(context.Background())
if areTestAPIKeysSet() && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
@@ -186,7 +191,7 @@ func TestGetAccountBalances(t *testing.T) {
func TestGetAccountBalanceByCurrency(t *testing.T) {
t.Parallel()
_, err := b.GetAccountBalanceByCurrency(curr)
_, err := b.GetAccountBalanceByCurrency(context.Background(), curr)
if areTestAPIKeysSet() && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
@@ -197,13 +202,13 @@ func TestGetAccountBalanceByCurrency(t *testing.T) {
func TestGetOrder(t *testing.T) {
t.Parallel()
_, err := b.GetOrder("0cb4c4e4-bdc7-4e13-8c13-430e587d2cc1")
_, err := b.GetOrder(context.Background(), "0cb4c4e4-bdc7-4e13-8c13-430e587d2cc1")
if areTestAPIKeysSet() && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
t.Error("Expected error")
}
_, err = b.GetOrder("")
_, err = b.GetOrder(context.Background(), "")
if areTestAPIKeysSet() && err == nil {
t.Error("Expected error")
} else if !areTestAPIKeysSet() && err == nil {
@@ -214,13 +219,13 @@ func TestGetOrder(t *testing.T) {
func TestGetOrderHistoryForCurrency(t *testing.T) {
t.Parallel()
_, err := b.GetOrderHistoryForCurrency("")
_, err := b.GetOrderHistoryForCurrency(context.Background(), "")
if areTestAPIKeysSet() && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
t.Error("Expected error")
}
_, err = b.GetOrderHistoryForCurrency(currPair)
_, err = b.GetOrderHistoryForCurrency(context.Background(), currPair)
if areTestAPIKeysSet() && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
@@ -231,7 +236,7 @@ func TestGetOrderHistoryForCurrency(t *testing.T) {
func TestGetClosedWithdrawals(t *testing.T) {
t.Parallel()
_, err := b.GetClosedWithdrawals()
_, err := b.GetClosedWithdrawals(context.Background())
if areTestAPIKeysSet() && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
@@ -242,7 +247,7 @@ func TestGetClosedWithdrawals(t *testing.T) {
func TestGetClosedWithdrawalsForCurrency(t *testing.T) {
t.Parallel()
_, err := b.GetClosedWithdrawalsForCurrency(curr)
_, err := b.GetClosedWithdrawalsForCurrency(context.Background(), curr)
if areTestAPIKeysSet() && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
@@ -253,7 +258,7 @@ func TestGetClosedWithdrawalsForCurrency(t *testing.T) {
func TestGetOpenWithdrawals(t *testing.T) {
t.Parallel()
_, err := b.GetOpenWithdrawals()
_, err := b.GetOpenWithdrawals(context.Background())
if areTestAPIKeysSet() && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
@@ -264,7 +269,7 @@ func TestGetOpenWithdrawals(t *testing.T) {
func TestGetClosedDeposits(t *testing.T) {
t.Parallel()
_, err := b.GetClosedDeposits()
_, err := b.GetClosedDeposits(context.Background())
if areTestAPIKeysSet() && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
@@ -275,7 +280,7 @@ func TestGetClosedDeposits(t *testing.T) {
func TestGetClosedDepositsForCurrency(t *testing.T) {
t.Parallel()
_, err := b.GetClosedDepositsForCurrency(curr)
_, err := b.GetClosedDepositsForCurrency(context.Background(), curr)
if areTestAPIKeysSet() && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
@@ -286,7 +291,7 @@ func TestGetClosedDepositsForCurrency(t *testing.T) {
func TestGetClosedDepositsPaginated(t *testing.T) {
t.Parallel()
_, err := b.GetClosedDepositsPaginated(100)
_, err := b.GetClosedDepositsPaginated(context.Background(), 100)
if areTestAPIKeysSet() && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
@@ -297,7 +302,7 @@ func TestGetClosedDepositsPaginated(t *testing.T) {
func TestGetOpenDeposits(t *testing.T) {
t.Parallel()
_, err := b.GetOpenDeposits()
_, err := b.GetOpenDeposits(context.Background())
if areTestAPIKeysSet() && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
@@ -308,7 +313,7 @@ func TestGetOpenDeposits(t *testing.T) {
func TestGetOpenDepositsForCurrency(t *testing.T) {
t.Parallel()
_, err := b.GetOpenDepositsForCurrency(curr)
_, err := b.GetOpenDepositsForCurrency(context.Background(), curr)
if areTestAPIKeysSet() && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
@@ -321,7 +326,8 @@ func TestWithdraw(t *testing.T) {
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys or canManipulateRealOrders isnt set correctly")
}
_, err := b.Withdraw(curr, "", core.BitcoinDonationAddress, 0.0009)
_, err := b.Withdraw(context.Background(),
curr, "", core.BitcoinDonationAddress, 0.0009)
if err != nil {
t.Error(err)
}
@@ -339,7 +345,7 @@ func setFeeBuilder() *exchange.FeeBuilder {
// TestGetFeeByTypeOfflineTradeFee logic test
func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
var feeBuilder = setFeeBuilder()
_, err := b.GetFeeByType(feeBuilder)
_, err := b.GetFeeByType(context.Background(), feeBuilder)
if err != nil {
t.Fatal(err)
}
@@ -357,7 +363,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
func TestGetFee(t *testing.T) {
var feeBuilder = setFeeBuilder()
// CryptocurrencyTradeFee Basic
if _, err := b.GetFee(feeBuilder); err != nil {
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
t.Error(err)
}
@@ -365,35 +371,35 @@ func TestGetFee(t *testing.T) {
feeBuilder = setFeeBuilder()
feeBuilder.Amount = 1000
feeBuilder.PurchasePrice = 1000
if _, err := b.GetFee(feeBuilder); err != nil {
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyTradeFee IsMaker
feeBuilder = setFeeBuilder()
feeBuilder.IsMaker = true
if _, err := b.GetFee(feeBuilder); err != nil {
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyTradeFee Negative purchase price
feeBuilder = setFeeBuilder()
feeBuilder.PurchasePrice = -1000
if _, err := b.GetFee(feeBuilder); err != nil {
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyWithdrawalFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee
if _, err := b.GetFee(feeBuilder); err != nil {
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyDepositFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.CryptocurrencyDepositFee
if _, err := b.GetFee(feeBuilder); err != nil {
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
t.Error(err)
}
@@ -401,7 +407,7 @@ func TestGetFee(t *testing.T) {
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.InternationalBankDepositFee
feeBuilder.FiatCurrency = currency.HKD
if _, err := b.GetFee(feeBuilder); err != nil {
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
t.Error(err)
}
@@ -409,7 +415,7 @@ func TestGetFee(t *testing.T) {
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
feeBuilder.FiatCurrency = currency.HKD
if _, err := b.GetFee(feeBuilder); err != nil {
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
t.Error(err)
}
}
@@ -436,7 +442,7 @@ func TestGetActiveOrders(t *testing.T) {
getOrdersRequest.Pairs[0].Delimiter = currency.DashDelimiter
_, err = b.GetActiveOrders(&getOrdersRequest)
_, err = b.GetActiveOrders(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
@@ -450,7 +456,7 @@ func TestGetOrderHistory(t *testing.T) {
AssetType: asset.Spot,
}
_, err := b.GetOrderHistory(&getOrdersRequest)
_, err := b.GetOrderHistory(context.Background(), &getOrdersRequest)
if err == nil {
t.Error("Expected: 'At least one currency is required to fetch order history'. received nil")
}
@@ -459,7 +465,7 @@ func TestGetOrderHistory(t *testing.T) {
currency.NewPair(currency.BTC, currency.USDT),
}
_, err = b.GetOrderHistory(&getOrdersRequest)
_, err = b.GetOrderHistory(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
@@ -491,7 +497,7 @@ func TestSubmitOrder(t *testing.T) {
ClientID: "meowOrder",
AssetType: asset.Spot,
}
response, err := b.SubmitOrder(orderSubmission)
response, err := b.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && (err != nil || !response.IsOrderPlaced) {
t.Errorf("Order failed to be placed: %v", err)
} else if !areTestAPIKeysSet() && err == nil {
@@ -513,7 +519,7 @@ func TestCancelExchangeOrder(t *testing.T) {
AssetType: asset.Spot,
}
err := b.CancelOrder(orderCancellation)
err := b.CancelOrder(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
t.Error("Expecting an error when no keys are set")
}
@@ -536,7 +542,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
AssetType: asset.Spot,
}
resp, err := b.CancelAllOrders(orderCancellation)
resp, err := b.CancelAllOrders(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
t.Error("Expecting an error when no keys are set")
@@ -554,7 +560,8 @@ func TestModifyOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.ModifyOrder(&order.Modify{AssetType: asset.Spot})
_, err := b.ModifyOrder(context.Background(),
&order.Modify{AssetType: asset.Spot})
if err == nil {
t.Error("Expected error")
}
@@ -574,7 +581,8 @@ func WithdrawCryptocurrencyFunds(t *testing.T) {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.WithdrawCryptocurrencyFunds(&withdrawCryptoRequest)
_, err := b.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
if !areTestAPIKeysSet() && err == nil {
t.Error("Expecting an error when no keys are set")
}
@@ -590,7 +598,7 @@ func TestWithdrawFiat(t *testing.T) {
var withdrawFiatRequest = withdraw.Request{}
_, err := b.WithdrawFiatFunds(&withdrawFiatRequest)
_, err := b.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
if err != common.ErrFunctionNotSupported {
t.Errorf("Expected '%v', received: '%v'", common.ErrFunctionNotSupported, err)
}
@@ -603,7 +611,8 @@ func TestWithdrawInternationalBank(t *testing.T) {
var withdrawFiatRequest = withdraw.Request{}
_, err := b.WithdrawFiatFundsToInternationalBank(&withdrawFiatRequest)
_, err := b.WithdrawFiatFundsToInternationalBank(context.Background(),
&withdrawFiatRequest)
if err != common.ErrFunctionNotSupported {
t.Errorf("Expected '%v', received: '%v'", common.ErrFunctionNotSupported, err)
}
@@ -611,12 +620,12 @@ func TestWithdrawInternationalBank(t *testing.T) {
func TestGetDepositAddress(t *testing.T) {
if areTestAPIKeysSet() {
_, err := b.GetDepositAddress(currency.BTC, "")
_, err := b.GetDepositAddress(context.Background(), currency.BTC, "")
if err != nil {
t.Error(err)
}
} else {
_, err := b.GetDepositAddress(currency.BTC, "")
_, err := b.GetDepositAddress(context.Background(), currency.BTC, "")
if err == nil {
t.Error("error cannot be nil")
}
@@ -629,7 +638,7 @@ func TestGetRecentTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = b.GetRecentTrades(currencyPair, asset.Spot)
_, err = b.GetRecentTrades(context.Background(), currencyPair, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -641,7 +650,8 @@ func TestGetHistoricTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = b.GetHistoricTrades(currencyPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now())
_, err = b.GetHistoricTrades(context.Background(),
currencyPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now())
if err != nil && err != common.ErrFunctionNotSupported {
t.Fatal(err)
}

6
exchanges/bittrex/bittrex_websocket.go
View File

@@ -71,7 +71,7 @@ func (b *Bittrex) WsConnect() error {
}
var wsHandshakeData WsSignalRHandshakeData
err := b.WsSignalRHandshake(&wsHandshakeData)
err := b.WsSignalRHandshake(context.TODO(), &wsHandshakeData)
if err != nil {
return err
}
@@ -128,7 +128,7 @@ func (b *Bittrex) WsConnect() error {
}
// WsSignalRHandshake requests the SignalR connection token over https
func (b *Bittrex) WsSignalRHandshake(result interface{}) error {
func (b *Bittrex) WsSignalRHandshake(ctx context.Context, result interface{}) error {
endpoint, err := b.API.Endpoints.GetURL(exchange.WebsocketSpotSupplementary)
if err != nil {
return err
@@ -142,7 +142,7 @@ func (b *Bittrex) WsSignalRHandshake(result interface{}) error {
HTTPDebugging: b.HTTPDebugging,
HTTPRecording: b.HTTPRecording,
}
return b.SendPayload(context.Background(), request.Unset, func() (*request.Item, error) {
return b.SendPayload(ctx, request.Unset, func() (*request.Item, error) {
return item, nil
})
}

132
exchanges/bittrex/bittrex_wrapper.go
View File

@@ -1,6 +1,7 @@
package bittrex
import (
"context"
"errors"
"fmt"
"sort"
@@ -40,7 +41,7 @@ func (b *Bittrex) GetDefaultConfig() (*config.ExchangeConfig, error) {
}
if b.Features.Supports.RESTCapabilities.AutoPairUpdates {
err = b.UpdateTradablePairs(true)
err = b.UpdateTradablePairs(context.TODO(), true)
if err != nil {
return nil, err
}
@@ -212,7 +213,7 @@ func (b *Bittrex) Run() {
return
}
err := b.UpdateTradablePairs(false)
err := b.UpdateTradablePairs(context.TODO(), false)
if err != nil {
log.Errorf(log.ExchangeSys,
"%s failed to update tradable pairs. Err: %s",
@@ -241,12 +242,12 @@ func (b *Bittrex) Run() {
}
// FetchTradablePairs returns a list of the exchanges tradable pairs
func (b *Bittrex) FetchTradablePairs(asset asset.Item) ([]string, error) {
func (b *Bittrex) FetchTradablePairs(ctx context.Context, asset asset.Item) ([]string, error) {
// Bittrex only supports spot trading
if !b.SupportsAsset(asset) {
return nil, fmt.Errorf("asset type of %s is not supported by %s", asset, b.Name)
}
markets, err := b.GetMarkets()
markets, err := b.GetMarkets(ctx)
if err != nil {
return nil, err
}
@@ -264,8 +265,8 @@ func (b *Bittrex) FetchTradablePairs(asset asset.Item) ([]string, error) {
// UpdateTradablePairs updates the exchanges available pairs and stores
// them in the exchanges config
func (b *Bittrex) UpdateTradablePairs(forceUpdate bool) error {
pairs, err := b.FetchTradablePairs(asset.Spot)
func (b *Bittrex) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
pairs, err := b.FetchTradablePairs(ctx, asset.Spot)
if err != nil {
return err
}
@@ -279,23 +280,23 @@ func (b *Bittrex) UpdateTradablePairs(forceUpdate bool) error {
}
// UpdateTickers updates the ticker for all currency pairs of a given asset type
func (b *Bittrex) UpdateTickers(a asset.Item) error {
func (b *Bittrex) UpdateTickers(ctx context.Context, a asset.Item) error {
return common.ErrFunctionNotSupported
}
// UpdateTicker updates and returns the ticker for a currency pair
func (b *Bittrex) UpdateTicker(p currency.Pair, a asset.Item) (*ticker.Price, error) {
func (b *Bittrex) UpdateTicker(ctx context.Context, p currency.Pair, a asset.Item) (*ticker.Price, error) {
formattedPair, err := b.FormatExchangeCurrency(p, a)
if err != nil {
return nil, err
}
t, err := b.GetTicker(formattedPair.String())
t, err := b.GetTicker(ctx, formattedPair.String())
if err != nil {
return nil, err
}
s, err := b.GetMarketSummary(formattedPair.String())
s, err := b.GetMarketSummary(ctx, formattedPair.String())
if err != nil {
return nil, err
}
@@ -333,32 +334,33 @@ func (b *Bittrex) constructTicker(t TickerData, s *MarketSummaryData, pair curre
}
// FetchTicker returns the ticker for a currency pair
func (b *Bittrex) FetchTicker(p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
func (b *Bittrex) FetchTicker(ctx context.Context, p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
resp, err := ticker.GetTicker(b.Name, p, assetType)
if err != nil {
return b.UpdateTicker(p, assetType)
return b.UpdateTicker(ctx, p, assetType)
}
return resp, nil
}
// FetchOrderbook returns orderbook base on the currency pair
func (b *Bittrex) FetchOrderbook(currency currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
resp, err := orderbook.Get(b.Name, currency, assetType)
func (b *Bittrex) FetchOrderbook(ctx context.Context, c currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
resp, err := orderbook.Get(b.Name, c, assetType)
if err != nil {
return b.UpdateOrderbook(currency, assetType)
return b.UpdateOrderbook(ctx, c, assetType)
}
return resp, nil
}
// UpdateOrderbook updates and returns the orderbook for a currency pair
func (b *Bittrex) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
func (b *Bittrex) UpdateOrderbook(ctx context.Context, p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
formattedPair, err := b.FormatExchangeCurrency(p, assetType)
if err != nil {
return nil, err
}
// Valid order book depths are 1, 25 and 500
orderbookData, sequence, err := b.GetOrderbook(formattedPair.String(), orderbookDepth)
orderbookData, sequence, err := b.GetOrderbook(ctx,
formattedPair.String(), orderbookDepth)
if err != nil {
return nil, err
}
@@ -397,9 +399,9 @@ func (b *Bittrex) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*order
}
// UpdateAccountInfo retrieves balances for all enabled currencies
func (b *Bittrex) UpdateAccountInfo(assetType asset.Item) (account.Holdings, error) {
func (b *Bittrex) UpdateAccountInfo(ctx context.Context, assetType asset.Item) (account.Holdings, error) {
var resp account.Holdings
balanceData, err := b.GetBalances()
balanceData, err := b.GetBalances(ctx)
if err != nil {
return resp, err
}
@@ -422,24 +424,23 @@ func (b *Bittrex) UpdateAccountInfo(assetType asset.Item) (account.Holdings, err
}
// FetchAccountInfo retrieves balances for all enabled currencies
func (b *Bittrex) FetchAccountInfo(assetType asset.Item) (account.Holdings, error) {
func (b *Bittrex) FetchAccountInfo(ctx context.Context, assetType asset.Item) (account.Holdings, error) {
resp, err := account.GetHoldings(b.Name, assetType)
if err != nil {
return b.UpdateAccountInfo(assetType)
return b.UpdateAccountInfo(ctx, assetType)
}
return resp, nil
}
// GetFundingHistory returns funding history, deposits and
// withdrawals
func (b *Bittrex) GetFundingHistory() ([]exchange.FundHistory, error) {
func (b *Bittrex) GetFundingHistory(ctx context.Context) ([]exchange.FundHistory, error) {
var resp []exchange.FundHistory
closedDepositData, err := b.GetClosedDeposits()
closedDepositData, err := b.GetClosedDeposits(ctx)
if err != nil {
return resp, err
}
openDepositData, err := b.GetOpenDeposits()
openDepositData, err := b.GetOpenDeposits(ctx)
if err != nil {
return resp, err
}
@@ -458,11 +459,11 @@ func (b *Bittrex) GetFundingHistory() ([]exchange.FundHistory, error) {
CryptoTxID: depositData[x].TxID,
})
}
closedWithdrawalData, err := b.GetClosedWithdrawals()
closedWithdrawalData, err := b.GetClosedWithdrawals(ctx)
if err != nil {
return resp, err
}
openWithdrawalData, err := b.GetOpenWithdrawals()
openWithdrawalData, err := b.GetOpenWithdrawals(ctx)
if err != nil {
return resp, err
}
@@ -487,18 +488,18 @@ func (b *Bittrex) GetFundingHistory() ([]exchange.FundHistory, error) {
}
// GetWithdrawalsHistory returns previous withdrawals data
func (b *Bittrex) GetWithdrawalsHistory(c currency.Code) (resp []exchange.WithdrawalHistory, err error) {
func (b *Bittrex) GetWithdrawalsHistory(ctx context.Context, c currency.Code) (resp []exchange.WithdrawalHistory, err error) {
return nil, common.ErrNotYetImplemented
}
// GetRecentTrades returns the most recent trades for a currency and asset
func (b *Bittrex) GetRecentTrades(p currency.Pair, assetType asset.Item) ([]trade.Data, error) {
func (b *Bittrex) GetRecentTrades(ctx context.Context, p currency.Pair, assetType asset.Item) ([]trade.Data, error) {
var err error
formattedPair, err := b.FormatExchangeCurrency(p, assetType)
if err != nil {
return nil, err
}
tradeData, err := b.GetMarketHistory(formattedPair.String())
tradeData, err := b.GetMarketHistory(ctx, formattedPair.String())
if err != nil {
return nil, err
}
@@ -532,12 +533,12 @@ func (b *Bittrex) GetRecentTrades(p currency.Pair, assetType asset.Item) ([]trad
// GetHistoricTrades returns historic trade data within the timeframe provided
// Bittrex only reports recent trades
func (b *Bittrex) GetHistoricTrades(_ currency.Pair, _ asset.Item, _, _ time.Time) ([]trade.Data, error) {
func (b *Bittrex) GetHistoricTrades(_ context.Context, _ currency.Pair, _ asset.Item, _, _ time.Time) ([]trade.Data, error) {
return nil, common.ErrFunctionNotSupported
}
// SubmitOrder submits a new order
func (b *Bittrex) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
func (b *Bittrex) SubmitOrder(ctx context.Context, s *order.Submit) (order.SubmitResponse, error) {
if err := s.Validate(); err != nil {
return order.SubmitResponse{}, err
}
@@ -555,7 +556,8 @@ func (b *Bittrex) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
return order.SubmitResponse{}, err
}
orderData, err := b.Order(formattedPair.String(),
orderData, err := b.Order(ctx,
formattedPair.String(),
s.Side.String(),
s.Type.String(),
GoodTilCancelled,
@@ -574,27 +576,27 @@ func (b *Bittrex) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
// ModifyOrder will allow of changing orderbook placement and limit to
// market conversion
func (b *Bittrex) ModifyOrder(action *order.Modify) (order.Modify, error) {
func (b *Bittrex) ModifyOrder(_ context.Context, _ *order.Modify) (order.Modify, error) {
return order.Modify{}, common.ErrFunctionNotSupported
}
// CancelOrder cancels an order by its corresponding ID number
func (b *Bittrex) CancelOrder(ord *order.Cancel) error {
func (b *Bittrex) CancelOrder(ctx context.Context, ord *order.Cancel) error {
if err := ord.Validate(ord.StandardCancel()); err != nil {
return err
}
_, err := b.CancelExistingOrder(ord.ID)
_, err := b.CancelExistingOrder(ctx, ord.ID)
return err
}
// CancelBatchOrders cancels an orders by their corresponding ID numbers
func (b *Bittrex) CancelBatchOrders(orders []order.Cancel) (order.CancelBatchResponse, error) {
func (b *Bittrex) CancelBatchOrders(_ context.Context, _ []order.Cancel) (order.CancelBatchResponse, error) {
return order.CancelBatchResponse{}, common.ErrNotYetImplemented
}
// CancelAllOrders cancels all orders associated with a currency pair, or cancels all orders for all
// pairs if no pair was specified
func (b *Bittrex) CancelAllOrders(orderCancellation *order.Cancel) (order.CancelAllResponse, error) {
func (b *Bittrex) CancelAllOrders(ctx context.Context, orderCancellation *order.Cancel) (order.CancelAllResponse, error) {
var pair string
if orderCancellation != nil {
formattedPair, err := b.FormatExchangeCurrency(orderCancellation.Pair, orderCancellation.AssetType)
@@ -603,7 +605,7 @@ func (b *Bittrex) CancelAllOrders(orderCancellation *order.Cancel) (order.Cancel
}
pair = formattedPair.String()
}
orderData, err := b.CancelOpenOrders(pair)
orderData, err := b.CancelOpenOrders(ctx, pair)
if err != nil {
return order.CancelAllResponse{}, err
}
@@ -622,8 +624,8 @@ func (b *Bittrex) CancelAllOrders(orderCancellation *order.Cancel) (order.Cancel
}
// GetOrderInfo returns information on a current open order
func (b *Bittrex) GetOrderInfo(orderID string, pair currency.Pair, assetType asset.Item) (order.Detail, error) {
orderData, err := b.GetOrder(orderID)
func (b *Bittrex) GetOrderInfo(ctx context.Context, orderID string, pair currency.Pair, assetType asset.Item) (order.Detail, error) {
orderData, err := b.GetOrder(ctx, orderID)
if err != nil {
return order.Detail{}, err
}
@@ -692,8 +694,8 @@ func (b *Bittrex) ConstructOrderDetail(orderData *OrderData) (order.Detail, erro
}
// GetDepositAddress returns a deposit address for a specified currency
func (b *Bittrex) GetDepositAddress(cryptocurrency currency.Code, _ string) (string, error) {
depositAddr, err := b.GetCryptoDepositAddress(cryptocurrency.String())
func (b *Bittrex) GetDepositAddress(ctx context.Context, cryptocurrency currency.Code, _ string) (string, error) {
depositAddr, err := b.GetCryptoDepositAddress(ctx, cryptocurrency.String())
if err != nil {
return "", err
}
@@ -706,11 +708,12 @@ func (b *Bittrex) GetDepositAddress(cryptocurrency currency.Code, _ string) (str
// WithdrawCryptocurrencyFunds returns a withdrawal ID when a withdrawal is
// submitted
func (b *Bittrex) WithdrawCryptocurrencyFunds(withdrawRequest *withdraw.Request) (*withdraw.ExchangeResponse, error) {
func (b *Bittrex) WithdrawCryptocurrencyFunds(ctx context.Context, withdrawRequest *withdraw.Request) (*withdraw.ExchangeResponse, error) {
if err := withdrawRequest.Validate(); err != nil {
return nil, err
}
result, err := b.Withdraw(withdrawRequest.Currency.String(),
result, err := b.Withdraw(ctx,
withdrawRequest.Currency.String(),
withdrawRequest.Crypto.AddressTag,
withdrawRequest.Crypto.Address,
withdrawRequest.Amount)
@@ -726,18 +729,18 @@ func (b *Bittrex) WithdrawCryptocurrencyFunds(withdrawRequest *withdraw.Request)
// WithdrawFiatFunds returns a withdrawal ID when a
// withdrawal is submitted
func (b *Bittrex) WithdrawFiatFunds(_ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
func (b *Bittrex) WithdrawFiatFunds(_ context.Context, _ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
return nil, common.ErrFunctionNotSupported
}
// WithdrawFiatFundsToInternationalBank returns a withdrawal ID when a
// withdrawal is submitted
func (b *Bittrex) WithdrawFiatFundsToInternationalBank(_ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
func (b *Bittrex) WithdrawFiatFundsToInternationalBank(_ context.Context, _ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
return nil, common.ErrFunctionNotSupported
}
// GetActiveOrders retrieves any orders that are active/open
func (b *Bittrex) GetActiveOrders(req *order.GetOrdersRequest) ([]order.Detail, error) {
func (b *Bittrex) GetActiveOrders(ctx context.Context, req *order.GetOrdersRequest) ([]order.Detail, error) {
if err := req.Validate(); err != nil {
return nil, err
}
@@ -756,7 +759,7 @@ func (b *Bittrex) GetActiveOrders(req *order.GetOrdersRequest) ([]order.Detail,
return nil, err
}
orderData, sequence, err := b.GetOpenOrders(currPair)
orderData, sequence, err := b.GetOpenOrders(ctx, currPair)
if err != nil {
return nil, err
}
@@ -806,7 +809,7 @@ func (b *Bittrex) GetActiveOrders(req *order.GetOrdersRequest) ([]order.Detail,
// GetOrderHistory retrieves account order information
// Can Limit response to specific order status
func (b *Bittrex) GetOrderHistory(req *order.GetOrdersRequest) ([]order.Detail, error) {
func (b *Bittrex) GetOrderHistory(ctx context.Context, req *order.GetOrdersRequest) ([]order.Detail, error) {
if err := req.Validate(); err != nil {
return nil, err
}
@@ -826,7 +829,7 @@ func (b *Bittrex) GetOrderHistory(req *order.GetOrdersRequest) ([]order.Detail,
return nil, err
}
orderData, err := b.GetOrderHistoryForCurrency(formattedPair.String())
orderData, err := b.GetOrderHistoryForCurrency(ctx, formattedPair.String())
if err != nil {
return nil, err
}
@@ -880,18 +883,18 @@ func (b *Bittrex) GetOrderHistory(req *order.GetOrdersRequest) ([]order.Detail,
}
// GetFeeByType returns an estimate of fee based on type of transaction
func (b *Bittrex) GetFeeByType(feeBuilder *exchange.FeeBuilder) (float64, error) {
func (b *Bittrex) GetFeeByType(ctx context.Context, feeBuilder *exchange.FeeBuilder) (float64, error) {
if !b.AllowAuthenticatedRequest() && // Todo check connection status
feeBuilder.FeeType == exchange.CryptocurrencyTradeFee {
feeBuilder.FeeType = exchange.OfflineTradeFee
}
return b.GetFee(feeBuilder)
return b.GetFee(ctx, feeBuilder)
}
// ValidateCredentials validates current credentials used for wrapper
// functionality
func (b *Bittrex) ValidateCredentials(assetType asset.Item) error {
_, err := b.UpdateAccountInfo(assetType)
func (b *Bittrex) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
_, err := b.UpdateAccountInfo(ctx, assetType)
return b.CheckTransientError(err)
}
@@ -920,7 +923,7 @@ func (b *Bittrex) FormatExchangeKlineInterval(in kline.Interval) string {
// - 1 day interval: candles for 366 days
// This implementation rounds returns candles up to the next interval or to the end
// time (whichever comes first)
func (b *Bittrex) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
func (b *Bittrex) GetHistoricCandles(ctx context.Context, pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
if err := b.ValidateKline(pair, a, interval); err != nil {
return kline.Item{}, err
}
@@ -974,8 +977,13 @@ func (b *Bittrex) GetHistoricCandles(pair currency.Pair, a asset.Item, start, en
var ohlcData []CandleData
if getHistoric {
var historicData []CandleData
historicData, err = b.GetHistoricalCandles(formattedPair.String(),
b.FormatExchangeKlineInterval(interval), "TRADE", year, int(month), day)
historicData, err = b.GetHistoricalCandles(ctx,
formattedPair.String(),
b.FormatExchangeKlineInterval(interval),
"TRADE",
year,
int(month),
day)
if err != nil {
return kline.Item{}, err
}
@@ -983,8 +991,10 @@ func (b *Bittrex) GetHistoricCandles(pair currency.Pair, a asset.Item, start, en
}
if getRecent {
var recentData []CandleData
recentData, err = b.GetRecentCandles(formattedPair.String(),
b.FormatExchangeKlineInterval(interval), "TRADE")
recentData, err = b.GetRecentCandles(ctx,
formattedPair.String(),
b.FormatExchangeKlineInterval(interval),
"TRADE")
if err != nil {
return kline.Item{}, err
}
@@ -1011,6 +1021,6 @@ func (b *Bittrex) GetHistoricCandles(pair currency.Pair, a asset.Item, start, en
}
// GetHistoricCandlesExtended returns candles between a time period for a set time interval
func (b *Bittrex) GetHistoricCandlesExtended(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
func (b *Bittrex) GetHistoricCandlesExtended(ctx context.Context, pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
return kline.Item{}, common.ErrNotYetImplemented
}

7
exchanges/bittrex/bittrex_ws_orderbook.go
View File

@@ -1,6 +1,7 @@
package bittrex
import (
"context"
"fmt"
"github.com/thrasher-corp/gocryptotrader/currency"
@@ -110,8 +111,8 @@ func (b *Bittrex) UpdateLocalOBBuffer(update *OrderbookUpdateMessage) (bool, err
}
// SeedLocalOBCache seeds depth data
func (b *Bittrex) SeedLocalOBCache(p currency.Pair) error {
ob, sequence, err := b.GetOrderbook(p.String(), orderbookDepth)
func (b *Bittrex) SeedLocalOBCache(ctx context.Context, p currency.Pair) error {
ob, sequence, err := b.GetOrderbook(ctx, p.String(), orderbookDepth)
if err != nil {
return err
}
@@ -215,7 +216,7 @@ func (b *Bittrex) SynchroniseWebsocketOrderbook() {
// processJob fetches and processes orderbook updates
func (b *Bittrex) processJob(p currency.Pair) error {
err := b.SeedLocalOBCache(p)
err := b.SeedLocalOBCache(context.TODO(), p)
if err != nil {
return fmt.Errorf("%s %s seeding local cache for orderbook error: %v",
p, asset.Spot, err)