exchanges: Initial context propagation (#744)

* 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

exchanges/ftx/ftx_websocket.go

@@ -1,6 +1,7 @@
 package ftx
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -340,7 +341,7 @@ func (f *FTX) wsHandleData(respRaw []byte) error {
 				return err
 			}
 			var orderVars OrderVars
-			orderVars, err = f.compatibleOrderVars(
+			orderVars, err = f.compatibleOrderVars(context.TODO(),
 				resultData.OrderData.Side,
 				resultData.OrderData.Status,
 				resultData.OrderData.OrderType,

exchanges/ftx/ftx_wrapper.go

@@ -1,6 +1,7 @@
 package ftx
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"sort"
@@ -41,7 +42,7 @@ func (f *FTX) GetDefaultConfig() (*config.ExchangeConfig, error) {
 	}
 
 	if f.Features.Supports.RESTCapabilities.AutoPairUpdates {
-		err = f.UpdateTradablePairs(true)
+		err = f.UpdateTradablePairs(context.TODO(), true)
 		if err != nil {
 			return nil, err
 		}
@@ -219,7 +220,7 @@ func (f *FTX) Run() {
 		f.PrintEnabledPairs()
 	}
 
-	err := f.UpdateOrderExecutionLimits("")
+	err := f.UpdateOrderExecutionLimits(context.TODO(), "")
 	if err != nil {
 		log.Errorf(log.ExchangeSys,
 			"%s failed to set exchange order execution limits. Err: %v",
@@ -231,7 +232,7 @@ func (f *FTX) Run() {
 		return
 	}
 
-	err = f.UpdateTradablePairs(false)
+	err = f.UpdateTradablePairs(context.TODO(), false)
 	if err != nil {
 		log.Errorf(log.ExchangeSys,
 			"%s failed to update tradable pairs. Err: %s",
@@ -241,11 +242,11 @@ func (f *FTX) Run() {
 }
 
 // FetchTradablePairs returns a list of the exchanges tradable pairs
-func (f *FTX) FetchTradablePairs(a asset.Item) ([]string, error) {
+func (f *FTX) FetchTradablePairs(ctx context.Context, a asset.Item) ([]string, error) {
 	if !f.SupportsAsset(a) {
 		return nil, fmt.Errorf("asset type of %s is not supported by %s", a, f.Name)
 	}
-	markets, err := f.GetMarkets()
+	markets, err := f.GetMarkets(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -281,10 +282,10 @@ func (f *FTX) FetchTradablePairs(a asset.Item) ([]string, error) {
 
 // UpdateTradablePairs updates the exchanges available pairs and stores
 // them in the exchanges config
-func (f *FTX) UpdateTradablePairs(forceUpdate bool) error {
+func (f *FTX) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
 	assets := f.GetAssetTypes(false)
 	for x := range assets {
-		pairs, err := f.FetchTradablePairs(assets[x])
+		pairs, err := f.FetchTradablePairs(ctx, assets[x])
 		if err != nil {
 			return err
 		}
@@ -301,13 +302,13 @@ func (f *FTX) UpdateTradablePairs(forceUpdate bool) error {
 }
 
 // UpdateTickers updates the ticker for all currency pairs of a given asset type
-func (f *FTX) UpdateTickers(a asset.Item) error {
+func (f *FTX) UpdateTickers(ctx context.Context, a asset.Item) error {
 	allPairs, err := f.GetEnabledPairs(a)
 	if err != nil {
 		return err
 	}
 
-	markets, err := f.GetMarkets()
+	markets, err := f.GetMarkets(ctx)
 	if err != nil {
 		return err
 	}
@@ -342,13 +343,13 @@ func (f *FTX) UpdateTickers(a asset.Item) error {
 }
 
 // UpdateTicker updates and returns the ticker for a currency pair
-func (f *FTX) UpdateTicker(p currency.Pair, a asset.Item) (*ticker.Price, error) {
+func (f *FTX) UpdateTicker(ctx context.Context, p currency.Pair, a asset.Item) (*ticker.Price, error) {
 	formattedPair, err := f.FormatExchangeCurrency(p, a)
 	if err != nil {
 		return nil, err
 	}
 
-	market, err := f.GetMarket(formattedPair.String())
+	market, err := f.GetMarket(ctx, formattedPair.String())
 	if err != nil {
 		return nil, err
 	}
@@ -373,25 +374,25 @@ func (f *FTX) UpdateTicker(p currency.Pair, a asset.Item) (*ticker.Price, error)
 }
 
 // FetchTicker returns the ticker for a currency pair
-func (f *FTX) FetchTicker(p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
+func (f *FTX) FetchTicker(ctx context.Context, p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
 	tickerNew, err := ticker.GetTicker(f.Name, p, assetType)
 	if err != nil {
-		return f.UpdateTicker(p, assetType)
+		return f.UpdateTicker(ctx, p, assetType)
 	}
 	return tickerNew, nil
 }
 
 // FetchOrderbook returns orderbook base on the currency pair
-func (f *FTX) FetchOrderbook(currency currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
-	ob, err := orderbook.Get(f.Name, currency, assetType)
+func (f *FTX) FetchOrderbook(ctx context.Context, c currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
+	ob, err := orderbook.Get(f.Name, c, assetType)
 	if err != nil {
-		return f.UpdateOrderbook(currency, assetType)
+		return f.UpdateOrderbook(ctx, c, assetType)
 	}
 	return ob, nil
 }
 
 // UpdateOrderbook updates and returns the orderbook for a currency pair
-func (f *FTX) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
+func (f *FTX) UpdateOrderbook(ctx context.Context, p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
 	book := &orderbook.Base{
 		Exchange:        f.Name,
 		Pair:            p,
@@ -402,7 +403,7 @@ func (f *FTX) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orderbook
 	if err != nil {
 		return book, err
 	}
-	tempResp, err := f.GetOrderbook(formattedPair.String(), 100)
+	tempResp, err := f.GetOrderbook(ctx, formattedPair.String(), 100)
 	if err != nil {
 		return book, err
 	}
@@ -424,11 +425,11 @@ func (f *FTX) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orderbook
 }
 
 // UpdateAccountInfo retrieves balances for all enabled currencies
-func (f *FTX) UpdateAccountInfo(a asset.Item) (account.Holdings, error) {
+func (f *FTX) UpdateAccountInfo(ctx context.Context, a asset.Item) (account.Holdings, error) {
 	var resp account.Holdings
 	// Get all wallet balances used so we can transfer between accounts if
 	// needed.
-	data, err := f.GetAllWalletBalances()
+	data, err := f.GetAllWalletBalances(ctx)
 	if err != nil {
 		return resp, err
 	}
@@ -457,10 +458,10 @@ func (f *FTX) UpdateAccountInfo(a asset.Item) (account.Holdings, error) {
 }
 
 // FetchAccountInfo retrieves balances for all enabled currencies
-func (f *FTX) FetchAccountInfo(assetType asset.Item) (account.Holdings, error) {
+func (f *FTX) FetchAccountInfo(ctx context.Context, assetType asset.Item) (account.Holdings, error) {
 	acc, err := account.GetHoldings(f.Name, assetType)
 	if err != nil {
-		return f.UpdateAccountInfo(assetType)
+		return f.UpdateAccountInfo(ctx, assetType)
 	}
 
 	return acc, nil
@@ -468,9 +469,9 @@ func (f *FTX) FetchAccountInfo(assetType asset.Item) (account.Holdings, error) {
 
 // GetFundingHistory returns funding history, deposits and
 // withdrawals
-func (f *FTX) GetFundingHistory() ([]exchange.FundHistory, error) {
+func (f *FTX) GetFundingHistory(ctx context.Context) ([]exchange.FundHistory, error) {
 	var resp []exchange.FundHistory
-	depositData, err := f.FetchDepositHistory()
+	depositData, err := f.FetchDepositHistory(ctx)
 	if err != nil {
 		return resp, err
 	}
@@ -486,7 +487,7 @@ func (f *FTX) GetFundingHistory() ([]exchange.FundHistory, error) {
 		tempData.TransferID = strconv.FormatInt(depositData[x].ID, 10)
 		resp = append(resp, tempData)
 	}
-	withdrawalData, err := f.FetchWithdrawalHistory()
+	withdrawalData, err := f.FetchWithdrawalHistory(ctx)
 	if err != nil {
 		return resp, err
 	}
@@ -506,18 +507,18 @@ func (f *FTX) GetFundingHistory() ([]exchange.FundHistory, error) {
 }
 
 // GetWithdrawalsHistory returns previous withdrawals data
-func (f *FTX) GetWithdrawalsHistory(c currency.Code) (resp []exchange.WithdrawalHistory, err error) {
+func (f *FTX) 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 (f *FTX) GetRecentTrades(p currency.Pair, assetType asset.Item) ([]trade.Data, error) {
-	return f.GetHistoricTrades(p, assetType, time.Now().Add(-time.Minute*15), time.Now())
+func (f *FTX) GetRecentTrades(ctx context.Context, p currency.Pair, assetType asset.Item) ([]trade.Data, error) {
+	return f.GetHistoricTrades(ctx, p, assetType, time.Now().Add(-time.Minute*15), time.Now())
 }
 
 // GetHistoricTrades returns historic trade data within the timeframe provided
 // FTX returns trades from the end date and iterates towards the start date
-func (f *FTX) GetHistoricTrades(p currency.Pair, assetType asset.Item, timestampStart, timestampEnd time.Time) ([]trade.Data, error) {
+func (f *FTX) GetHistoricTrades(ctx context.Context, p currency.Pair, assetType asset.Item, timestampStart, timestampEnd time.Time) ([]trade.Data, error) {
 	if err := common.StartEndTimeCheck(timestampStart, timestampEnd); err != nil {
 		return nil, fmt.Errorf("invalid time range supplied. Start: %v End %v %w", timestampStart, timestampEnd, err)
 	}
@@ -532,7 +533,8 @@ func (f *FTX) GetHistoricTrades(p currency.Pair, assetType asset.Item, timestamp
 allTrades:
 	for {
 		var trades []TradeData
-		trades, err = f.GetTrades(p.String(),
+		trades, err = f.GetTrades(ctx,
+			p.String(),
 			timestampStart.Unix(),
 			ts.Unix(),
 			100)
@@ -585,7 +587,7 @@ allTrades:
 }
 
 // SubmitOrder submits a new order
-func (f *FTX) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
+func (f *FTX) SubmitOrder(ctx context.Context, s *order.Submit) (order.SubmitResponse, error) {
 	var resp order.SubmitResponse
 	if err := s.Validate(); err != nil {
 		return resp, err
@@ -603,7 +605,8 @@ func (f *FTX) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
 		return resp, err
 	}
 
-	tempResp, err := f.Order(fPair.String(),
+	tempResp, err := f.Order(ctx,
+		fPair.String(),
 		s.Side.Lower(),
 		s.Type.Lower(),
 		s.ReduceOnly,
@@ -622,13 +625,14 @@ func (f *FTX) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
 
 // ModifyOrder will allow of changing orderbook placement and limit to
 // market conversion
-func (f *FTX) ModifyOrder(action *order.Modify) (order.Modify, error) {
+func (f *FTX) ModifyOrder(ctx context.Context, action *order.Modify) (order.Modify, error) {
 	if err := action.Validate(); err != nil {
 		return order.Modify{}, err
 	}
 
 	if action.TriggerPrice != 0 {
-		a, err := f.ModifyTriggerOrder(action.ID,
+		a, err := f.ModifyTriggerOrder(ctx,
+			action.ID,
 			action.Type.String(),
 			action.Amount,
 			action.TriggerPrice,
@@ -652,12 +656,20 @@ func (f *FTX) ModifyOrder(action *order.Modify) (order.Modify, error) {
 	var o OrderData
 	var err error
 	if action.ID == "" {
-		o, err = f.ModifyOrderByClientID(action.ClientOrderID, action.ClientOrderID, action.Price, action.Amount)
+		o, err = f.ModifyOrderByClientID(ctx,
+			action.ClientOrderID,
+			action.ClientOrderID,
+			action.Price,
+			action.Amount)
 		if err != nil {
 			return order.Modify{}, err
 		}
 	} else {
-		o, err = f.ModifyPlacedOrder(action.ID, action.ClientOrderID, action.Price, action.Amount)
+		o, err = f.ModifyPlacedOrder(ctx,
+			action.ID,
+			action.ClientOrderID,
+			action.Price,
+			action.Amount)
 		if err != nil {
 			return order.Modify{}, err
 		}
@@ -674,27 +686,27 @@ func (f *FTX) ModifyOrder(action *order.Modify) (order.Modify, error) {
 }
 
 // CancelOrder cancels an order by its corresponding ID number
-func (f *FTX) CancelOrder(o *order.Cancel) error {
+func (f *FTX) CancelOrder(ctx context.Context, o *order.Cancel) error {
 	if err := o.Validate(o.StandardCancel()); err != nil {
 		return err
 	}
 
 	if o.ClientOrderID != "" {
-		_, err := f.DeleteOrderByClientID(o.ClientOrderID)
+		_, err := f.DeleteOrderByClientID(ctx, o.ClientOrderID)
 		return err
 	}
 
-	_, err := f.DeleteOrder(o.ID)
+	_, err := f.DeleteOrder(ctx, o.ID)
 	return err
 }
 
 // CancelBatchOrders cancels an orders by their corresponding ID numbers
-func (f *FTX) CancelBatchOrders(o []order.Cancel) (order.CancelBatchResponse, error) {
+func (f *FTX) CancelBatchOrders(ctx context.Context, o []order.Cancel) (order.CancelBatchResponse, error) {
 	return order.CancelBatchResponse{}, common.ErrNotYetImplemented
 }
 
 // CancelAllOrders cancels all orders associated with a currency pair
-func (f *FTX) CancelAllOrders(orderCancellation *order.Cancel) (order.CancelAllResponse, error) {
+func (f *FTX) CancelAllOrders(ctx context.Context, orderCancellation *order.Cancel) (order.CancelAllResponse, error) {
 	if err := orderCancellation.Validate(); err != nil {
 		return order.CancelAllResponse{}, err
 	}
@@ -704,14 +716,14 @@ func (f *FTX) CancelAllOrders(orderCancellation *order.Cancel) (order.CancelAllR
 	if err != nil {
 		return resp, err
 	}
-	orders, err := f.GetOpenOrders(formattedPair.String())
+	orders, err := f.GetOpenOrders(ctx, formattedPair.String())
 	if err != nil {
 		return resp, err
 	}
 
 	tempMap := make(map[string]string)
 	for x := range orders {
-		_, err := f.DeleteOrder(strconv.FormatInt(orders[x].ID, 10))
+		_, err := f.DeleteOrder(ctx, strconv.FormatInt(orders[x].ID, 10))
 		if err != nil {
 			tempMap[strconv.FormatInt(orders[x].ID, 10)] = "Cancellation Failed"
 			continue
@@ -723,7 +735,7 @@ func (f *FTX) CancelAllOrders(orderCancellation *order.Cancel) (order.CancelAllR
 }
 
 // GetCompatible gets compatible variables for order vars
-func (s *OrderData) GetCompatible(f *FTX) (OrderVars, error) {
+func (s *OrderData) GetCompatible(ctx context.Context, f *FTX) (OrderVars, error) {
 	var resp OrderVars
 	switch s.Side {
 	case order.Buy.Lower():
@@ -759,7 +771,7 @@ func (s *OrderData) GetCompatible(f *FTX) (OrderVars, error) {
 		resp.OrderType = order.Limit
 		feeBuilder.IsMaker = true
 	}
-	fee, err := f.GetFee(&feeBuilder)
+	fee, err := f.GetFee(ctx, &feeBuilder)
 	if err != nil {
 		return resp, err
 	}
@@ -768,9 +780,9 @@ func (s *OrderData) GetCompatible(f *FTX) (OrderVars, error) {
 }
 
 // GetOrderInfo returns order information based on order ID
-func (f *FTX) GetOrderInfo(orderID string, pair currency.Pair, assetType asset.Item) (order.Detail, error) {
+func (f *FTX) GetOrderInfo(ctx context.Context, orderID string, pair currency.Pair, assetType asset.Item) (order.Detail, error) {
 	var resp order.Detail
-	orderData, err := f.GetOrderStatus(orderID)
+	orderData, err := f.GetOrderStatus(ctx, orderID)
 	if err != nil {
 		return resp, err
 	}
@@ -792,7 +804,7 @@ func (f *FTX) GetOrderInfo(orderID string, pair currency.Pair, assetType asset.I
 	resp.AssetType = orderAssetType
 	resp.Price = orderData.Price
 	resp.RemainingAmount = orderData.RemainingSize
-	orderVars, err := orderData.GetCompatible(f)
+	orderVars, err := orderData.GetCompatible(ctx, f)
 	if err != nil {
 		return resp, err
 	}
@@ -804,8 +816,8 @@ func (f *FTX) GetOrderInfo(orderID string, pair currency.Pair, assetType asset.I
 }
 
 // GetDepositAddress returns a deposit address for a specified currency
-func (f *FTX) GetDepositAddress(cryptocurrency currency.Code, _ string) (string, error) {
-	a, err := f.FetchDepositAddress(cryptocurrency)
+func (f *FTX) GetDepositAddress(ctx context.Context, cryptocurrency currency.Code, _ string) (string, error) {
+	a, err := f.FetchDepositAddress(ctx, cryptocurrency)
 	if err != nil {
 		return "", err
 	}
@@ -814,11 +826,12 @@ func (f *FTX) GetDepositAddress(cryptocurrency currency.Code, _ string) (string,
 
 // WithdrawCryptocurrencyFunds returns a withdrawal ID when a withdrawal is
 // submitted
-func (f *FTX) WithdrawCryptocurrencyFunds(withdrawRequest *withdraw.Request) (*withdraw.ExchangeResponse, error) {
+func (f *FTX) WithdrawCryptocurrencyFunds(ctx context.Context, withdrawRequest *withdraw.Request) (*withdraw.ExchangeResponse, error) {
 	if err := withdrawRequest.Validate(); err != nil {
 		return nil, err
 	}
-	resp, err := f.Withdraw(withdrawRequest.Currency,
+	resp, err := f.Withdraw(ctx,
+		withdrawRequest.Currency,
 		withdrawRequest.Crypto.Address,
 		withdrawRequest.Crypto.AddressTag,
 		withdrawRequest.TradePassword,
@@ -836,13 +849,13 @@ func (f *FTX) WithdrawCryptocurrencyFunds(withdrawRequest *withdraw.Request) (*w
 
 // WithdrawFiatFunds returns a withdrawal ID when a withdrawal is
 // submitted
-func (f *FTX) WithdrawFiatFunds(_ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
+func (f *FTX) WithdrawFiatFunds(_ context.Context, _ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
 	return nil, common.ErrFunctionNotSupported
 }
 
 // WithdrawFiatFundsToInternationalBank returns a withdrawal ID when a
 // withdrawal is submitted
-func (f *FTX) WithdrawFiatFundsToInternationalBank(_ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
+func (f *FTX) WithdrawFiatFundsToInternationalBank(_ context.Context, _ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
 	return nil, common.ErrFunctionNotSupported
 }
 
@@ -852,7 +865,7 @@ func (f *FTX) GetWebsocket() (*stream.Websocket, error) {
 }
 
 // GetActiveOrders retrieves any orders that are active/open
-func (f *FTX) GetActiveOrders(getOrdersRequest *order.GetOrdersRequest) ([]order.Detail, error) {
+func (f *FTX) GetActiveOrders(ctx context.Context, getOrdersRequest *order.GetOrdersRequest) ([]order.Detail, error) {
 	if err := getOrdersRequest.Validate(); err != nil {
 		return nil, err
 	}
@@ -870,7 +883,7 @@ func (f *FTX) GetActiveOrders(getOrdersRequest *order.GetOrdersRequest) ([]order
 		}
 
 		var tempResp order.Detail
-		orderData, err := f.GetOpenOrders(formattedPair.String())
+		orderData, err := f.GetOpenOrders(ctx, formattedPair.String())
 		if err != nil {
 			return resp, err
 		}
@@ -892,7 +905,7 @@ func (f *FTX) GetActiveOrders(getOrdersRequest *order.GetOrdersRequest) ([]order
 			tempResp.Price = orderData[y].Price
 			tempResp.RemainingAmount = orderData[y].RemainingSize
 			var orderVars OrderVars
-			orderVars, err = f.compatibleOrderVars(
+			orderVars, err = f.compatibleOrderVars(ctx,
 				orderData[y].Side,
 				orderData[y].Status,
 				orderData[y].OrderType,
@@ -909,7 +922,8 @@ func (f *FTX) GetActiveOrders(getOrdersRequest *order.GetOrdersRequest) ([]order
 			resp = append(resp, tempResp)
 		}
 
-		triggerOrderData, err := f.GetOpenTriggerOrders(formattedPair.String(),
+		triggerOrderData, err := f.GetOpenTriggerOrders(ctx,
+			formattedPair.String(),
 			getOrdersRequest.Type.String())
 		if err != nil {
 			return resp, err
@@ -930,7 +944,7 @@ func (f *FTX) GetActiveOrders(getOrdersRequest *order.GetOrdersRequest) ([]order
 			tempResp.Price = triggerOrderData[z].AvgFillPrice
 			tempResp.RemainingAmount = triggerOrderData[z].Size - triggerOrderData[z].FilledSize
 			tempResp.TriggerPrice = triggerOrderData[z].TriggerPrice
-			orderVars, err := f.compatibleOrderVars(
+			orderVars, err := f.compatibleOrderVars(ctx,
 				triggerOrderData[z].Side,
 				triggerOrderData[z].Status,
 				triggerOrderData[z].OrderType,
@@ -952,7 +966,7 @@ func (f *FTX) GetActiveOrders(getOrdersRequest *order.GetOrdersRequest) ([]order
 
 // GetOrderHistory retrieves account order information
 // Can Limit response to specific order status
-func (f *FTX) GetOrderHistory(getOrdersRequest *order.GetOrdersRequest) ([]order.Detail, error) {
+func (f *FTX) GetOrderHistory(ctx context.Context, getOrdersRequest *order.GetOrdersRequest) ([]order.Detail, error) {
 	if err := getOrdersRequest.Validate(); err != nil {
 		return nil, err
 	}
@@ -970,8 +984,11 @@ func (f *FTX) GetOrderHistory(getOrdersRequest *order.GetOrdersRequest) ([]order
 			return nil, err
 		}
 
-		orderData, err := f.FetchOrderHistory(formattedPair.String(),
-			getOrdersRequest.StartTime, getOrdersRequest.EndTime, "")
+		orderData, err := f.FetchOrderHistory(ctx,
+			formattedPair.String(),
+			getOrdersRequest.StartTime,
+			getOrdersRequest.EndTime,
+			"")
 		if err != nil {
 			return resp, err
 		}
@@ -992,7 +1009,7 @@ func (f *FTX) GetOrderHistory(getOrdersRequest *order.GetOrdersRequest) ([]order
 			tempResp.Price = orderData[y].Price
 			tempResp.RemainingAmount = orderData[y].RemainingSize
 			var orderVars OrderVars
-			orderVars, err = f.compatibleOrderVars(
+			orderVars, err = f.compatibleOrderVars(ctx,
 				orderData[y].Side,
 				orderData[y].Status,
 				orderData[y].OrderType,
@@ -1008,7 +1025,8 @@ func (f *FTX) GetOrderHistory(getOrdersRequest *order.GetOrdersRequest) ([]order
 			tempResp.Fee = orderVars.Fee
 			resp = append(resp, tempResp)
 		}
-		triggerOrderData, err := f.GetTriggerOrderHistory(formattedPair.String(),
+		triggerOrderData, err := f.GetTriggerOrderHistory(ctx,
+			formattedPair.String(),
 			getOrdersRequest.StartTime,
 			getOrdersRequest.EndTime,
 			strings.ToLower(getOrdersRequest.Side.String()),
@@ -1033,7 +1051,7 @@ func (f *FTX) GetOrderHistory(getOrdersRequest *order.GetOrdersRequest) ([]order
 			tempResp.Price = triggerOrderData[z].AvgFillPrice
 			tempResp.RemainingAmount = triggerOrderData[z].Size - triggerOrderData[z].FilledSize
 			tempResp.TriggerPrice = triggerOrderData[z].TriggerPrice
-			orderVars, err := f.compatibleOrderVars(
+			orderVars, err := f.compatibleOrderVars(ctx,
 				triggerOrderData[z].Side,
 				triggerOrderData[z].Status,
 				triggerOrderData[z].OrderType,
@@ -1054,8 +1072,8 @@ func (f *FTX) GetOrderHistory(getOrdersRequest *order.GetOrdersRequest) ([]order
 }
 
 // GetFeeByType returns an estimate of fee based on the type of transaction
-func (f *FTX) GetFeeByType(feeBuilder *exchange.FeeBuilder) (float64, error) {
-	return f.GetFee(feeBuilder)
+func (f *FTX) GetFeeByType(ctx context.Context, feeBuilder *exchange.FeeBuilder) (float64, error) {
+	return f.GetFee(ctx, feeBuilder)
 }
 
 // SubscribeToWebsocketChannels appends to ChannelsToSubscribe
@@ -1071,19 +1089,19 @@ func (f *FTX) UnsubscribeToWebsocketChannels(channels []stream.ChannelSubscripti
 }
 
 // AuthenticateWebsocket sends an authentication message to the websocket
-func (f *FTX) AuthenticateWebsocket() error {
+func (f *FTX) AuthenticateWebsocket(_ context.Context) error {
 	return f.WsAuth()
 }
 
 // ValidateCredentials validates current credentials used for wrapper
 // functionality
-func (f *FTX) ValidateCredentials(assetType asset.Item) error {
-	_, err := f.UpdateAccountInfo(assetType)
+func (f *FTX) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
+	_, err := f.UpdateAccountInfo(ctx, assetType)
 	return f.CheckTransientError(err)
 }
 
 // GetHistoricCandles returns candles between a time period for a set time interval
-func (f *FTX) GetHistoricCandles(p currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
+func (f *FTX) GetHistoricCandles(ctx context.Context, p currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
 	if err := f.ValidateKline(p, a, interval); err != nil {
 		return kline.Item{}, err
 	}
@@ -1093,10 +1111,12 @@ func (f *FTX) GetHistoricCandles(p currency.Pair, a asset.Item, start, end time.
 		return kline.Item{}, err
 	}
 
-	ohlcData, err := f.GetHistoricalData(formattedPair.String(),
+	ohlcData, err := f.GetHistoricalData(ctx,
+		formattedPair.String(),
 		int64(interval.Duration().Seconds()),
 		int64(f.Features.Enabled.Kline.ResultLimit),
-		start, end)
+		start,
+		end)
 	if err != nil {
 		return kline.Item{}, err
 	}
@@ -1122,7 +1142,7 @@ func (f *FTX) GetHistoricCandles(p currency.Pair, a asset.Item, start, end time.
 }
 
 // GetHistoricCandlesExtended returns candles between a time period for a set time interval
-func (f *FTX) GetHistoricCandlesExtended(p currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
+func (f *FTX) GetHistoricCandlesExtended(ctx context.Context, p currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
 	if err := f.ValidateKline(p, a, interval); err != nil {
 		return kline.Item{}, err
 	}
@@ -1146,10 +1166,12 @@ func (f *FTX) GetHistoricCandlesExtended(p currency.Pair, a asset.Item, start, e
 
 	for x := range dates.Ranges {
 		var ohlcData []OHLCVData
-		ohlcData, err = f.GetHistoricalData(formattedPair.String(),
+		ohlcData, err = f.GetHistoricalData(ctx,
+			formattedPair.String(),
 			int64(interval.Duration().Seconds()),
 			int64(f.Features.Enabled.Kline.ResultLimit),
-			dates.Ranges[x].Start.Time, dates.Ranges[x].End.Time)
+			dates.Ranges[x].Start.Time,
+			dates.Ranges[x].End.Time)
 		if err != nil {
 			return kline.Item{}, err
 		}
@@ -1177,8 +1199,8 @@ func (f *FTX) GetHistoricCandlesExtended(p currency.Pair, a asset.Item, start, e
 }
 
 // UpdateOrderExecutionLimits sets exchange executions for a required asset type
-func (f *FTX) UpdateOrderExecutionLimits(_ asset.Item) error {
-	limits, err := f.FetchExchangeLimits()
+func (f *FTX) UpdateOrderExecutionLimits(ctx context.Context, _ asset.Item) error {
+	limits, err := f.FetchExchangeLimits(ctx)
 	if err != nil {
 		return fmt.Errorf("cannot update exchange execution limits: %w", err)
 	}