add
This commit is contained in:
lz_db
917
ccxt/pro/whitebit.py
Normal file
917
ccxt/pro/whitebit.py
Normal file
@@ -0,0 +1,917 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
|
||||
# https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
|
||||
|
||||
import ccxt.async_support
|
||||
from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
|
||||
from ccxt.base.types import Any, Balances, Bool, Int, Order, OrderBook, Str, Strings, Ticker, Tickers, Trade
|
||||
from ccxt.async_support.base.ws.client import Client
|
||||
from typing import List
|
||||
from ccxt.base.errors import AuthenticationError
|
||||
from ccxt.base.errors import ArgumentsRequired
|
||||
from ccxt.base.errors import BadRequest
|
||||
from ccxt.base.precise import Precise
|
||||
|
||||
|
||||
class whitebit(ccxt.async_support.whitebit):
|
||||
|
||||
def describe(self) -> Any:
|
||||
return self.deep_extend(super(whitebit, self).describe(), {
|
||||
'has': {
|
||||
'ws': True,
|
||||
'watchBalance': True,
|
||||
'watchMyTrades': True,
|
||||
'watchOHLCV': True,
|
||||
'watchOrderBook': True,
|
||||
'watchOrders': True,
|
||||
'watchTicker': True,
|
||||
'watchTickers': True,
|
||||
'watchTrades': True,
|
||||
'watchTradesForSymbols': False,
|
||||
},
|
||||
'urls': {
|
||||
'api': {
|
||||
'ws': 'wss://api.whitebit.com/ws',
|
||||
},
|
||||
},
|
||||
'options': {
|
||||
'timeframes': {
|
||||
'1m': '60',
|
||||
'5m': '300',
|
||||
'15m': '900',
|
||||
'30m': '1800',
|
||||
'1h': '3600',
|
||||
'4h': '14400',
|
||||
'8h': '28800',
|
||||
'1d': '86400',
|
||||
'1w': '604800',
|
||||
},
|
||||
'watchOrderBook': {
|
||||
'priceInterval': 0, # "0" - no interval, available values - "0.00000001", "0.0000001", "0.000001", "0.00001", "0.0001", "0.001", "0.01", "0.1"
|
||||
},
|
||||
},
|
||||
'streaming': {
|
||||
'ping': self.ping,
|
||||
},
|
||||
'exceptions': {
|
||||
'ws': {
|
||||
'exact': {
|
||||
'1': BadRequest, # {error: {code: 1, message: 'invalid argument'}, result: null, id: 1656404342}
|
||||
'2': BadRequest, # {error: {code: 2, message: 'internal error'}, result: null, id: 1656404075}
|
||||
'4': BadRequest, # {error: {code: 4, message: 'method not found'}, result: null, id: 1656404250}
|
||||
'6': AuthenticationError, # {error: {code: 6, message: 'require authentication'}, result: null, id: 1656404076}
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
async def watch_ohlcv(self, symbol: str, timeframe: str = '1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
|
||||
"""
|
||||
watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
|
||||
|
||||
https://docs.whitebit.com/public/websocket/#kline
|
||||
|
||||
:param str symbol: unified symbol of the market to fetch OHLCV data for
|
||||
:param str timeframe: the length of time each candle represents
|
||||
:param int [since]: timestamp in ms of the earliest candle to fetch
|
||||
:param int [limit]: the maximum amount of candles to fetch
|
||||
:param dict [params]: extra parameters specific to the exchange API endpoint
|
||||
:returns int[][]: A list of candles ordered, open, high, low, close, volume
|
||||
"""
|
||||
await self.load_markets()
|
||||
market = self.market(symbol)
|
||||
symbol = market['symbol']
|
||||
timeframes = self.safe_value(self.options, 'timeframes', {})
|
||||
interval = self.safe_integer(timeframes, timeframe)
|
||||
marketId = market['id']
|
||||
# currently there is no way of knowing
|
||||
# the interval upon getting an update
|
||||
# so that can't be part of the message hash, and the user can only subscribe
|
||||
# to one timeframe per symbol
|
||||
messageHash = 'candles:' + symbol
|
||||
reqParams = [marketId, interval]
|
||||
method = 'candles_subscribe'
|
||||
ohlcv = await self.watch_public(messageHash, method, reqParams, params)
|
||||
if self.newUpdates:
|
||||
limit = ohlcv.getLimit(symbol, limit)
|
||||
return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
|
||||
|
||||
def handle_ohlcv(self, client: Client, message):
|
||||
#
|
||||
# {
|
||||
# "method": "candles_update",
|
||||
# "params": [
|
||||
# [
|
||||
# 1655204760,
|
||||
# "22374.15",
|
||||
# "22351.34",
|
||||
# "22374.27",
|
||||
# "22342.52",
|
||||
# "30.213426",
|
||||
# "675499.29718947",
|
||||
# "BTC_USDT"
|
||||
# ]
|
||||
# ],
|
||||
# "id": null
|
||||
# }
|
||||
#
|
||||
params = self.safe_value(message, 'params', [])
|
||||
for i in range(0, len(params)):
|
||||
data = params[i]
|
||||
marketId = self.safe_string(data, 7)
|
||||
market = self.safe_market(marketId)
|
||||
symbol = market['symbol']
|
||||
messageHash = 'candles' + ':' + symbol
|
||||
parsed = self.parse_ohlcv(data, market)
|
||||
# self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol)
|
||||
if not (symbol in self.ohlcvs):
|
||||
self.ohlcvs[symbol] = {}
|
||||
# stored = self.ohlcvs[symbol]['unknown'] # we don't know the timeframe but we need to respect the type
|
||||
if not ('unknown' in self.ohlcvs[symbol]):
|
||||
limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
|
||||
stored = ArrayCacheByTimestamp(limit)
|
||||
self.ohlcvs[symbol]['unknown'] = stored
|
||||
ohlcv = self.ohlcvs[symbol]['unknown']
|
||||
ohlcv.append(parsed)
|
||||
client.resolve(ohlcv, messageHash)
|
||||
return message
|
||||
|
||||
async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
|
||||
"""
|
||||
watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
|
||||
|
||||
https://docs.whitebit.com/public/websocket/#market-depth
|
||||
|
||||
:param str symbol: unified symbol of the market to fetch the order book for
|
||||
:param int [limit]: the maximum amount of order book entries to return
|
||||
:param dict [params]: extra parameters specific to the exchange API endpoint
|
||||
:returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
|
||||
"""
|
||||
await self.load_markets()
|
||||
market = self.market(symbol)
|
||||
if limit is None:
|
||||
limit = 10 # max 100
|
||||
messageHash = 'orderbook' + ':' + market['symbol']
|
||||
method = 'depth_subscribe'
|
||||
options = self.safe_value(self.options, 'watchOrderBook', {})
|
||||
defaultPriceInterval = self.safe_string(options, 'priceInterval', '0')
|
||||
priceInterval = self.safe_string(params, 'priceInterval', defaultPriceInterval)
|
||||
params = self.omit(params, 'priceInterval')
|
||||
reqParams = [
|
||||
market['id'],
|
||||
limit,
|
||||
priceInterval,
|
||||
True, # True for allowing multiple subscriptions
|
||||
]
|
||||
orderbook = await self.watch_public(messageHash, method, reqParams, params)
|
||||
return orderbook.limit()
|
||||
|
||||
def handle_order_book(self, client: Client, message):
|
||||
#
|
||||
# {
|
||||
# "method":"depth_update",
|
||||
# "params":[
|
||||
# True,
|
||||
# {
|
||||
# "timestamp": 1708679568.940867,
|
||||
# "asks":[
|
||||
# ["21252.45","0.01957"],
|
||||
# ["21252.55","0.126205"],
|
||||
# ["21252.66","0.222689"],
|
||||
# ["21252.76","0.185358"],
|
||||
# ["21252.87","0.210077"],
|
||||
# ["21252.98","0.303991"],
|
||||
# ["21253.08","0.327909"],
|
||||
# ["21253.19","0.399007"],
|
||||
# ["21253.3","0.427695"],
|
||||
# ["21253.4","0.492901"]
|
||||
# ],
|
||||
# "bids":[
|
||||
# ["21248.82","0.22"],
|
||||
# ["21248.73","0.000467"],
|
||||
# ["21248.62","0.100864"],
|
||||
# ["21248.51","0.061436"],
|
||||
# ["21248.42","0.091"],
|
||||
# ["21248.41","0.126839"],
|
||||
# ["21248.3","0.063511"],
|
||||
# ["21248.2","0.110547"],
|
||||
# ["21248","0.25257"],
|
||||
# ["21247.7","1.71813"]
|
||||
# ]
|
||||
# },
|
||||
# "BTC_USDT"
|
||||
# ],
|
||||
# "id":null
|
||||
# }
|
||||
#
|
||||
params = self.safe_value(message, 'params', [])
|
||||
isSnapshot = self.safe_value(params, 0)
|
||||
marketId = self.safe_string(params, 2)
|
||||
market = self.safe_market(marketId)
|
||||
symbol = market['symbol']
|
||||
data = self.safe_value(params, 1)
|
||||
timestamp = self.safe_timestamp(data, 'timestamp')
|
||||
if not (symbol in self.orderbooks):
|
||||
ob = self.order_book()
|
||||
self.orderbooks[symbol] = ob
|
||||
orderbook = self.orderbooks[symbol]
|
||||
orderbook['timestamp'] = timestamp
|
||||
orderbook['datetime'] = self.iso8601(timestamp)
|
||||
if isSnapshot:
|
||||
snapshot = self.parse_order_book(data, symbol)
|
||||
orderbook.reset(snapshot)
|
||||
else:
|
||||
asks = self.safe_value(data, 'asks', [])
|
||||
bids = self.safe_value(data, 'bids', [])
|
||||
self.handle_deltas(orderbook['asks'], asks)
|
||||
self.handle_deltas(orderbook['bids'], bids)
|
||||
messageHash = 'orderbook' + ':' + symbol
|
||||
client.resolve(orderbook, messageHash)
|
||||
|
||||
def handle_delta(self, bookside, delta):
|
||||
price = self.safe_float(delta, 0)
|
||||
amount = self.safe_float(delta, 1)
|
||||
bookside.store(price, amount)
|
||||
|
||||
def handle_deltas(self, bookside, deltas):
|
||||
for i in range(0, len(deltas)):
|
||||
self.handle_delta(bookside, deltas[i])
|
||||
|
||||
async def watch_ticker(self, symbol: str, params={}) -> Ticker:
|
||||
"""
|
||||
watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
|
||||
|
||||
https://docs.whitebit.com/public/websocket/#market-statistics
|
||||
|
||||
:param str symbol: unified symbol of the market to fetch the ticker for
|
||||
:param dict [params]: extra parameters specific to the exchange API endpoint
|
||||
:returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
|
||||
"""
|
||||
await self.load_markets()
|
||||
market = self.market(symbol)
|
||||
symbol = market['symbol']
|
||||
method = 'market_subscribe'
|
||||
messageHash = 'ticker:' + symbol
|
||||
# every time we want to subscribe to another market we have to "re-subscribe" sending it all again
|
||||
return await self.watch_multiple_subscription(messageHash, method, symbol, False, params)
|
||||
|
||||
async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
|
||||
"""
|
||||
watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
|
||||
|
||||
https://docs.whitebit.com/public/websocket/#market-statistics
|
||||
|
||||
:param str[] [symbols]: unified symbol of the market to fetch the ticker for
|
||||
:param dict [params]: extra parameters specific to the exchange API endpoint
|
||||
:returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
|
||||
"""
|
||||
await self.load_markets()
|
||||
symbols = self.market_symbols(symbols, None, False)
|
||||
method = 'market_subscribe'
|
||||
url = self.urls['api']['ws']
|
||||
id = self.nonce()
|
||||
messageHashes = []
|
||||
args = []
|
||||
for i in range(0, len(symbols)):
|
||||
market = self.market(symbols[i])
|
||||
messageHashes.append('ticker:' + market['symbol'])
|
||||
args.append(market['id'])
|
||||
request: dict = {
|
||||
'id': id,
|
||||
'method': method,
|
||||
'params': args,
|
||||
}
|
||||
await self.watch_multiple(url, messageHashes, self.extend(request, params), messageHashes)
|
||||
return self.filter_by_array(self.tickers, 'symbol', symbols)
|
||||
|
||||
def handle_ticker(self, client: Client, message):
|
||||
#
|
||||
# {
|
||||
# "method": "market_update",
|
||||
# "params": [
|
||||
# "BTC_USDT",
|
||||
# {
|
||||
# "close": "22293.86",
|
||||
# "deal": "1986990019.96552952",
|
||||
# "high": "24360.7",
|
||||
# "last": "22293.86",
|
||||
# "low": "20851.44",
|
||||
# "open": "24076.12",
|
||||
# "period": 86400,
|
||||
# "volume": "87016.995668"
|
||||
# }
|
||||
# ],
|
||||
# "id": null
|
||||
# }
|
||||
#
|
||||
tickers = self.safe_value(message, 'params', [])
|
||||
marketId = self.safe_string(tickers, 0)
|
||||
market = self.safe_market(marketId, None)
|
||||
symbol = market['symbol']
|
||||
rawTicker = self.safe_value(tickers, 1, {})
|
||||
messageHash = 'ticker' + ':' + symbol
|
||||
ticker = self.parse_ticker(rawTicker, market)
|
||||
self.tickers[symbol] = ticker
|
||||
# watchTicker
|
||||
client.resolve(ticker, messageHash)
|
||||
# watchTickers
|
||||
messageHashes = list(client.futures.keys())
|
||||
for i in range(0, len(messageHashes)):
|
||||
currentMessageHash = messageHashes[i]
|
||||
if currentMessageHash.find('tickers') >= 0 and currentMessageHash.find(symbol) >= 0:
|
||||
# Example: user calls watchTickers with ['LTC/USDT', 'ETH/USDT']
|
||||
# the associated messagehash will be: 'tickers:LTC/USDT:ETH/USDT'
|
||||
# since we only have access to a single symbol at a time
|
||||
# we have to do a reverse lookup into the tickers hashes
|
||||
# and check if the current symbol is a part of one or more
|
||||
# tickers hashes and resolve them
|
||||
# user might have multiple watchTickers promises
|
||||
# watchTickers( ['LTC/USDT', 'ETH/USDT'] ), watchTickers( ['ETC/USDT', 'DOGE/USDT'] )
|
||||
# and we want to make sure we resolve only the correct ones
|
||||
client.resolve(ticker, currentMessageHash)
|
||||
return message
|
||||
|
||||
async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
|
||||
"""
|
||||
get the list of most recent trades for a particular symbol
|
||||
|
||||
https://docs.whitebit.com/public/websocket/#market-trades
|
||||
|
||||
:param str symbol: unified symbol of the market to fetch trades for
|
||||
:param int [since]: timestamp in ms of the earliest trade to fetch
|
||||
:param int [limit]: the maximum amount of trades to fetch
|
||||
:param dict [params]: extra parameters specific to the exchange API endpoint
|
||||
:returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
|
||||
"""
|
||||
await self.load_markets()
|
||||
market = self.market(symbol)
|
||||
symbol = market['symbol']
|
||||
messageHash = 'trades' + ':' + symbol
|
||||
method = 'trades_subscribe'
|
||||
# every time we want to subscribe to another market we have to 're-subscribe' sending it all again
|
||||
trades = await self.watch_multiple_subscription(messageHash, method, symbol, False, params)
|
||||
if self.newUpdates:
|
||||
limit = trades.getLimit(symbol, limit)
|
||||
return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
|
||||
|
||||
def handle_trades(self, client: Client, message):
|
||||
#
|
||||
# {
|
||||
# "method":"trades_update",
|
||||
# "params":[
|
||||
# "BTC_USDT",
|
||||
# [
|
||||
# {
|
||||
# "id":1900632398,
|
||||
# "time":1656320231.404343,
|
||||
# "price":"21443.04",
|
||||
# "amount":"0.072844",
|
||||
# "type":"buy"
|
||||
# },
|
||||
# {
|
||||
# "id":1900632397,
|
||||
# "time":1656320231.400001,
|
||||
# "price":"21443.15",
|
||||
# "amount":"0.060757",
|
||||
# "type":"buy"
|
||||
# }
|
||||
# ]
|
||||
# ]
|
||||
# }
|
||||
#
|
||||
params = self.safe_value(message, 'params', [])
|
||||
marketId = self.safe_string(params, 0)
|
||||
market = self.safe_market(marketId)
|
||||
symbol = market['symbol']
|
||||
stored = self.safe_value(self.trades, symbol)
|
||||
if stored is None:
|
||||
limit = self.safe_integer(self.options, 'tradesLimit', 1000)
|
||||
stored = ArrayCache(limit)
|
||||
self.trades[symbol] = stored
|
||||
data = self.safe_value(params, 1, [])
|
||||
parsedTrades = self.parse_trades(data, market)
|
||||
for j in range(0, len(parsedTrades)):
|
||||
stored.append(parsedTrades[j])
|
||||
messageHash = 'trades:' + market['symbol']
|
||||
client.resolve(stored, messageHash)
|
||||
|
||||
async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
|
||||
"""
|
||||
watches trades made by the user
|
||||
|
||||
https://docs.whitebit.com/private/websocket/#deals
|
||||
|
||||
:param str symbol: unified market symbol
|
||||
:param int [since]: the earliest time in ms to fetch trades for
|
||||
:param int [limit]: the maximum number of trades structures to retrieve
|
||||
:param dict [params]: extra parameters specific to the exchange API endpoint
|
||||
:returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
|
||||
"""
|
||||
if symbol is None:
|
||||
raise ArgumentsRequired(self.id + ' watchMyTrades() requires a symbol argument')
|
||||
await self.load_markets()
|
||||
await self.authenticate()
|
||||
market = self.market(symbol)
|
||||
symbol = market['symbol']
|
||||
messageHash = 'myTrades:' + symbol
|
||||
method = 'deals_subscribe'
|
||||
trades = await self.watch_multiple_subscription(messageHash, method, symbol, True, params)
|
||||
if self.newUpdates:
|
||||
limit = trades.getLimit(symbol, limit)
|
||||
return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
|
||||
|
||||
def handle_my_trades(self, client: Client, message, subscription=None):
|
||||
#
|
||||
# {
|
||||
# "method": "deals_update",
|
||||
# "params": [
|
||||
# 1894994106,
|
||||
# 1656151427.729706,
|
||||
# "LTC_USDT",
|
||||
# 96624037337,
|
||||
# "56.78",
|
||||
# "0.16717",
|
||||
# "0.0094919126",
|
||||
# ''
|
||||
# ],
|
||||
# "id": null
|
||||
# }
|
||||
#
|
||||
trade = self.safe_value(message, 'params')
|
||||
if self.myTrades is None:
|
||||
limit = self.safe_integer(self.options, 'tradesLimit', 1000)
|
||||
self.myTrades = ArrayCache(limit)
|
||||
stored = self.myTrades
|
||||
parsed = self.parse_ws_trade(trade)
|
||||
stored.append(parsed)
|
||||
symbol = parsed['symbol']
|
||||
messageHash = 'myTrades:' + symbol
|
||||
client.resolve(stored, messageHash)
|
||||
|
||||
def parse_ws_trade(self, trade, market=None):
|
||||
#
|
||||
# [
|
||||
# 1894994106, # id
|
||||
# 1656151427.729706, # deal time
|
||||
# "LTC_USDT", # symbol
|
||||
# 96624037337, # order id
|
||||
# "56.78", # price
|
||||
# "0.16717", # amount
|
||||
# "0.0094919126", # fee
|
||||
# '' # client order id
|
||||
# ]
|
||||
#
|
||||
orderId = self.safe_string(trade, 3)
|
||||
timestamp = self.safe_timestamp(trade, 1)
|
||||
id = self.safe_string(trade, 0)
|
||||
price = self.safe_string(trade, 4)
|
||||
amount = self.safe_string(trade, 5)
|
||||
marketId = self.safe_string(trade, 2)
|
||||
market = self.safe_market(marketId, market)
|
||||
fee = None
|
||||
feeCost = self.safe_string(trade, 6)
|
||||
if feeCost is not None:
|
||||
fee = {
|
||||
'cost': feeCost,
|
||||
'currency': market['quote'],
|
||||
}
|
||||
return self.safe_trade({
|
||||
'id': id,
|
||||
'info': trade,
|
||||
'timestamp': timestamp,
|
||||
'datetime': self.iso8601(timestamp),
|
||||
'symbol': market['symbol'],
|
||||
'order': orderId,
|
||||
'type': None,
|
||||
'side': None,
|
||||
'takerOrMaker': None,
|
||||
'price': price,
|
||||
'amount': amount,
|
||||
'cost': None,
|
||||
'fee': fee,
|
||||
}, market)
|
||||
|
||||
async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
|
||||
"""
|
||||
watches information on multiple orders made by the user
|
||||
|
||||
https://docs.whitebit.com/private/websocket/#orders-pending
|
||||
|
||||
:param str symbol: unified market symbol of the market orders were made in
|
||||
:param int [since]: the earliest time in ms to fetch orders for
|
||||
:param int [limit]: the maximum number of order structures to retrieve
|
||||
:param dict [params]: extra parameters specific to the exchange API endpoint
|
||||
:returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
|
||||
"""
|
||||
if symbol is None:
|
||||
raise ArgumentsRequired(self.id + ' watchOrders() requires a symbol argument')
|
||||
await self.load_markets()
|
||||
await self.authenticate()
|
||||
market = self.market(symbol)
|
||||
symbol = market['symbol']
|
||||
messageHash = 'orders:' + symbol
|
||||
method = 'ordersPending_subscribe'
|
||||
trades = await self.watch_multiple_subscription(messageHash, method, symbol, False, params)
|
||||
if self.newUpdates:
|
||||
limit = trades.getLimit(symbol, limit)
|
||||
return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
|
||||
|
||||
def handle_order(self, client: Client, message, subscription=None):
|
||||
#
|
||||
# {
|
||||
# "method": "ordersPending_update",
|
||||
# "params": [
|
||||
# 1, # 1 = new, 2 = update 3 = cancel or execute
|
||||
# {
|
||||
# "id": 96433622651,
|
||||
# "market": "LTC_USDT",
|
||||
# "type": 1,
|
||||
# "side": 2,
|
||||
# "ctime": 1656092215.39375,
|
||||
# "mtime": 1656092215.39375,
|
||||
# "price": "25",
|
||||
# "amount": "0.202",
|
||||
# "taker_fee": "0.001",
|
||||
# "maker_fee": "0.001",
|
||||
# "left": "0.202",
|
||||
# "deal_stock": "0",
|
||||
# "deal_money": "0",
|
||||
# "deal_fee": "0",
|
||||
# "client_order_id": ''
|
||||
# }
|
||||
# ]
|
||||
# "id": null
|
||||
# }
|
||||
#
|
||||
params = self.safe_value(message, 'params', [])
|
||||
data = self.safe_value(params, 1)
|
||||
if self.orders is None:
|
||||
limit = self.safe_integer(self.options, 'ordersLimit', 1000)
|
||||
self.orders = ArrayCacheBySymbolById(limit)
|
||||
stored = self.orders
|
||||
status = self.safe_integer(params, 0)
|
||||
parsed = self.parse_ws_order(self.extend(data, {'status': status}))
|
||||
stored.append(parsed)
|
||||
symbol = parsed['symbol']
|
||||
messageHash = 'orders:' + symbol
|
||||
client.resolve(self.orders, messageHash)
|
||||
|
||||
def parse_ws_order(self, order, market=None):
|
||||
#
|
||||
# {
|
||||
# "id": 96433622651,
|
||||
# "market": "LTC_USDT",
|
||||
# "type": 1,
|
||||
# "side": 2, #1- sell 2-buy
|
||||
# "ctime": 1656092215.39375,
|
||||
# "mtime": 1656092215.39375,
|
||||
# "price": "25",
|
||||
# "amount": "0.202",
|
||||
# "taker_fee": "0.001",
|
||||
# "maker_fee": "0.001",
|
||||
# "left": "0.202",
|
||||
# "deal_stock": "0",
|
||||
# "deal_money": "0",
|
||||
# "deal_fee": "0",
|
||||
# "activation_price": "40",
|
||||
# "activation_condition": "lte",
|
||||
# "client_order_id": ''
|
||||
# "status": 1, # 1 = new, 2 = update 3 = cancel or execute
|
||||
# }
|
||||
#
|
||||
status = self.safe_integer(order, 'status')
|
||||
marketId = self.safe_string(order, 'market')
|
||||
market = self.safe_market(marketId, market)
|
||||
id = self.safe_string(order, 'id')
|
||||
clientOrderId = self.omit_zero(self.safe_string(order, 'client_order_id'))
|
||||
price = self.safe_string(order, 'price')
|
||||
filled = self.safe_string(order, 'deal_stock')
|
||||
cost = self.safe_string(order, 'deal_money')
|
||||
stopPrice = self.safe_string(order, 'activation_price')
|
||||
rawType = self.safe_string(order, 'type')
|
||||
type = self.parse_ws_order_type(rawType)
|
||||
amount = None
|
||||
remaining = None
|
||||
if type == 'market':
|
||||
amount = self.safe_string(order, 'deal_stock')
|
||||
remaining = '0'
|
||||
else:
|
||||
remaining = self.safe_string(order, 'left')
|
||||
amount = self.safe_string(order, 'amount')
|
||||
timestamp = self.safe_timestamp(order, 'ctime')
|
||||
lastTradeTimestamp = self.safe_timestamp(order, 'mtime')
|
||||
symbol = market['symbol']
|
||||
rawSide = self.safe_integer(order, 'side')
|
||||
side = 'sell' if (rawSide == 1) else 'buy'
|
||||
dealFee = self.safe_string(order, 'deal_fee')
|
||||
fee = None
|
||||
if dealFee is not None:
|
||||
fee = {
|
||||
'cost': self.parse_number(dealFee),
|
||||
'currency': market['quote'],
|
||||
}
|
||||
unifiedStatus = None
|
||||
if (status == 1) or (status == 2):
|
||||
unifiedStatus = 'open'
|
||||
else:
|
||||
if Precise.string_equals(remaining, '0'):
|
||||
unifiedStatus = 'closed'
|
||||
else:
|
||||
unifiedStatus = 'canceled'
|
||||
return self.safe_order({
|
||||
'info': order,
|
||||
'symbol': symbol,
|
||||
'id': id,
|
||||
'clientOrderId': clientOrderId,
|
||||
'timestamp': timestamp,
|
||||
'datetime': self.iso8601(timestamp),
|
||||
'lastTradeTimestamp': lastTradeTimestamp,
|
||||
'type': type,
|
||||
'timeInForce': None,
|
||||
'postOnly': None,
|
||||
'side': side,
|
||||
'price': price,
|
||||
'stopPrice': stopPrice,
|
||||
'triggerPrice': stopPrice,
|
||||
'amount': amount,
|
||||
'cost': cost,
|
||||
'average': None,
|
||||
'filled': filled,
|
||||
'remaining': remaining,
|
||||
'status': unifiedStatus,
|
||||
'fee': fee,
|
||||
'trades': None,
|
||||
}, market)
|
||||
|
||||
def parse_ws_order_type(self, status):
|
||||
statuses: dict = {
|
||||
'1': 'limit',
|
||||
'2': 'market',
|
||||
'202': 'market',
|
||||
'3': 'limit',
|
||||
'4': 'market',
|
||||
'5': 'limit',
|
||||
'6': 'market',
|
||||
'8': 'limit',
|
||||
'10': 'market',
|
||||
}
|
||||
return self.safe_string(statuses, status, status)
|
||||
|
||||
async def watch_balance(self, params={}) -> Balances:
|
||||
"""
|
||||
watch balance and get the amount of funds available for trading or funds locked in orders
|
||||
|
||||
https://docs.whitebit.com/private/websocket/#balance-spot
|
||||
https://docs.whitebit.com/private/websocket/#balance-margin
|
||||
|
||||
:param dict [params]: extra parameters specific to the exchange API endpoint
|
||||
:param str [params.type]: spot or contract if not provided self.options['defaultType'] is used
|
||||
:returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
|
||||
"""
|
||||
await self.load_markets()
|
||||
type = None
|
||||
type, params = self.handle_market_type_and_params('watchBalance', None, params)
|
||||
messageHash = 'wallet:'
|
||||
method = None
|
||||
if type == 'spot':
|
||||
method = 'balanceSpot_subscribe'
|
||||
messageHash += 'spot'
|
||||
else:
|
||||
method = 'balanceMargin_subscribe'
|
||||
messageHash += 'margin'
|
||||
currencies = list(self.currencies.keys())
|
||||
return await self.watch_private(messageHash, method, currencies, params)
|
||||
|
||||
def handle_balance(self, client: Client, message):
|
||||
#
|
||||
# {
|
||||
# "method":"balanceSpot_update",
|
||||
# "params":[
|
||||
# {
|
||||
# "LTC":{
|
||||
# "available":"0.16587",
|
||||
# "freeze":"0"
|
||||
# }
|
||||
# }
|
||||
# ],
|
||||
# "id":null
|
||||
# }
|
||||
#
|
||||
method = self.safe_string(message, 'method')
|
||||
data = self.safe_value(message, 'params')
|
||||
balanceDict = self.safe_value(data, 0)
|
||||
self.balance['info'] = balanceDict
|
||||
keys = list(balanceDict.keys())
|
||||
currencyId = self.safe_value(keys, 0)
|
||||
rawBalance = self.safe_value(balanceDict, currencyId)
|
||||
code = self.safe_currency_code(currencyId)
|
||||
account = self.account()
|
||||
account['free'] = self.safe_string(rawBalance, 'available')
|
||||
account['used'] = self.safe_string(rawBalance, 'freeze')
|
||||
self.balance[code] = account
|
||||
self.balance = self.safe_balance(self.balance)
|
||||
messageHash = 'wallet:'
|
||||
if method.find('Spot') >= 0:
|
||||
messageHash += 'spot'
|
||||
else:
|
||||
messageHash += 'margin'
|
||||
client.resolve(self.balance, messageHash)
|
||||
|
||||
async def watch_public(self, messageHash, method, reqParams=[], params={}):
|
||||
url = self.urls['api']['ws']
|
||||
id = self.nonce()
|
||||
request: dict = {
|
||||
'id': id,
|
||||
'method': method,
|
||||
'params': reqParams,
|
||||
}
|
||||
message = self.extend(request, params)
|
||||
return await self.watch(url, messageHash, message, messageHash)
|
||||
|
||||
async def watch_multiple_subscription(self, messageHash, method, symbol, isNested=False, params={}):
|
||||
await self.load_markets()
|
||||
url = self.urls['api']['ws']
|
||||
id = self.nonce()
|
||||
client = self.safe_value(self.clients, url)
|
||||
request = None
|
||||
marketIds = []
|
||||
if client is None:
|
||||
subscription: dict = {}
|
||||
market = self.market(symbol)
|
||||
marketId = market['id']
|
||||
subscription[marketId] = True
|
||||
marketIds = [marketId]
|
||||
if isNested:
|
||||
marketIds = [marketIds]
|
||||
request = {
|
||||
'id': id,
|
||||
'method': method,
|
||||
'params': marketIds,
|
||||
}
|
||||
message = self.extend(request, params)
|
||||
return await self.watch(url, messageHash, message, method, subscription)
|
||||
else:
|
||||
subscription = self.safe_value(client.subscriptions, method, {})
|
||||
hasSymbolSubscription = True
|
||||
market = self.market(symbol)
|
||||
marketId = market['id']
|
||||
isSubscribed = self.safe_bool(subscription, marketId, False)
|
||||
if not isSubscribed:
|
||||
subscription[marketId] = True
|
||||
hasSymbolSubscription = False
|
||||
if hasSymbolSubscription:
|
||||
# already subscribed to self market(s)
|
||||
return await self.watch(url, messageHash, request, method, subscription)
|
||||
else:
|
||||
# resubscribe
|
||||
marketIdsNew = []
|
||||
marketIdsNew = list(subscription.keys())
|
||||
if isNested:
|
||||
marketIdsNew = [marketIdsNew]
|
||||
resubRequest: dict = {
|
||||
'id': id,
|
||||
'method': method,
|
||||
'params': marketIdsNew,
|
||||
}
|
||||
if method in client.subscriptions:
|
||||
del client.subscriptions[method]
|
||||
return await self.watch(url, messageHash, resubRequest, method, subscription)
|
||||
|
||||
async def watch_private(self, messageHash, method, reqParams=[], params={}):
|
||||
self.check_required_credentials()
|
||||
await self.authenticate()
|
||||
url = self.urls['api']['ws']
|
||||
id = self.nonce()
|
||||
request: dict = {
|
||||
'id': id,
|
||||
'method': method,
|
||||
'params': reqParams,
|
||||
}
|
||||
message = self.extend(request, params)
|
||||
return await self.watch(url, messageHash, message, messageHash)
|
||||
|
||||
async def authenticate(self, params={}):
|
||||
self.check_required_credentials()
|
||||
url = self.urls['api']['ws']
|
||||
messageHash = 'authenticated'
|
||||
client = self.client(url)
|
||||
future = client.reusableFuture('authenticated')
|
||||
authenticated = self.safe_value(client.subscriptions, messageHash)
|
||||
if authenticated is None:
|
||||
authToken = await self.v4PrivatePostProfileWebsocketToken()
|
||||
#
|
||||
# {
|
||||
# "websocket_token": "$2y$10$lxCvTXig/XrcTBFY1bdFseCKQmFTDtCpEzHNVnXowGplExFxPJp9y"
|
||||
# }
|
||||
#
|
||||
token = self.safe_string(authToken, 'websocket_token')
|
||||
id = self.nonce()
|
||||
request: dict = {
|
||||
'id': id,
|
||||
'method': 'authorize',
|
||||
'params': [
|
||||
token,
|
||||
'public',
|
||||
],
|
||||
}
|
||||
subscription: dict = {
|
||||
'id': id,
|
||||
'method': self.handle_authenticate,
|
||||
}
|
||||
try:
|
||||
await self.watch(url, messageHash, request, messageHash, subscription)
|
||||
except Exception as e:
|
||||
del client.subscriptions[messageHash]
|
||||
future.reject(e)
|
||||
return await future
|
||||
|
||||
def handle_authenticate(self, client: Client, message):
|
||||
#
|
||||
# {error: null, result: {status: "success"}, id: 1656084550}
|
||||
#
|
||||
future = client.futures['authenticated']
|
||||
future.resolve(1)
|
||||
return message
|
||||
|
||||
def handle_error_message(self, client: Client, message) -> Bool:
|
||||
#
|
||||
# {
|
||||
# "error": {code: 1, message: "invalid argument"},
|
||||
# "result": null,
|
||||
# "id": 1656090882
|
||||
# }
|
||||
#
|
||||
error = self.safe_value(message, 'error')
|
||||
try:
|
||||
if error is not None:
|
||||
code = self.safe_string(message, 'code')
|
||||
feedback = self.id + ' ' + self.json(message)
|
||||
self.throw_exactly_matched_exception(self.exceptions['ws']['exact'], code, feedback)
|
||||
except Exception as e:
|
||||
if isinstance(e, AuthenticationError):
|
||||
client.reject(e, 'authenticated')
|
||||
if 'authenticated' in client.subscriptions:
|
||||
del client.subscriptions['authenticated']
|
||||
return False
|
||||
return message
|
||||
|
||||
def handle_message(self, client: Client, message):
|
||||
#
|
||||
# auth
|
||||
# {error: null, result: {status: "success"}, id: 1656084550}
|
||||
#
|
||||
# pong
|
||||
# {error: null, result: "pong", id: 0}
|
||||
#
|
||||
if not self.handle_error_message(client, message):
|
||||
return
|
||||
result = self.safe_string(message, 'result')
|
||||
if result == 'pong':
|
||||
self.handle_pong(client, message)
|
||||
return
|
||||
id = self.safe_integer(message, 'id')
|
||||
if id is not None:
|
||||
self.handle_subscription_status(client, message, id)
|
||||
return
|
||||
methods: dict = {
|
||||
'market_update': self.handle_ticker,
|
||||
'trades_update': self.handle_trades,
|
||||
'depth_update': self.handle_order_book,
|
||||
'candles_update': self.handle_ohlcv,
|
||||
'ordersPending_update': self.handle_order,
|
||||
'ordersExecuted_update': self.handle_order,
|
||||
'balanceSpot_update': self.handle_balance,
|
||||
'balanceMargin_update': self.handle_balance,
|
||||
'deals_update': self.handle_my_trades,
|
||||
}
|
||||
topic = self.safe_value(message, 'method')
|
||||
method = self.safe_value(methods, topic)
|
||||
if method is not None:
|
||||
method(client, message)
|
||||
|
||||
def handle_subscription_status(self, client: Client, message, id):
|
||||
# not every method stores its subscription
|
||||
# object so we can't do indeById here
|
||||
subs = client.subscriptions
|
||||
values = list(subs.values())
|
||||
for i in range(0, len(values)):
|
||||
subscription = values[i]
|
||||
if subscription is not True:
|
||||
subId = self.safe_integer(subscription, 'id')
|
||||
if (subId is not None) and (subId == id):
|
||||
method = self.safe_value(subscription, 'method')
|
||||
if method is not None:
|
||||
method(client, message)
|
||||
return
|
||||
|
||||
def handle_pong(self, client: Client, message):
|
||||
client.lastPong = self.milliseconds()
|
||||
return message
|
||||
|
||||
def ping(self, client: Client):
|
||||
return {
|
||||
'id': 0,
|
||||
'method': 'ping',
|
||||
'params': [],
|
||||
}
|
||||
Reference in New Issue
Block a user