d0zingcat/gocryptotrader
1
0
Fork 0
mirror of https://github.com/d0zingcat/gocryptotrader.git synced 2026-05-31 07:26:44 +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

284
exchanges/bitmex/bitmex.go
View File

@@ -104,104 +104,104 @@ const (
)
// GetAnnouncement returns the general announcements from Bitmex
func (b *Bitmex) GetAnnouncement() ([]Announcement, error) {
func (b *Bitmex) GetAnnouncement(ctx context.Context) ([]Announcement, error) {
var announcement []Announcement
return announcement, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointAnnouncement,
return announcement, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointAnnouncement,
nil,
&announcement)
}
// GetUrgentAnnouncement returns an urgent announcement for your account
func (b *Bitmex) GetUrgentAnnouncement() ([]Announcement, error) {
func (b *Bitmex) GetUrgentAnnouncement(ctx context.Context) ([]Announcement, error) {
var announcement []Announcement
return announcement, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return announcement, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointAnnouncementUrgent,
nil,
&announcement)
}
// GetAPIKeys returns the APIkeys from bitmex
func (b *Bitmex) GetAPIKeys() ([]APIKey, error) {
func (b *Bitmex) GetAPIKeys(ctx context.Context) ([]APIKey, error) {
var keys []APIKey
return keys, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return keys, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointAPIkeys,
nil,
&keys)
}
// RemoveAPIKey removes an Apikey from the bitmex trading engine
func (b *Bitmex) RemoveAPIKey(params APIKeyParams) (bool, error) {
func (b *Bitmex) RemoveAPIKey(ctx context.Context, params APIKeyParams) (bool, error) {
var keyDeleted bool
return keyDeleted, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodDelete,
return keyDeleted, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodDelete,
bitmexEndpointAPIkeys,
&params,
&keyDeleted)
}
// DisableAPIKey disables an Apikey from the bitmex trading engine
func (b *Bitmex) DisableAPIKey(params APIKeyParams) (APIKey, error) {
func (b *Bitmex) DisableAPIKey(ctx context.Context, params APIKeyParams) (APIKey, error) {
var keyInfo APIKey
return keyInfo, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return keyInfo, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointDisableAPIkey,
&params,
&keyInfo)
}
// EnableAPIKey enables an Apikey from the bitmex trading engine
func (b *Bitmex) EnableAPIKey(params APIKeyParams) (APIKey, error) {
func (b *Bitmex) EnableAPIKey(ctx context.Context, params APIKeyParams) (APIKey, error) {
var keyInfo APIKey
return keyInfo, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return keyInfo, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointEnableAPIkey,
&params,
&keyInfo)
}
// GetTrollboxMessages returns messages from the bitmex trollbox
func (b *Bitmex) GetTrollboxMessages(params ChatGetParams) ([]Chat, error) {
func (b *Bitmex) GetTrollboxMessages(ctx context.Context, params ChatGetParams) ([]Chat, error) {
var messages []Chat
return messages, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointTrollbox, &params, &messages)
return messages, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointTrollbox, &params, &messages)
}
// SendTrollboxMessage sends a message to the bitmex trollbox
func (b *Bitmex) SendTrollboxMessage(params ChatSendParams) ([]Chat, error) {
func (b *Bitmex) SendTrollboxMessage(ctx context.Context, params ChatSendParams) ([]Chat, error) {
var messages []Chat
return messages, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return messages, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointTrollboxSend,
&params,
&messages)
}
// GetTrollboxChannels the channels from the the bitmex trollbox
func (b *Bitmex) GetTrollboxChannels() ([]ChatChannel, error) {
func (b *Bitmex) GetTrollboxChannels(ctx context.Context) ([]ChatChannel, error) {
var channels []ChatChannel
return channels, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointTrollboxChannels,
return channels, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointTrollboxChannels,
nil,
&channels)
}
// GetTrollboxConnectedUsers the channels from the the bitmex trollbox
func (b *Bitmex) GetTrollboxConnectedUsers() (ConnectedUsers, error) {
func (b *Bitmex) GetTrollboxConnectedUsers(ctx context.Context) (ConnectedUsers, error) {
var users ConnectedUsers
return users, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointTrollboxConnected, nil, &users)
return users, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointTrollboxConnected, nil, &users)
}
// GetAccountExecutions returns all raw transactions, which includes order
// opening and cancelation, and order status changes. It can be quite noisy.
// More focused information is available at /execution/tradeHistory.
func (b *Bitmex) GetAccountExecutions(params *GenericRequestParams) ([]Execution, error) {
func (b *Bitmex) GetAccountExecutions(ctx context.Context, params *GenericRequestParams) ([]Execution, error) {
var executionList []Execution
return executionList, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return executionList, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointExecution,
params,
&executionList)
@@ -209,17 +209,17 @@ func (b *Bitmex) GetAccountExecutions(params *GenericRequestParams) ([]Execution
// GetAccountExecutionTradeHistory returns all balance-affecting executions.
// This includes each trade, insurance charge, and settlement.
func (b *Bitmex) GetAccountExecutionTradeHistory(params *GenericRequestParams) ([]Execution, error) {
func (b *Bitmex) GetAccountExecutionTradeHistory(ctx context.Context, params *GenericRequestParams) ([]Execution, error) {
var tradeHistory []Execution
return tradeHistory, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return tradeHistory, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointExecutionTradeHistory,
params,
&tradeHistory)
}
// GetFullFundingHistory returns funding history
func (b *Bitmex) GetFullFundingHistory(symbol, count, filter, columns, start string, reverse bool, startTime, endTime time.Time) ([]Funding, error) {
func (b *Bitmex) GetFullFundingHistory(ctx context.Context, symbol, count, filter, columns, start string, reverse bool, startTime, endTime time.Time) ([]Funding, error) {
var fundingHistory []Funding
params := url.Values{}
params.Set("symbol", symbol)
@@ -238,50 +238,50 @@ func (b *Bitmex) GetFullFundingHistory(symbol, count, filter, columns, start str
params.Set("startTime", startTime.Format(time.RFC3339))
params.Set("endTime", endTime.Format(time.RFC3339))
}
return fundingHistory, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointFundingHistory+params.Encode(),
return fundingHistory, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointFundingHistory+params.Encode(),
nil,
&fundingHistory)
}
// GetInstruments returns instrument data
func (b *Bitmex) GetInstruments(params *GenericRequestParams) ([]Instrument, error) {
func (b *Bitmex) GetInstruments(ctx context.Context, params *GenericRequestParams) ([]Instrument, error) {
var instruments []Instrument
return instruments, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointInstruments,
return instruments, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointInstruments,
params,
&instruments)
}
// GetActiveInstruments returns active instruments
func (b *Bitmex) GetActiveInstruments(params *GenericRequestParams) ([]Instrument, error) {
func (b *Bitmex) GetActiveInstruments(ctx context.Context, params *GenericRequestParams) ([]Instrument, error) {
var activeInstruments []Instrument
return activeInstruments, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointActiveInstruments,
return activeInstruments, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointActiveInstruments,
params,
&activeInstruments)
}
// GetActiveAndIndexInstruments returns all active instruments and all indices
func (b *Bitmex) GetActiveAndIndexInstruments() ([]Instrument, error) {
func (b *Bitmex) GetActiveAndIndexInstruments(ctx context.Context) ([]Instrument, error) {
var activeAndIndices []Instrument
return activeAndIndices,
b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointActiveAndIndexInstruments,
b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointActiveAndIndexInstruments,
nil,
&activeAndIndices)
}
// GetActiveIntervals returns funding history
func (b *Bitmex) GetActiveIntervals() (InstrumentInterval, error) {
func (b *Bitmex) GetActiveIntervals(ctx context.Context) (InstrumentInterval, error) {
var interval InstrumentInterval
return interval, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointActiveIntervals,
return interval, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointActiveIntervals,
nil,
&interval)
}
// GetCompositeIndex returns composite index
func (b *Bitmex) GetCompositeIndex(symbol, count, filter, columns, start, reverse string, startTime, endTime time.Time) ([]IndexComposite, error) {
func (b *Bitmex) GetCompositeIndex(ctx context.Context, symbol, count, filter, columns, start, reverse string, startTime, endTime time.Time) ([]IndexComposite, error) {
var compositeIndices []IndexComposite
params := url.Values{}
params.Set("symbol", symbol)
@@ -307,82 +307,82 @@ func (b *Bitmex) GetCompositeIndex(symbol, count, filter, columns, start, revers
params.Set("startTime", startTime.Format(time.RFC3339))
params.Set("endTime", endTime.Format(time.RFC3339))
}
return compositeIndices, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointCompositeIndex+"?"+params.Encode(),
return compositeIndices, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointCompositeIndex+"?"+params.Encode(),
nil,
&compositeIndices)
}
// GetIndices returns all price indices
func (b *Bitmex) GetIndices() ([]Instrument, error) {
func (b *Bitmex) GetIndices(ctx context.Context) ([]Instrument, error) {
var indices []Instrument
return indices, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointIndices, nil, &indices)
return indices, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointIndices, nil, &indices)
}
// GetInsuranceFundHistory returns insurance fund history
func (b *Bitmex) GetInsuranceFundHistory(params *GenericRequestParams) ([]Insurance, error) {
func (b *Bitmex) GetInsuranceFundHistory(ctx context.Context, params *GenericRequestParams) ([]Insurance, error) {
var history []Insurance
return history, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointIndices, params, &history)
return history, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointIndices, params, &history)
}
// GetLeaderboard returns leaderboard information
func (b *Bitmex) GetLeaderboard(params LeaderboardGetParams) ([]Leaderboard, error) {
func (b *Bitmex) GetLeaderboard(ctx context.Context, params LeaderboardGetParams) ([]Leaderboard, error) {
var leader []Leaderboard
return leader, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointLeader, params, &leader)
return leader, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointLeader, params, &leader)
}
// GetAliasOnLeaderboard returns your alias on the leaderboard
func (b *Bitmex) GetAliasOnLeaderboard() (Alias, error) {
func (b *Bitmex) GetAliasOnLeaderboard(ctx context.Context) (Alias, error) {
var alias Alias
return alias, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointAlias, nil, &alias)
return alias, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointAlias, nil, &alias)
}
// GetLiquidationOrders returns liquidation orders
func (b *Bitmex) GetLiquidationOrders(params *GenericRequestParams) ([]Liquidation, error) {
func (b *Bitmex) GetLiquidationOrders(ctx context.Context, params *GenericRequestParams) ([]Liquidation, error) {
var orders []Liquidation
return orders, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointLiquidation,
return orders, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointLiquidation,
params,
&orders)
}
// GetCurrentNotifications returns your current notifications
func (b *Bitmex) GetCurrentNotifications() ([]Notification, error) {
func (b *Bitmex) GetCurrentNotifications(ctx context.Context) ([]Notification, error) {
var notifications []Notification
return notifications, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return notifications, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointNotifications,
nil,
&notifications)
}
// GetOrders returns all the orders, open and closed
func (b *Bitmex) GetOrders(params *OrdersRequest) ([]Order, error) {
func (b *Bitmex) GetOrders(ctx context.Context, params *OrdersRequest) ([]Order, error) {
var orders []Order
return orders, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return orders, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointOrder,
params,
&orders)
}
// AmendOrder amends the quantity or price of an open order
func (b *Bitmex) AmendOrder(params *OrderAmendParams) (Order, error) {
func (b *Bitmex) AmendOrder(ctx context.Context, params *OrderAmendParams) (Order, error) {
var order Order
return order, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPut,
return order, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPut,
bitmexEndpointOrder,
params,
&order)
}
// CreateOrder creates a new order
func (b *Bitmex) CreateOrder(params *OrderNewParams) (Order, error) {
func (b *Bitmex) CreateOrder(ctx context.Context, params *OrderNewParams) (Order, error) {
var orderInfo Order
return orderInfo, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return orderInfo, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointOrder,
params,
&orderInfo)
@@ -390,223 +390,223 @@ func (b *Bitmex) CreateOrder(params *OrderNewParams) (Order, error) {
// CancelOrders cancels one or a batch of orders on the exchange and returns
// a cancelled order list
func (b *Bitmex) CancelOrders(params *OrderCancelParams) ([]Order, error) {
func (b *Bitmex) CancelOrders(ctx context.Context, params *OrderCancelParams) ([]Order, error) {
var cancelledOrders []Order
return cancelledOrders, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodDelete,
return cancelledOrders, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodDelete,
bitmexEndpointOrder,
params,
&cancelledOrders)
}
// CancelAllExistingOrders cancels all open orders on the exchange
func (b *Bitmex) CancelAllExistingOrders(params OrderCancelAllParams) ([]Order, error) {
func (b *Bitmex) CancelAllExistingOrders(ctx context.Context, params OrderCancelAllParams) ([]Order, error) {
var cancelledOrders []Order
return cancelledOrders, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodDelete,
return cancelledOrders, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodDelete,
bitmexEndpointCancelAllOrders,
params,
&cancelledOrders)
}
// AmendBulkOrders amends multiple orders for the same symbol
func (b *Bitmex) AmendBulkOrders(params OrderAmendBulkParams) ([]Order, error) {
func (b *Bitmex) AmendBulkOrders(ctx context.Context, params OrderAmendBulkParams) ([]Order, error) {
var amendedOrders []Order
return amendedOrders, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPut,
return amendedOrders, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPut,
bitmexEndpointBulk,
params,
&amendedOrders)
}
// CreateBulkOrders creates multiple orders for the same symbol
func (b *Bitmex) CreateBulkOrders(params OrderNewBulkParams) ([]Order, error) {
func (b *Bitmex) CreateBulkOrders(ctx context.Context, params OrderNewBulkParams) ([]Order, error) {
var orders []Order
return orders, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return orders, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointBulk,
params,
&orders)
}
// CancelAllOrdersAfterTime closes all positions after a certain time period
func (b *Bitmex) CancelAllOrdersAfterTime(params OrderCancelAllAfterParams) ([]Order, error) {
func (b *Bitmex) CancelAllOrdersAfterTime(ctx context.Context, params OrderCancelAllAfterParams) ([]Order, error) {
var cancelledOrder []Order
return cancelledOrder, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return cancelledOrder, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointCancelOrderAfter,
params,
&cancelledOrder)
}
// ClosePosition closes a position WARNING deprecated use /order endpoint
func (b *Bitmex) ClosePosition(params OrderClosePositionParams) ([]Order, error) {
func (b *Bitmex) ClosePosition(ctx context.Context, params OrderClosePositionParams) ([]Order, error) {
var closedPositions []Order
return closedPositions, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return closedPositions, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointOrder,
params,
&closedPositions)
}
// GetOrderbook returns layer two orderbook data
func (b *Bitmex) GetOrderbook(params OrderBookGetL2Params) ([]OrderBookL2, error) {
func (b *Bitmex) GetOrderbook(ctx context.Context, params OrderBookGetL2Params) ([]OrderBookL2, error) {
var orderBooks []OrderBookL2
return orderBooks, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointOrderbookL2,
return orderBooks, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointOrderbookL2,
params,
&orderBooks)
}
// GetPositions returns positions
func (b *Bitmex) GetPositions(params PositionGetParams) ([]Position, error) {
func (b *Bitmex) GetPositions(ctx context.Context, params PositionGetParams) ([]Position, error) {
var positions []Position
return positions, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return positions, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointPosition,
params,
&positions)
}
// IsolatePosition enables isolated margin or cross margin per-position
func (b *Bitmex) IsolatePosition(params PositionIsolateMarginParams) (Position, error) {
func (b *Bitmex) IsolatePosition(ctx context.Context, params PositionIsolateMarginParams) (Position, error) {
var position Position
return position, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return position, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointIsolatePosition,
params,
&position)
}
// LeveragePosition chooses leverage for a position
func (b *Bitmex) LeveragePosition(params PositionUpdateLeverageParams) (Position, error) {
func (b *Bitmex) LeveragePosition(ctx context.Context, params PositionUpdateLeverageParams) (Position, error) {
var position Position
return position, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return position, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointLeveragePosition,
params,
&position)
}
// UpdateRiskLimit updates risk limit on a position
func (b *Bitmex) UpdateRiskLimit(params PositionUpdateRiskLimitParams) (Position, error) {
func (b *Bitmex) UpdateRiskLimit(ctx context.Context, params PositionUpdateRiskLimitParams) (Position, error) {
var position Position
return position, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return position, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointAdjustRiskLimit,
params,
&position)
}
// TransferMargin transfers equity in or out of a position
func (b *Bitmex) TransferMargin(params PositionTransferIsolatedMarginParams) (Position, error) {
func (b *Bitmex) TransferMargin(ctx context.Context, params PositionTransferIsolatedMarginParams) (Position, error) {
var position Position
return position, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return position, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointTransferMargin,
params,
&position)
}
// GetQuotes returns quotations
func (b *Bitmex) GetQuotes(params *GenericRequestParams) ([]Quote, error) {
func (b *Bitmex) GetQuotes(ctx context.Context, params *GenericRequestParams) ([]Quote, error) {
var quotations []Quote
return quotations, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointQuote,
return quotations, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointQuote,
params,
&quotations)
}
// GetQuotesByBuckets returns previous quotes in time buckets
func (b *Bitmex) GetQuotesByBuckets(params *QuoteGetBucketedParams) ([]Quote, error) {
func (b *Bitmex) GetQuotesByBuckets(ctx context.Context, params *QuoteGetBucketedParams) ([]Quote, error) {
var quotations []Quote
return quotations, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointQuoteBucketed,
return quotations, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointQuoteBucketed,
params,
&quotations)
}
// GetSettlementHistory returns settlement history
func (b *Bitmex) GetSettlementHistory(params *GenericRequestParams) ([]Settlement, error) {
func (b *Bitmex) GetSettlementHistory(ctx context.Context, params *GenericRequestParams) ([]Settlement, error) {
var history []Settlement
return history, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointSettlement,
return history, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointSettlement,
params,
&history)
}
// GetStats returns exchange wide per series turnover and volume statistics
func (b *Bitmex) GetStats() ([]Stats, error) {
func (b *Bitmex) GetStats(ctx context.Context) ([]Stats, error) {
var stats []Stats
return stats, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointStats, nil, &stats)
return stats, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointStats, nil, &stats)
}
// GetStatsHistorical historic stats
func (b *Bitmex) GetStatsHistorical() ([]StatsHistory, error) {
func (b *Bitmex) GetStatsHistorical(ctx context.Context) ([]StatsHistory, error) {
var history []StatsHistory
return history, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointStatsHistory, nil, &history)
return history, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointStatsHistory, nil, &history)
}
// GetStatSummary returns the stats summary in USD terms
func (b *Bitmex) GetStatSummary() ([]StatsUSD, error) {
func (b *Bitmex) GetStatSummary(ctx context.Context) ([]StatsUSD, error) {
var summary []StatsUSD
return summary, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointStatsSummary, nil, &summary)
return summary, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointStatsSummary, nil, &summary)
}
// GetTrade returns executed trades on the desk
func (b *Bitmex) GetTrade(params *GenericRequestParams) ([]Trade, error) {
func (b *Bitmex) GetTrade(ctx context.Context, params *GenericRequestParams) ([]Trade, error) {
var trade []Trade
return trade, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointTrade, params, &trade)
return trade, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointTrade, params, &trade)
}
// GetPreviousTrades previous trade history in time buckets
func (b *Bitmex) GetPreviousTrades(params *TradeGetBucketedParams) ([]Trade, error) {
func (b *Bitmex) GetPreviousTrades(ctx context.Context, params *TradeGetBucketedParams) ([]Trade, error) {
var trade []Trade
return trade, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointTradeBucketed,
return trade, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointTradeBucketed,
params,
&trade)
}
// GetUserInfo returns your user information
func (b *Bitmex) GetUserInfo() (User, error) {
func (b *Bitmex) GetUserInfo(ctx context.Context) (User, error) {
var userInfo User
return userInfo, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return userInfo, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointUser,
nil,
&userInfo)
}
// UpdateUserInfo updates user information
func (b *Bitmex) UpdateUserInfo(params *UserUpdateParams) (User, error) {
func (b *Bitmex) UpdateUserInfo(ctx context.Context, params *UserUpdateParams) (User, error) {
var userInfo User
return userInfo, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPut,
return userInfo, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPut,
bitmexEndpointUser,
params,
&userInfo)
}
// GetAffiliateStatus returns your affiliate status
func (b *Bitmex) GetAffiliateStatus() (AffiliateStatus, error) {
func (b *Bitmex) GetAffiliateStatus(ctx context.Context) (AffiliateStatus, error) {
var status AffiliateStatus
return status, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return status, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointUserAffiliate,
nil,
&status)
}
// CancelWithdraw cancels a current withdrawal
func (b *Bitmex) CancelWithdraw(token string) (TransactionInfo, error) {
func (b *Bitmex) CancelWithdraw(ctx context.Context, token string) (TransactionInfo, error) {
var info TransactionInfo
return info, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return info, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointUserCancelWithdraw,
UserTokenParams{Token: token},
&info)
@@ -614,56 +614,56 @@ func (b *Bitmex) CancelWithdraw(token string) (TransactionInfo, error) {
// CheckReferalCode checks a code, will return a percentage eg 0.1 for 10% or
// if err a 404
func (b *Bitmex) CheckReferalCode(referralCode string) (float64, error) {
func (b *Bitmex) CheckReferalCode(ctx context.Context, referralCode string) (float64, error) {
var percentage float64
return percentage, b.SendHTTPRequest(exchange.RestSpot, bitmexEndpointUserCheckReferralCode,
return percentage, b.SendHTTPRequest(ctx, exchange.RestSpot, bitmexEndpointUserCheckReferralCode,
UserCheckReferralCodeParams{ReferralCode: referralCode},
&percentage)
}
// GetUserCommision returns your account's commission status.
func (b *Bitmex) GetUserCommision() (UserCommission, error) {
func (b *Bitmex) GetUserCommision(ctx context.Context) (UserCommission, error) {
var commissionInfo UserCommission
return commissionInfo, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return commissionInfo, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointUserCommision,
nil,
&commissionInfo)
}
// ConfirmEmail confirms email address with a token
func (b *Bitmex) ConfirmEmail(token string) (ConfirmEmail, error) {
func (b *Bitmex) ConfirmEmail(ctx context.Context, token string) (ConfirmEmail, error) {
var confirmation ConfirmEmail
return confirmation, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return confirmation, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointUserConfirmEmail,
UserTokenParams{Token: token},
&confirmation)
}
// ConfirmTwoFactorAuth confirms 2FA for this account.
func (b *Bitmex) ConfirmTwoFactorAuth(token, typ string) (bool, error) {
func (b *Bitmex) ConfirmTwoFactorAuth(ctx context.Context, token, typ string) (bool, error) {
var working bool
return working, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return working, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointUserConfirmTFA,
UserConfirmTFAParams{Token: token, Type: typ},
&working)
}
// ConfirmWithdrawal confirms a withdrawal
func (b *Bitmex) ConfirmWithdrawal(token string) (TransactionInfo, error) {
func (b *Bitmex) ConfirmWithdrawal(ctx context.Context, token string) (TransactionInfo, error) {
var info TransactionInfo
return info, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return info, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointUserCancelWithdraw,
UserTokenParams{Token: token},
&info)
}
// GetCryptoDepositAddress returns a deposit address for a cryptocurency
func (b *Bitmex) GetCryptoDepositAddress(cryptoCurrency string) (string, error) {
func (b *Bitmex) GetCryptoDepositAddress(ctx context.Context, cryptoCurrency string) (string, error) {
var address string
if !strings.EqualFold(cryptoCurrency, currency.XBT.String()) {
@@ -672,85 +672,85 @@ func (b *Bitmex) GetCryptoDepositAddress(cryptoCurrency string) (string, error)
cryptoCurrency)
}
return address, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return address, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointUserDepositAddress,
UserCurrencyParams{Currency: "XBt"},
&address)
}
// DisableTFA dsiables 2 factor authentication for your account
func (b *Bitmex) DisableTFA(token, typ string) (bool, error) {
func (b *Bitmex) DisableTFA(ctx context.Context, token, typ string) (bool, error) {
var disabled bool
return disabled, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return disabled, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointUserDisableTFA,
UserConfirmTFAParams{Token: token, Type: typ},
&disabled)
}
// UserLogOut logs you out of BitMEX
func (b *Bitmex) UserLogOut() error {
return b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
func (b *Bitmex) UserLogOut(ctx context.Context) error {
return b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointUserLogout,
nil,
nil)
}
// UserLogOutAll logs you out of all systems for BitMEX
func (b *Bitmex) UserLogOutAll() (int64, error) {
func (b *Bitmex) UserLogOutAll(ctx context.Context) (int64, error) {
var status int64
return status, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return status, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointUserLogoutAll,
nil,
&status)
}
// GetUserMargin returns user margin information
func (b *Bitmex) GetUserMargin(currency string) (UserMargin, error) {
func (b *Bitmex) GetUserMargin(ctx context.Context, currency string) (UserMargin, error) {
var info UserMargin
return info, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return info, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointUserMargin,
UserCurrencyParams{Currency: currency},
&info)
}
// GetAllUserMargin returns user margin information
func (b *Bitmex) GetAllUserMargin() ([]UserMargin, error) {
func (b *Bitmex) GetAllUserMargin(ctx context.Context) ([]UserMargin, error) {
var info []UserMargin
return info, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return info, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointUserMargin,
UserCurrencyParams{Currency: "all"},
&info)
}
// GetMinimumWithdrawalFee returns minimum withdrawal fee information
func (b *Bitmex) GetMinimumWithdrawalFee(currency string) (MinWithdrawalFee, error) {
func (b *Bitmex) GetMinimumWithdrawalFee(ctx context.Context, currency string) (MinWithdrawalFee, error) {
var fee MinWithdrawalFee
return fee, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return fee, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointUserMinWithdrawalFee,
UserCurrencyParams{Currency: currency},
&fee)
}
// GetUserPreferences returns user preferences
func (b *Bitmex) GetUserPreferences(params UserPreferencesParams) (User, error) {
func (b *Bitmex) GetUserPreferences(ctx context.Context, params UserPreferencesParams) (User, error) {
var userInfo User
return userInfo, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return userInfo, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointUserPreferences,
params,
&userInfo)
}
// EnableTFA enables 2 factor authentication
func (b *Bitmex) EnableTFA(typ string) (bool, error) {
func (b *Bitmex) EnableTFA(ctx context.Context, typ string) (bool, error) {
var enabled bool
return enabled, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return enabled, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointUserRequestTFA,
UserConfirmTFAParams{Type: typ},
&enabled)
@@ -759,47 +759,47 @@ func (b *Bitmex) EnableTFA(typ string) (bool, error) {
// UserRequestWithdrawal This will send a confirmation email to the email
// address on record, unless requested via an API Key with the withdraw
// permission.
func (b *Bitmex) UserRequestWithdrawal(params UserRequestWithdrawalParams) (TransactionInfo, error) {
func (b *Bitmex) UserRequestWithdrawal(ctx context.Context, params UserRequestWithdrawalParams) (TransactionInfo, error) {
var info TransactionInfo
return info, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodPost,
return info, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost,
bitmexEndpointUserRequestWithdraw,
params,
&info)
}
// GetWalletInfo returns user wallet information
func (b *Bitmex) GetWalletInfo(currency string) (WalletInfo, error) {
func (b *Bitmex) GetWalletInfo(ctx context.Context, currency string) (WalletInfo, error) {
var info WalletInfo
return info, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return info, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointUserWallet,
UserCurrencyParams{Currency: currency},
&info)
}
// GetWalletHistory returns user wallet history transaction data
func (b *Bitmex) GetWalletHistory(currency string) ([]TransactionInfo, error) {
func (b *Bitmex) GetWalletHistory(ctx context.Context, currency string) ([]TransactionInfo, error) {
var info []TransactionInfo
return info, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return info, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointUserWalletHistory,
UserCurrencyParams{Currency: currency},
&info)
}
// GetWalletSummary returns user wallet summary
func (b *Bitmex) GetWalletSummary(currency string) ([]TransactionInfo, error) {
func (b *Bitmex) GetWalletSummary(ctx context.Context, currency string) ([]TransactionInfo, error) {
var info []TransactionInfo
return info, b.SendAuthenticatedHTTPRequest(exchange.RestSpot, http.MethodGet,
return info, b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodGet,
bitmexEndpointUserWalletSummary,
UserCurrencyParams{Currency: currency},
&info)
}
// SendHTTPRequest sends an unauthenticated HTTP request
func (b *Bitmex) SendHTTPRequest(ep exchange.URL, path string, params Parameter, result interface{}) error {
func (b *Bitmex) SendHTTPRequest(ctx context.Context, ep exchange.URL, path string, params Parameter, result interface{}) error {
var respCheck interface{}
endpoint, err := b.API.Endpoints.GetURL(ep)
if err != nil {
@@ -822,7 +822,7 @@ func (b *Bitmex) SendHTTPRequest(ep exchange.URL, path string, params Parameter,
HTTPRecording: b.HTTPRecording,
}
err = b.SendPayload(context.Background(), request.Unset, func() (*request.Item, error) {
err = b.SendPayload(ctx, request.Unset, func() (*request.Item, error) {
return item, nil
})
if err != nil {
@@ -833,7 +833,7 @@ func (b *Bitmex) SendHTTPRequest(ep exchange.URL, path string, params Parameter,
}
// SendAuthenticatedHTTPRequest sends an authenticated HTTP request to bitmex
func (b *Bitmex) SendAuthenticatedHTTPRequest(ep exchange.URL, verb, path string, params Parameter, result interface{}) error {
func (b *Bitmex) SendAuthenticatedHTTPRequest(ctx context.Context, ep exchange.URL, verb, path string, params Parameter, result interface{}) error {
if !b.AllowAuthenticatedRequest() {
return fmt.Errorf("%s %w", b.Name, exchange.ErrAuthenticatedRequestWithoutCredentialsSet)
}
@@ -890,7 +890,7 @@ func (b *Bitmex) SendAuthenticatedHTTPRequest(ep exchange.URL, verb, path string
HTTPRecording: b.HTTPRecording,
}, nil
}
err = b.SendPayload(context.Background(), request.Auth, newRequest)
err = b.SendPayload(ctx, request.Auth, newRequest)
if err != nil {
return err
}

192
exchanges/bitmex/bitmex_test.go
View File

@@ -1,6 +1,7 @@
package bitmex
import (
"context"
"log"
"net/http"
"os"
@@ -63,12 +64,14 @@ func TestStart(t *testing.T) {
func TestGetFullFundingHistory(t *testing.T) {
t.Parallel()
_, err := b.GetFullFundingHistory("", "", "", "", "", true, time.Now().Add(-time.Minute), time.Now())
_, err := b.GetFullFundingHistory(context.Background(),
"", "", "", "", "", true, time.Now().Add(-time.Minute), time.Now())
if err != nil {
t.Error(err)
}
_, err = b.GetFullFundingHistory("LTCUSD", "1", "", "", "", true, time.Now().Add(-time.Minute), time.Now())
_, err = b.GetFullFundingHistory(context.Background(),
"LTCUSD", "1", "", "", "", true, time.Now().Add(-time.Minute), time.Now())
if err != nil {
t.Error(err)
}
@@ -79,7 +82,7 @@ func TestGetUrgentAnnouncement(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.GetUrgentAnnouncement()
_, err := b.GetUrgentAnnouncement(context.Background())
if err == nil {
t.Error("GetUrgentAnnouncement() Expected error")
}
@@ -90,7 +93,7 @@ func TestGetAPIKeys(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.GetAPIKeys()
_, err := b.GetAPIKeys(context.Background())
if err == nil {
t.Error("GetAPIKeys() Expected error")
}
@@ -99,7 +102,7 @@ func TestGetAPIKeys(t *testing.T) {
func TestRemoveAPIKey(t *testing.T) {
t.Parallel()
_, err := b.RemoveAPIKey(APIKeyParams{APIKeyID: "1337"})
_, err := b.RemoveAPIKey(context.Background(), APIKeyParams{APIKeyID: "1337"})
if err == nil {
t.Error("RemoveAPIKey() Expected error")
}
@@ -110,7 +113,7 @@ func TestDisableAPIKey(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.DisableAPIKey(APIKeyParams{APIKeyID: "1337"})
_, err := b.DisableAPIKey(context.Background(), APIKeyParams{APIKeyID: "1337"})
if err == nil {
t.Error("DisableAPIKey() Expected error")
}
@@ -121,7 +124,7 @@ func TestEnableAPIKey(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.EnableAPIKey(APIKeyParams{APIKeyID: "1337"})
_, err := b.EnableAPIKey(context.Background(), APIKeyParams{APIKeyID: "1337"})
if err == nil {
t.Error("EnableAPIKey() Expected error")
}
@@ -129,7 +132,7 @@ func TestEnableAPIKey(t *testing.T) {
func TestGetTrollboxMessages(t *testing.T) {
t.Parallel()
_, err := b.GetTrollboxMessages(ChatGetParams{Count: 1})
_, err := b.GetTrollboxMessages(context.Background(), ChatGetParams{Count: 1})
if err != nil {
t.Error("GetTrollboxMessages() error", err)
}
@@ -140,9 +143,10 @@ func TestSendTrollboxMessage(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.SendTrollboxMessage(ChatSendParams{
ChannelID: 1337,
Message: "Hello,World!"})
_, err := b.SendTrollboxMessage(context.Background(),
ChatSendParams{
ChannelID: 1337,
Message: "Hello,World!"})
if err == nil {
t.Error("SendTrollboxMessage() Expected error")
}
@@ -150,7 +154,7 @@ func TestSendTrollboxMessage(t *testing.T) {
func TestGetTrollboxChannels(t *testing.T) {
t.Parallel()
_, err := b.GetTrollboxChannels()
_, err := b.GetTrollboxChannels(context.Background())
if err != nil {
t.Error("GetTrollboxChannels() error", err)
}
@@ -158,7 +162,7 @@ func TestGetTrollboxChannels(t *testing.T) {
func TestGetTrollboxConnectedUsers(t *testing.T) {
t.Parallel()
_, err := b.GetTrollboxConnectedUsers()
_, err := b.GetTrollboxConnectedUsers(context.Background())
if err == nil {
t.Error("GetTrollboxConnectedUsers() Expected error")
}
@@ -169,7 +173,8 @@ func TestGetAccountExecutions(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.GetAccountExecutions(&GenericRequestParams{})
_, err := b.GetAccountExecutions(context.Background(),
&GenericRequestParams{})
if err == nil {
t.Error("GetAccountExecutions() Expected error")
}
@@ -180,7 +185,8 @@ func TestGetAccountExecutionTradeHistory(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.GetAccountExecutionTradeHistory(&GenericRequestParams{})
_, err := b.GetAccountExecutionTradeHistory(context.Background(),
&GenericRequestParams{})
if err == nil {
t.Error("GetAccountExecutionTradeHistory() Expected error")
}
@@ -188,7 +194,7 @@ func TestGetAccountExecutionTradeHistory(t *testing.T) {
func TestGetFundingHistory(t *testing.T) {
t.Parallel()
_, err := b.GetFundingHistory()
_, err := b.GetFundingHistory(context.Background())
if err == nil {
t.Error("GetFundingHistory() Expected error")
}
@@ -196,9 +202,10 @@ func TestGetFundingHistory(t *testing.T) {
func TestGetInstruments(t *testing.T) {
t.Parallel()
_, err := b.GetInstruments(&GenericRequestParams{
Symbol: "XRPUSD",
})
_, err := b.GetInstruments(context.Background(),
&GenericRequestParams{
Symbol: "XRPUSD",
})
if err != nil {
t.Error("GetInstruments() error", err)
}
@@ -206,7 +213,8 @@ func TestGetInstruments(t *testing.T) {
func TestGetActiveInstruments(t *testing.T) {
t.Parallel()
_, err := b.GetActiveInstruments(&GenericRequestParams{})
_, err := b.GetActiveInstruments(context.Background(),
&GenericRequestParams{})
if err != nil {
t.Error("GetActiveInstruments() error", err)
}
@@ -214,7 +222,7 @@ func TestGetActiveInstruments(t *testing.T) {
func TestGetActiveAndIndexInstruments(t *testing.T) {
t.Parallel()
_, err := b.GetActiveAndIndexInstruments()
_, err := b.GetActiveAndIndexInstruments(context.Background())
if err != nil {
t.Error("GetActiveAndIndexInstruments() error", err)
}
@@ -222,7 +230,7 @@ func TestGetActiveAndIndexInstruments(t *testing.T) {
func TestGetActiveIntervals(t *testing.T) {
t.Parallel()
_, err := b.GetActiveIntervals()
_, err := b.GetActiveIntervals(context.Background())
if err == nil {
t.Error("GetActiveIntervals() Expected error")
}
@@ -230,7 +238,8 @@ func TestGetActiveIntervals(t *testing.T) {
func TestGetCompositeIndex(t *testing.T) {
t.Parallel()
_, err := b.GetCompositeIndex(".XBT", "", "", "", "", "", time.Time{}, time.Time{})
_, err := b.GetCompositeIndex(context.Background(),
".XBT", "", "", "", "", "", time.Time{}, time.Time{})
if err != nil {
t.Error("GetCompositeIndex() Expected error", err)
}
@@ -238,7 +247,7 @@ func TestGetCompositeIndex(t *testing.T) {
func TestGetIndices(t *testing.T) {
t.Parallel()
_, err := b.GetIndices()
_, err := b.GetIndices(context.Background())
if err != nil {
t.Error("GetIndices() error", err)
}
@@ -246,7 +255,8 @@ func TestGetIndices(t *testing.T) {
func TestGetInsuranceFundHistory(t *testing.T) {
t.Parallel()
_, err := b.GetInsuranceFundHistory(&GenericRequestParams{})
_, err := b.GetInsuranceFundHistory(context.Background(),
&GenericRequestParams{})
if err != nil {
t.Error("GetInsuranceFundHistory() error", err)
}
@@ -254,7 +264,7 @@ func TestGetInsuranceFundHistory(t *testing.T) {
func TestGetLeaderboard(t *testing.T) {
t.Parallel()
_, err := b.GetLeaderboard(LeaderboardGetParams{})
_, err := b.GetLeaderboard(context.Background(), LeaderboardGetParams{})
if err != nil {
t.Error("GetLeaderboard() error", err)
}
@@ -262,7 +272,7 @@ func TestGetLeaderboard(t *testing.T) {
func TestGetAliasOnLeaderboard(t *testing.T) {
t.Parallel()
_, err := b.GetAliasOnLeaderboard()
_, err := b.GetAliasOnLeaderboard(context.Background())
if err == nil {
t.Error("GetAliasOnLeaderboard() Expected error")
}
@@ -270,7 +280,8 @@ func TestGetAliasOnLeaderboard(t *testing.T) {
func TestGetLiquidationOrders(t *testing.T) {
t.Parallel()
_, err := b.GetLiquidationOrders(&GenericRequestParams{})
_, err := b.GetLiquidationOrders(context.Background(),
&GenericRequestParams{})
if err != nil {
t.Error("GetLiquidationOrders() error", err)
}
@@ -281,7 +292,7 @@ func TestGetCurrentNotifications(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.GetCurrentNotifications()
_, err := b.GetCurrentNotifications(context.Background())
if err == nil {
t.Error("GetCurrentNotifications() Expected error")
}
@@ -292,7 +303,7 @@ func TestAmendOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.AmendOrder(&OrderAmendParams{})
_, err := b.AmendOrder(context.Background(), &OrderAmendParams{})
if err == nil {
t.Error("AmendOrder() Expected error")
}
@@ -303,10 +314,11 @@ func TestCreateOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.CreateOrder(&OrderNewParams{Symbol: "XBTM15",
Price: 219.0,
ClientOrderID: "mm_bitmex_1a/oemUeQ4CAJZgP3fjHsA",
OrderQuantity: 98})
_, err := b.CreateOrder(context.Background(),
&OrderNewParams{Symbol: "XBTM15",
Price: 219.0,
ClientOrderID: "mm_bitmex_1a/oemUeQ4CAJZgP3fjHsA",
OrderQuantity: 98})
if err == nil {
t.Error("CreateOrder() Expected error")
}
@@ -317,7 +329,7 @@ func TestCancelOrders(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.CancelOrders(&OrderCancelParams{})
_, err := b.CancelOrders(context.Background(), &OrderCancelParams{})
if err == nil {
t.Error("CancelOrders() Expected error")
}
@@ -328,9 +340,10 @@ func TestCancelAllOrders(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.CancelAllExistingOrders(OrderCancelAllParams{})
_, err := b.CancelAllExistingOrders(context.Background(),
OrderCancelAllParams{})
if err == nil {
t.Error("CancelAllOrders(orderCancellation *order.Cancel) (order.CancelAllResponse, error)", err)
t.Error("CancelAllOrders(ctx context.Context, orderCancellation *order.Cancel) (order.CancelAllResponse, error)", err)
}
}
@@ -339,7 +352,7 @@ func TestAmendBulkOrders(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.AmendBulkOrders(OrderAmendBulkParams{})
_, err := b.AmendBulkOrders(context.Background(), OrderAmendBulkParams{})
if err == nil {
t.Error("AmendBulkOrders() Expected error")
}
@@ -350,7 +363,7 @@ func TestCreateBulkOrders(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.CreateBulkOrders(OrderNewBulkParams{})
_, err := b.CreateBulkOrders(context.Background(), OrderNewBulkParams{})
if err == nil {
t.Error("CreateBulkOrders() Expected error")
}
@@ -361,7 +374,8 @@ func TestCancelAllOrdersAfterTime(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.CancelAllOrdersAfterTime(OrderCancelAllAfterParams{})
_, err := b.CancelAllOrdersAfterTime(context.Background(),
OrderCancelAllAfterParams{})
if err == nil {
t.Error("CancelAllOrdersAfterTime() Expected error")
}
@@ -369,7 +383,7 @@ func TestCancelAllOrdersAfterTime(t *testing.T) {
func TestClosePosition(t *testing.T) {
t.Parallel()
_, err := b.ClosePosition(OrderClosePositionParams{})
_, err := b.ClosePosition(context.Background(), OrderClosePositionParams{})
if err == nil {
t.Error("ClosePosition() Expected error")
}
@@ -377,7 +391,8 @@ func TestClosePosition(t *testing.T) {
func TestGetOrderbook(t *testing.T) {
t.Parallel()
_, err := b.GetOrderbook(OrderBookGetL2Params{Symbol: "XBT"})
_, err := b.GetOrderbook(context.Background(),
OrderBookGetL2Params{Symbol: "XBT"})
if err != nil {
t.Error("GetOrderbook() error", err)
}
@@ -385,7 +400,7 @@ func TestGetOrderbook(t *testing.T) {
func TestGetPositions(t *testing.T) {
t.Parallel()
_, err := b.GetPositions(PositionGetParams{})
_, err := b.GetPositions(context.Background(), PositionGetParams{})
if err == nil {
t.Error("GetPositions() Expected error")
}
@@ -393,7 +408,8 @@ func TestGetPositions(t *testing.T) {
func TestIsolatePosition(t *testing.T) {
t.Parallel()
_, err := b.IsolatePosition(PositionIsolateMarginParams{Symbol: "XBT"})
_, err := b.IsolatePosition(context.Background(),
PositionIsolateMarginParams{Symbol: "XBT"})
if err == nil {
t.Error("IsolatePosition() Expected error")
}
@@ -401,7 +417,8 @@ func TestIsolatePosition(t *testing.T) {
func TestLeveragePosition(t *testing.T) {
t.Parallel()
_, err := b.LeveragePosition(PositionUpdateLeverageParams{})
_, err := b.LeveragePosition(context.Background(),
PositionUpdateLeverageParams{})
if err == nil {
t.Error("LeveragePosition() Expected error")
}
@@ -409,7 +426,8 @@ func TestLeveragePosition(t *testing.T) {
func TestUpdateRiskLimit(t *testing.T) {
t.Parallel()
_, err := b.UpdateRiskLimit(PositionUpdateRiskLimitParams{})
_, err := b.UpdateRiskLimit(context.Background(),
PositionUpdateRiskLimitParams{})
if err == nil {
t.Error("UpdateRiskLimit() Expected error")
}
@@ -417,7 +435,8 @@ func TestUpdateRiskLimit(t *testing.T) {
func TestTransferMargin(t *testing.T) {
t.Parallel()
_, err := b.TransferMargin(PositionTransferIsolatedMarginParams{})
_, err := b.TransferMargin(context.Background(),
PositionTransferIsolatedMarginParams{})
if err == nil {
t.Error("TransferMargin() Expected error")
}
@@ -425,7 +444,8 @@ func TestTransferMargin(t *testing.T) {
func TestGetQuotesByBuckets(t *testing.T) {
t.Parallel()
_, err := b.GetQuotesByBuckets(&QuoteGetBucketedParams{})
_, err := b.GetQuotesByBuckets(context.Background(),
&QuoteGetBucketedParams{})
if err == nil {
t.Error("GetQuotesByBuckets() Expected error")
}
@@ -433,7 +453,8 @@ func TestGetQuotesByBuckets(t *testing.T) {
func TestGetSettlementHistory(t *testing.T) {
t.Parallel()
_, err := b.GetSettlementHistory(&GenericRequestParams{})
_, err := b.GetSettlementHistory(context.Background(),
&GenericRequestParams{})
if err != nil {
t.Error("GetSettlementHistory() error", err)
}
@@ -441,7 +462,7 @@ func TestGetSettlementHistory(t *testing.T) {
func TestGetStats(t *testing.T) {
t.Parallel()
_, err := b.GetStats()
_, err := b.GetStats(context.Background())
if err != nil {
t.Error("GetStats() error", err)
}
@@ -449,7 +470,7 @@ func TestGetStats(t *testing.T) {
func TestGetStatsHistorical(t *testing.T) {
t.Parallel()
_, err := b.GetStatsHistorical()
_, err := b.GetStatsHistorical(context.Background())
if err != nil {
t.Error("GetStatsHistorical() error", err)
}
@@ -457,7 +478,7 @@ func TestGetStatsHistorical(t *testing.T) {
func TestGetStatSummary(t *testing.T) {
t.Parallel()
_, err := b.GetStatSummary()
_, err := b.GetStatSummary(context.Background())
if err != nil {
t.Error("GetStatSummary() error", err)
}
@@ -465,11 +486,12 @@ func TestGetStatSummary(t *testing.T) {
func TestGetTrade(t *testing.T) {
t.Parallel()
_, err := b.GetTrade(&GenericRequestParams{
Symbol: "XBT",
Reverse: false,
StartTime: time.Now().Add(-time.Minute).Format(time.RFC3339),
})
_, err := b.GetTrade(context.Background(),
&GenericRequestParams{
Symbol: "XBT",
Reverse: false,
StartTime: time.Now().Add(-time.Minute).Format(time.RFC3339),
})
if err != nil {
t.Error("GetTrade() error", err)
}
@@ -477,11 +499,12 @@ func TestGetTrade(t *testing.T) {
func TestGetPreviousTrades(t *testing.T) {
t.Parallel()
_, err := b.GetPreviousTrades(&TradeGetBucketedParams{
Symbol: "XBTBTC",
Start: int32(time.Now().Add(-time.Hour).Unix()),
Columns: "open,high,low,close,volume",
})
_, err := b.GetPreviousTrades(context.Background(),
&TradeGetBucketedParams{
Symbol: "XBTBTC",
Start: int32(time.Now().Add(-time.Hour).Unix()),
Columns: "open,high,low,close,volume",
})
if err == nil {
t.Error("GetPreviousTrades() Expected error")
}
@@ -500,7 +523,7 @@ func setFeeBuilder() *exchange.FeeBuilder {
func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
t.Parallel()
var feeBuilder = setFeeBuilder()
_, err := b.GetFeeByType(feeBuilder)
_, err := b.GetFeeByType(context.Background(), feeBuilder)
if err != nil {
t.Fatal(err)
}
@@ -593,7 +616,7 @@ func TestGetActiveOrders(t *testing.T) {
AssetType: asset.Spot,
}
_, 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 {
@@ -610,7 +633,7 @@ func TestGetOrderHistory(t *testing.T) {
AssetType: asset.Spot,
}
_, 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 {
@@ -642,7 +665,7 @@ func TestSubmitOrder(t *testing.T) {
ClientID: "meowOrder",
AssetType: asset.Futures,
}
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 {
@@ -665,7 +688,7 @@ func TestCancelExchangeOrder(t *testing.T) {
AssetType: asset.Futures,
}
err := b.CancelOrder(orderCancellation)
err := b.CancelOrder(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
t.Error("Expecting an error when no keys are set")
}
@@ -689,7 +712,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
AssetType: asset.Futures,
}
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")
@@ -706,12 +729,12 @@ func TestCancelAllExchangeOrders(t *testing.T) {
func TestGetAccountInfo(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() {
_, err := b.UpdateAccountInfo(asset.Spot)
_, err := b.UpdateAccountInfo(context.Background(), asset.Spot)
if err != nil {
t.Error("GetAccountInfo() error", err)
}
} else {
_, err := b.UpdateAccountInfo(asset.Spot)
_, err := b.UpdateAccountInfo(context.Background(), asset.Spot)
if err == nil {
t.Error("GetAccountInfo() error")
}
@@ -723,7 +746,8 @@ func TestModifyOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.ModifyOrder(&order.Modify{ID: "1337", AssetType: asset.Futures})
_, err := b.ModifyOrder(context.Background(),
&order.Modify{ID: "1337", AssetType: asset.Futures})
if err == nil {
t.Error("ModifyOrder() error")
}
@@ -745,7 +769,8 @@ func TestWithdraw(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")
}
@@ -761,7 +786,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)
}
@@ -774,7 +799,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)
}
@@ -783,12 +809,12 @@ func TestWithdrawInternationalBank(t *testing.T) {
func TestGetDepositAddress(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() {
_, err := b.GetDepositAddress(currency.BTC, "")
_, err := b.GetDepositAddress(context.Background(), currency.BTC, "")
if err != nil {
t.Error("GetDepositAddress() error", err)
}
} else {
_, err := b.GetDepositAddress(currency.BTC, "")
_, err := b.GetDepositAddress(context.Background(), currency.BTC, "")
if err == nil {
t.Error("GetDepositAddress() error cannot be nil")
}
@@ -826,7 +852,7 @@ func TestWsAuth(t *testing.T) {
func TestUpdateTradablePairs(t *testing.T) {
t.Parallel()
err := b.UpdateTradablePairs(true)
err := b.UpdateTradablePairs(context.Background(), true)
if err != nil {
t.Fatal(err)
}
@@ -1070,12 +1096,12 @@ func TestWsTrades(t *testing.T) {
func TestGetRecentTrades(t *testing.T) {
t.Parallel()
err := b.UpdateTradablePairs(false)
err := b.UpdateTradablePairs(context.Background(), false)
if err != nil {
t.Fatal(err)
}
currencyPair := b.CurrencyPairs.Pairs[asset.Futures].Available[0]
_, err = b.GetRecentTrades(currencyPair, asset.Futures)
_, err = b.GetRecentTrades(context.Background(), currencyPair, asset.Futures)
if err != nil {
t.Error(err)
}
@@ -1083,12 +1109,12 @@ func TestGetRecentTrades(t *testing.T) {
func TestGetHistoricTrades(t *testing.T) {
t.Parallel()
err := b.UpdateTradablePairs(false)
err := b.UpdateTradablePairs(context.Background(), false)
if err != nil {
t.Fatal(err)
}
currencyPair := b.CurrencyPairs.Pairs[asset.Futures].Available[0]
_, err = b.GetHistoricTrades(currencyPair, asset.Futures, time.Now().Add(-time.Minute), time.Now())
_, err = b.GetHistoricTrades(context.Background(), currencyPair, asset.Futures, time.Now().Add(-time.Minute), time.Now())
if err != nil {
t.Error(err)
}
@@ -1096,14 +1122,14 @@ func TestGetHistoricTrades(t *testing.T) {
func TestUpdateTicker(t *testing.T) {
cp := currency.NewPair(currency.ETH, currency.USD)
_, err := b.UpdateTicker(cp, asset.PerpetualContract)
_, err := b.UpdateTicker(context.Background(), cp, asset.PerpetualContract)
if err != nil {
t.Fatal(err)
}
}
func TestUpdateTickers(t *testing.T) {
err := b.UpdateTickers(asset.Spot)
err := b.UpdateTickers(context.Background(), asset.Spot)
if err != nil {
t.Fatal(err)
}

110
exchanges/bitmex/bitmex_wrapper.go
View File

@@ -1,6 +1,7 @@
package bitmex
import (
"context"
"errors"
"fmt"
"math"
@@ -41,7 +42,7 @@ func (b *Bitmex) 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
}
@@ -209,15 +210,15 @@ func (b *Bitmex) 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", b.Name, err)
}
}
// FetchTradablePairs returns a list of the exchanges tradable pairs
func (b *Bitmex) FetchTradablePairs(asset asset.Item) ([]string, error) {
marketInfo, err := b.GetActiveAndIndexInstruments()
func (b *Bitmex) FetchTradablePairs(ctx context.Context, asset asset.Item) ([]string, error) {
marketInfo, err := b.GetActiveAndIndexInstruments(ctx)
if err != nil {
return nil, err
}
@@ -232,8 +233,8 @@ func (b *Bitmex) FetchTradablePairs(asset asset.Item) ([]string, error) {
// UpdateTradablePairs updates the exchanges available pairs and stores
// them in the exchanges config
func (b *Bitmex) UpdateTradablePairs(forceUpdate bool) error {
pairs, err := b.FetchTradablePairs(asset.Spot)
func (b *Bitmex) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
pairs, err := b.FetchTradablePairs(ctx, asset.Spot)
if err != nil {
return err
}
@@ -280,8 +281,8 @@ func (b *Bitmex) UpdateTradablePairs(forceUpdate bool) error {
}
// UpdateTickers updates the ticker for all currency pairs of a given asset type
func (b *Bitmex) UpdateTickers(a asset.Item) error {
tick, err := b.GetActiveAndIndexInstruments()
func (b *Bitmex) UpdateTickers(ctx context.Context, a asset.Item) error {
tick, err := b.GetActiveAndIndexInstruments(ctx)
if err != nil {
return err
}
@@ -316,8 +317,8 @@ func (b *Bitmex) UpdateTickers(a asset.Item) error {
}
// UpdateTicker updates and returns the ticker for a currency pair
func (b *Bitmex) UpdateTicker(p currency.Pair, a asset.Item) (*ticker.Price, error) {
err := b.UpdateTickers(a)
func (b *Bitmex) UpdateTicker(ctx context.Context, p currency.Pair, a asset.Item) (*ticker.Price, error) {
err := b.UpdateTickers(ctx, a)
if err != nil {
return nil, err
}
@@ -331,7 +332,7 @@ func (b *Bitmex) UpdateTicker(p currency.Pair, a asset.Item) (*ticker.Price, err
}
// FetchTicker returns the ticker for a currency pair
func (b *Bitmex) FetchTicker(p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
func (b *Bitmex) FetchTicker(ctx context.Context, p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
fPair, err := b.FormatExchangeCurrency(p, assetType)
if err != nil {
return nil, err
@@ -339,13 +340,13 @@ func (b *Bitmex) FetchTicker(p currency.Pair, assetType asset.Item) (*ticker.Pri
tickerNew, err := ticker.GetTicker(b.Name, fPair, assetType)
if err != nil {
return b.UpdateTicker(fPair, assetType)
return b.UpdateTicker(ctx, fPair, assetType)
}
return tickerNew, nil
}
// FetchOrderbook returns orderbook base on the currency pair
func (b *Bitmex) FetchOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
func (b *Bitmex) FetchOrderbook(ctx context.Context, p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
fPair, err := b.FormatExchangeCurrency(p, assetType)
if err != nil {
return nil, err
@@ -353,13 +354,13 @@ func (b *Bitmex) FetchOrderbook(p currency.Pair, assetType asset.Item) (*orderbo
ob, err := orderbook.Get(b.Name, fPair, assetType)
if err != nil {
return b.UpdateOrderbook(fPair, assetType)
return b.UpdateOrderbook(ctx, fPair, assetType)
}
return ob, nil
}
// UpdateOrderbook updates and returns the orderbook for a currency pair
func (b *Bitmex) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
func (b *Bitmex) UpdateOrderbook(ctx context.Context, p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
book := &orderbook.Base{
Exchange: b.Name,
Pair: p,
@@ -376,9 +377,10 @@ func (b *Bitmex) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orderb
return book, err
}
orderbookNew, err := b.GetOrderbook(OrderBookGetL2Params{
Symbol: fpair.String(),
Depth: 500})
orderbookNew, err := b.GetOrderbook(ctx,
OrderBookGetL2Params{
Symbol: fpair.String(),
Depth: 500})
if err != nil {
return book, err
}
@@ -410,10 +412,10 @@ func (b *Bitmex) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orderb
// UpdateAccountInfo retrieves balances for all enabled currencies for the
// Bitmex exchange
func (b *Bitmex) UpdateAccountInfo(assetType asset.Item) (account.Holdings, error) {
func (b *Bitmex) UpdateAccountInfo(ctx context.Context, assetType asset.Item) (account.Holdings, error) {
var info account.Holdings
bal, err := b.GetAllUserMargin()
bal, err := b.GetAllUserMargin(ctx)
if err != nil {
return info, err
}
@@ -441,10 +443,10 @@ func (b *Bitmex) UpdateAccountInfo(assetType asset.Item) (account.Holdings, erro
}
// FetchAccountInfo retrieves balances for all enabled currencies
func (b *Bitmex) FetchAccountInfo(assetType asset.Item) (account.Holdings, error) {
func (b *Bitmex) FetchAccountInfo(ctx context.Context, assetType asset.Item) (account.Holdings, error) {
acc, err := account.GetHoldings(b.Name, assetType)
if err != nil {
return b.UpdateAccountInfo(assetType)
return b.UpdateAccountInfo(ctx, assetType)
}
return acc, nil
@@ -452,22 +454,22 @@ func (b *Bitmex) FetchAccountInfo(assetType asset.Item) (account.Holdings, error
// GetFundingHistory returns funding history, deposits and
// withdrawals
func (b *Bitmex) GetFundingHistory() ([]exchange.FundHistory, error) {
func (b *Bitmex) GetFundingHistory(ctx context.Context) ([]exchange.FundHistory, error) {
return nil, common.ErrNotYetImplemented
}
// GetWithdrawalsHistory returns previous withdrawals data
func (b *Bitmex) GetWithdrawalsHistory(c currency.Code) (resp []exchange.WithdrawalHistory, err error) {
func (b *Bitmex) 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 *Bitmex) GetRecentTrades(p currency.Pair, assetType asset.Item) ([]trade.Data, error) {
return b.GetHistoricTrades(p, assetType, time.Now().Add(-time.Minute*15), time.Now())
func (b *Bitmex) GetRecentTrades(ctx context.Context, p currency.Pair, assetType asset.Item) ([]trade.Data, error) {
return b.GetHistoricTrades(ctx, p, assetType, time.Now().Add(-time.Minute*15), time.Now())
}
// GetHistoricTrades returns historic trade data within the timeframe provided
func (b *Bitmex) GetHistoricTrades(p currency.Pair, assetType asset.Item, timestampStart, timestampEnd time.Time) ([]trade.Data, error) {
func (b *Bitmex) GetHistoricTrades(ctx context.Context, p currency.Pair, assetType asset.Item, timestampStart, timestampEnd time.Time) ([]trade.Data, error) {
if assetType == asset.Index {
return nil, fmt.Errorf("asset type '%v' not supported", assetType)
}
@@ -491,7 +493,7 @@ allTrades:
for {
req.StartTime = ts.UTC().Format("2006-01-02T15:04:05.000Z")
var tradeData []Trade
tradeData, err = b.GetTrade(req)
tradeData, err = b.GetTrade(ctx, req)
if err != nil {
return nil, err
}
@@ -541,7 +543,7 @@ allTrades:
}
// SubmitOrder submits a new order
func (b *Bitmex) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
func (b *Bitmex) SubmitOrder(ctx context.Context, s *order.Submit) (order.SubmitResponse, error) {
var submitOrderResponse order.SubmitResponse
if err := s.Validate(); err != nil {
return submitOrderResponse, err
@@ -568,7 +570,7 @@ func (b *Bitmex) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
orderNewParams.Price = s.Price
}
response, err := b.CreateOrder(&orderNewParams)
response, err := b.CreateOrder(ctx, &orderNewParams)
if err != nil {
return submitOrderResponse, err
}
@@ -585,7 +587,7 @@ func (b *Bitmex) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
// ModifyOrder will allow of changing orderbook placement and limit to
// market conversion
func (b *Bitmex) ModifyOrder(action *order.Modify) (order.Modify, error) {
func (b *Bitmex) ModifyOrder(ctx context.Context, action *order.Modify) (order.Modify, error) {
if err := action.Validate(); err != nil {
return order.Modify{}, err
}
@@ -600,7 +602,7 @@ func (b *Bitmex) ModifyOrder(action *order.Modify) (order.Modify, error) {
params.OrderQty = int32(action.Amount)
params.Price = action.Price
o, err := b.AmendOrder(&params)
o, err := b.AmendOrder(ctx, &params)
if err != nil {
return order.Modify{}, err
}
@@ -617,29 +619,29 @@ func (b *Bitmex) ModifyOrder(action *order.Modify) (order.Modify, error) {
}
// CancelOrder cancels an order by its corresponding ID number
func (b *Bitmex) CancelOrder(o *order.Cancel) error {
func (b *Bitmex) CancelOrder(ctx context.Context, o *order.Cancel) error {
if err := o.Validate(o.StandardCancel()); err != nil {
return err
}
var params = OrderCancelParams{
OrderID: o.ID,
}
_, err := b.CancelOrders(&params)
_, err := b.CancelOrders(ctx, &params)
return err
}
// CancelBatchOrders cancels an orders by their corresponding ID numbers
func (b *Bitmex) CancelBatchOrders(o []order.Cancel) (order.CancelBatchResponse, error) {
func (b *Bitmex) 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 (b *Bitmex) CancelAllOrders(_ *order.Cancel) (order.CancelAllResponse, error) {
func (b *Bitmex) CancelAllOrders(ctx context.Context, _ *order.Cancel) (order.CancelAllResponse, error) {
cancelAllOrdersResponse := order.CancelAllResponse{
Status: make(map[string]string),
}
var emptyParams OrderCancelAllParams
orders, err := b.CancelAllExistingOrders(emptyParams)
orders, err := b.CancelAllExistingOrders(ctx, emptyParams)
if err != nil {
return cancelAllOrdersResponse, err
}
@@ -654,19 +656,19 @@ func (b *Bitmex) CancelAllOrders(_ *order.Cancel) (order.CancelAllResponse, erro
}
// GetOrderInfo returns order information based on order ID
func (b *Bitmex) GetOrderInfo(orderID string, pair currency.Pair, assetType asset.Item) (order.Detail, error) {
func (b *Bitmex) GetOrderInfo(ctx context.Context, orderID string, pair currency.Pair, assetType asset.Item) (order.Detail, error) {
var orderDetail order.Detail
return orderDetail, common.ErrNotYetImplemented
}
// GetDepositAddress returns a deposit address for a specified currency
func (b *Bitmex) GetDepositAddress(cryptocurrency currency.Code, _ string) (string, error) {
return b.GetCryptoDepositAddress(cryptocurrency.String())
func (b *Bitmex) GetDepositAddress(ctx context.Context, cryptocurrency currency.Code, _ string) (string, error) {
return b.GetCryptoDepositAddress(ctx, cryptocurrency.String())
}
// WithdrawCryptocurrencyFunds returns a withdrawal ID when a withdrawal is
// submitted
func (b *Bitmex) WithdrawCryptocurrencyFunds(withdrawRequest *withdraw.Request) (*withdraw.ExchangeResponse, error) {
func (b *Bitmex) WithdrawCryptocurrencyFunds(ctx context.Context, withdrawRequest *withdraw.Request) (*withdraw.ExchangeResponse, error) {
if err := withdrawRequest.Validate(); err != nil {
return nil, err
}
@@ -680,7 +682,7 @@ func (b *Bitmex) WithdrawCryptocurrencyFunds(withdrawRequest *withdraw.Request)
r.Fee = withdrawRequest.Crypto.FeeAmount
}
resp, err := b.UserRequestWithdrawal(r)
resp, err := b.UserRequestWithdrawal(ctx, r)
if err != nil {
return nil, err
}
@@ -693,18 +695,18 @@ func (b *Bitmex) WithdrawCryptocurrencyFunds(withdrawRequest *withdraw.Request)
// WithdrawFiatFunds returns a withdrawal ID when a withdrawal is
// submitted
func (b *Bitmex) WithdrawFiatFunds(_ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
func (b *Bitmex) WithdrawFiatFunds(_ context.Context, _ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
return nil, common.ErrFunctionNotSupported
}
// WithdrawFiatFundsToInternationalBank returns a withdrawal ID when a withdrawal is
// submitted
func (b *Bitmex) WithdrawFiatFundsToInternationalBank(_ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
func (b *Bitmex) WithdrawFiatFundsToInternationalBank(_ context.Context, _ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
return nil, common.ErrFunctionNotSupported
}
// GetFeeByType returns an estimate of fee based on type of transaction
func (b *Bitmex) GetFeeByType(feeBuilder *exchange.FeeBuilder) (float64, error) {
func (b *Bitmex) GetFeeByType(ctx context.Context, feeBuilder *exchange.FeeBuilder) (float64, error) {
if !b.AllowAuthenticatedRequest() && // Todo check connection status
feeBuilder.FeeType == exchange.CryptocurrencyTradeFee {
feeBuilder.FeeType = exchange.OfflineTradeFee
@@ -714,7 +716,7 @@ func (b *Bitmex) GetFeeByType(feeBuilder *exchange.FeeBuilder) (float64, error)
// GetActiveOrders retrieves any orders that are active/open
// This function is not concurrency safe due to orderSide/orderType maps
func (b *Bitmex) GetActiveOrders(req *order.GetOrdersRequest) ([]order.Detail, error) {
func (b *Bitmex) GetActiveOrders(ctx context.Context, req *order.GetOrdersRequest) ([]order.Detail, error) {
if err := req.Validate(); err != nil {
return nil, err
}
@@ -723,7 +725,7 @@ func (b *Bitmex) GetActiveOrders(req *order.GetOrdersRequest) ([]order.Detail, e
params := OrdersRequest{}
params.Filter = "{\"open\":true}"
resp, err := b.GetOrders(&params)
resp, err := b.GetOrders(ctx, &params)
if err != nil {
return nil, err
}
@@ -767,14 +769,14 @@ func (b *Bitmex) GetActiveOrders(req *order.GetOrdersRequest) ([]order.Detail, e
// GetOrderHistory retrieves account order information
// Can Limit response to specific order status
// This function is not concurrency safe due to orderSide/orderType maps
func (b *Bitmex) GetOrderHistory(req *order.GetOrdersRequest) ([]order.Detail, error) {
func (b *Bitmex) GetOrderHistory(ctx context.Context, req *order.GetOrdersRequest) ([]order.Detail, error) {
if err := req.Validate(); err != nil {
return nil, err
}
var orders []order.Detail
params := OrdersRequest{}
resp, err := b.GetOrders(&params)
resp, err := b.GetOrders(ctx, &params)
if err != nil {
return nil, err
}
@@ -815,23 +817,23 @@ func (b *Bitmex) GetOrderHistory(req *order.GetOrdersRequest) ([]order.Detail, e
}
// AuthenticateWebsocket sends an authentication message to the websocket
func (b *Bitmex) AuthenticateWebsocket() error {
func (b *Bitmex) AuthenticateWebsocket(_ context.Context) error {
return b.websocketSendAuth()
}
// ValidateCredentials validates current credentials used for wrapper
// functionality
func (b *Bitmex) ValidateCredentials(assetType asset.Item) error {
_, err := b.UpdateAccountInfo(assetType)
func (b *Bitmex) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
_, err := b.UpdateAccountInfo(ctx, assetType)
return b.CheckTransientError(err)
}
// GetHistoricCandles returns candles between a time period for a set time interval
func (b *Bitmex) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
func (b *Bitmex) GetHistoricCandles(ctx context.Context, pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
return kline.Item{}, common.ErrFunctionNotSupported
}
// GetHistoricCandlesExtended returns candles between a time period for a set time interval
func (b *Bitmex) GetHistoricCandlesExtended(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
func (b *Bitmex) GetHistoricCandlesExtended(ctx context.Context, pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
return kline.Item{}, common.ErrFunctionNotSupported
}