def handle_trades(self, client, message, subscription):
#
# [
# 0, # channelID
# [ # price volume time side type misc
# ["5541.20000", "0.15850568", "1534614057.321597", "s", "l", ""],
# ["6060.00000", "0.02455000", "1534614057.324998", "b", "l", ""],
# ],
# "trade",
# "XBT/USD"
# ]
#
wsName = self.safe_string(message, 3)
name = self.safe_string(message, 2)
messageHash = name + ':' + wsName
market = self.safe_value(self.options['marketsByWsName'], wsName)
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
trades = self.safe_value(message, 1, [])
parsed = self.parse_trades(trades, market)
for i in range(0, len(parsed)):
stored.append(parsed[i])
client.resolve(stored, messageHash)
def handle_trade(self, client, message):
#
# {
# data: {
# sequence: '1568787654360',
# symbol: 'BTC-USDT',
# side: 'buy',
# size: '0.00536577',
# price: '9345',
# takerOrderId: '5e356c4a9f1a790008f8d921',
# time: '1580559434436443257',
# type: 'match',
# makerOrderId: '5e356bffedf0010008fa5d7f',
# tradeId: '5e356c4aeefabd62c62a1ece'
# },
# subject: 'trade.l3match',
# topic: '/market/match:BTC-USDT',
# type: 'message'
# }
#
data = self.safe_value(message, 'data', {})
trade = self.parse_trade(data)
messageHash = self.safe_string(message, 'topic')
symbol = trade['symbol']
trades = self.safe_value(self.trades, symbol)
if trades is None:
limit = self.safe_integer(self.options, 'tradesLimit', 1000)
trades = ArrayCache(limit)
self.trades[symbol] = trades
trades.append(trade)
client.resolve(trades, messageHash)
return message
def handle_trades(self, client, message):
#
# {
# sequence: 1795484727,
# symbol: 'sBTCUSDT',
# trades: [
# [1592891002064516600, 'Buy', 964020000000, 1431000],
# [1592890978987934500, 'Sell', 963704000000, 1401800],
# [1592890972918701800, 'Buy', 963938000000, 2018600],
# ],
# type: 'snapshot'
# }
#
name = 'trade'
marketId = self.safe_string(message, 'symbol')
if marketId in self.markets_by_id:
market = self.markets_by_id[marketId]
symbol = market['symbol']
messageHash = name + ':' + 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
trades = self.safe_value(message, 'trades', [])
parsed = self.parse_trades(trades, market)
for i in range(0, len(parsed)):
stored.append(parsed[i])
client.resolve(stored, messageHash)
def handle_trade(self, client, message):
#
# {
# type: 'match',
# trade_id: 82047307,
# maker_order_id: '0f358725-2134-435e-be11-753912a326e0',
# taker_order_id: '252b7002-87a3-425c-ac73-f5b9e23f3caf',
# side: 'sell',
# size: '0.00513192',
# price: '9314.78',
# product_id: 'BTC-USD',
# sequence: 12038915443,
# time: '2020-01-31T20:03:41.158814Z'
# }
#
marketId = self.safe_string(message, 'product_id')
if marketId is not None:
trade = self.parse_trade(message)
symbol = trade['symbol']
# the exchange sends type = 'match'
# but requires 'matches' upon subscribing
# therefore we resolve 'matches' here instead of 'match'
# type = self.safe_string(message, 'type')
type = 'matches'
messageHash = type + ':' + marketId
array = self.safe_value(self.trades, symbol)
if array is None:
tradesLimit = self.safe_integer(self.options, 'tradesLimit',
1000)
array = ArrayCache(tradesLimit)
self.trades[symbol] = array
array.append(trade)
client.resolve(array, messageHash)
return message
def handle_trade(self, client, message):
#
# {
# event: 'trade',
# timestamp: 1590779594547,
# market: 'ETH-EUR',
# id: '450c3298-f082-4461-9e2c-a0262cc7cc2e',
# amount: '0.05026233',
# price: '198.46',
# side: 'buy'
# }
#
marketId = self.safe_string(message, 'market')
market = self.safe_market(marketId, None, '-')
symbol = market['symbol']
name = 'trades'
messageHash = name + '@' + marketId
trade = self.parse_trade(message, market)
array = self.safe_value(self.trades, symbol)
if array is None:
limit = self.safe_integer(self.options, 'tradesLimit', 1000)
array = ArrayCache(limit)
array.append(trade)
self.trades[symbol] = array
client.resolve(array, messageHash)
def handle_trade(self, client, message):
#
# {
# data: {
# buy_order_id: 1207733769326592,
# amount_str: "0.14406384",
# timestamp: "1583691851",
# microtimestamp: "1583691851934000",
# id: 106833903,
# amount: 0.14406384,
# sell_order_id: 1207733765476352,
# price_str: "8302.92",
# type: 0,
# price: 8302.92
# },
# event: "trade",
# channel: "live_trades_btcusd"
# }
#
# the trade streams push raw trade information in real-time
# each trade has a unique buyer and seller
channel = self.safe_string(message, 'channel')
data = self.safe_value(message, 'data')
subscription = self.safe_value(client.subscriptions, channel)
symbol = self.safe_string(subscription, 'symbol')
market = self.market(symbol)
trade = self.parse_trade(data, market)
array = self.safe_value(self.trades, symbol)
if array is None:
limit = self.safe_integer(self.options, 'tradesLimit', 1000)
array = ArrayCache(limit)
self.trades[symbol] = array
array.append(trade)
client.resolve(array, channel)
def handle_trade(self, client, message):
#
# {
# table: 'spot/trade',
# data: [
# {
# side: 'buy',
# trade_id: '30770973',
# price: '4665.4',
# size: '0.019',
# instrument_id: 'BTC-USDT',
# timestamp: '2020-03-16T13:41:46.526Z'
# }
# ]
# }
#
table = self.safe_string(message, 'table')
data = self.safe_value(message, 'data', [])
tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000)
for i in range(0, len(data)):
trade = self.parse_trade(data[i])
symbol = trade['symbol']
marketId = self.safe_string(trade['info'], 'instrument_id')
messageHash = table + ':' + marketId
stored = self.safe_value(self.trades, symbol)
if stored is None:
stored = ArrayCache(tradesLimit)
self.trades[symbol] = stored
stored.append(trade)
client.resolve(stored, messageHash)
return message
def handle_trades(self, client, message):
#
# {
# deltas: [
# {
# id: '5bf67885-a0a8-4c62-b73d-534e480e3332',
# executedAt: '2020-10-05T23:02:17.49Z',
# quantity: '0.00166790',
# rate: '10763.97000000',
# takerSide: 'BUY'
# }
# ],
# sequence: 24391,
# marketSymbol: 'BTC-USD'
# }
#
deltas = self.safe_value(message, 'deltas', [])
marketId = self.safe_string(message, 'marketSymbol')
symbol = self.safe_symbol(marketId, None, '-')
market = self.market(symbol)
name = 'trade'
messageHash = name + '_' + marketId
stored = self.safe_value(self.trades, symbol)
if stored is None:
limit = self.safe_integer(self.options, 'tradesLimit', 1000)
stored = ArrayCache(limit)
trades = self.parse_trades(deltas, market)
for i in range(0, len(trades)):
stored.append(trades[i])
self.trades[symbol] = stored
client.resolve(stored, messageHash)
def handle_trades(self, client, message):
# {type: 'trade',
# code: 'KRW-BTC',
# timestamp: 1584508285812,
# trade_date: '2020-03-18',
# trade_time: '05:11:25',
# trade_timestamp: 1584508285000,
# trade_price: 6747000,
# trade_volume: 0.06499468,
# ask_bid: 'ASK',
# prev_closing_price: 6774000,
# change: 'FALL',
# change_price: 27000,
# sequential_id: 1584508285000002,
# stream_type: 'REALTIME'}
trade = self.parse_trade(message)
symbol = trade['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
stored.append(trade)
marketId = self.safe_string(message, 'code')
messageHash = 'trade:' + marketId
client.resolve(stored, messageHash)
def handle_trades(self, client, message, subscription):
#
# {
# status: 'OK',
# destination: 'internal.trade',
# payload: {
# price: 11668.55,
# size: 0.001,
# id: 1600300736,
# ts: 1596653426822,
# symbol: 'BTC/USD_LEVERAGE',
# orderId: '00a02503-0079-54c4-0000-00004020163c',
# clientOrderId: '00a02503-0079-54c4-0000-482f0000754f',
# buyer: False
# }
# }
#
payload = self.safe_value(message, 'payload')
parsed = self.handle_trade(payload)
symbol = parsed['symbol']
# destination = self.safe_string(message, 'destination')
destination = 'trades.subscribe'
messageHash = destination + ':' + 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
stored.append(parsed)
client.resolve(stored, messageHash)
def handle_ohlcv(self, client, message):
#
# {
# e: 'kline',
# E: 1579482921215,
# s: 'ETHBTC',
# k: {
# t: 1579482900000,
# T: 1579482959999,
# s: 'ETHBTC',
# i: '1m',
# f: 158411535,
# L: 158411550,
# o: '0.01913200',
# c: '0.01913500',
# h: '0.01913700',
# l: '0.01913200',
# v: '5.08400000',
# n: 16,
# x: False,
# q: '0.09728060',
# V: '3.30200000',
# Q: '0.06318500',
# B: '0'
# }
# }
#
marketId = self.safe_string(message, 's')
lowercaseMarketId = self.safe_string_lower(message, 's')
event = self.safe_string(message, 'e')
kline = self.safe_value(message, 'k')
interval = self.safe_string(kline, 'i')
# use a reverse lookup in a static map instead
timeframe = self.find_timeframe(interval)
messageHash = lowercaseMarketId + '@' + event + '_' + interval
parsed = [
self.safe_integer(kline, 't'),
self.safe_float(kline, 'o'),
self.safe_float(kline, 'h'),
self.safe_float(kline, 'l'),
self.safe_float(kline, 'c'),
self.safe_float(kline, 'v'),
]
symbol = marketId
if marketId in self.markets_by_id:
market = self.markets_by_id[marketId]
symbol = market['symbol']
self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {})
stored = self.safe_value(self.ohlcvs[symbol], timeframe)
if stored is None:
limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
stored = ArrayCache(limit)
self.ohlcvs[symbol][timeframe] = stored
length = len(stored)
if length and (parsed[0] == stored[length - 1][0]):
stored[length - 1] = parsed
else:
stored.append(parsed)
client.resolve(stored, messageHash)
def handle_ohlcv(self, client, message):
#
# {
# jsonrpc: '2.0',
# method: 'snapshotCandles', # updateCandles
# params: {
# data: [
# {
# timestamp: '2020-04-05T00:06:00.000Z',
# open: '6869.40',
# close: '6867.16',
# min: '6863.17',
# max: '6869.4',
# volume: '0.08947',
# volumeQuote: '614.4195442'
# },
# {
# timestamp: '2020-04-05T00:07:00.000Z',
# open: '6867.54',
# close: '6859.26',
# min: '6858.85',
# max: '6867.54',
# volume: '1.7766',
# volumeQuote: '12191.5880395'
# },
# ],
# symbol: 'BTCUSD',
# period: 'M1'
# }
# }
#
params = self.safe_value(message, 'params', {})
data = self.safe_value(params, 'data', [])
marketId = self.safe_string(params, 'symbol')
if marketId in self.markets_by_id:
market = self.markets_by_id[marketId]
symbol = market['symbol']
period = self.safe_string(params, 'period')
timeframe = self.find_timeframe(period)
messageHash = 'ohlcv:' + marketId + ':' + period
limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
for i in range(0, len(data)):
candle = data[i]
parsed = self.parse_ohlcv(candle, market)
self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {})
stored = self.safe_value(self.ohlcvs[symbol], timeframe)
if stored is None:
stored = ArrayCache(limit)
self.ohlcvs[symbol][timeframe] = stored
length = len(stored)
if length and parsed[0] == stored[length - 1][0]:
stored[length - 1] = parsed
else:
stored.append(parsed)
client.resolve(stored, messageHash)
return message
def handle_ohlcv(self, client, message, subscription):
#
# [
# 216, # channelID
# [
# '1574454214.962096', # Time, seconds since epoch
# '1574454240.000000', # End timestamp of the interval
# '0.020970', # Open price at midnight UTC
# '0.020970', # Intraday high price
# '0.020970', # Intraday low price
# '0.020970', # Closing price at midnight UTC
# '0.020970', # Volume weighted average price
# '0.08636138', # Accumulated volume today
# 1, # Number of trades today
# ],
# 'ohlc-1', # Channel Name of subscription
# 'ETH/XBT', # Asset pair
# ]
#
info = self.safe_value(subscription, 'subscription', {})
interval = self.safe_integer(info, 'interval')
name = self.safe_string(info, 'name')
wsName = self.safe_string(message, 3)
market = self.safe_value(self.options['marketsByWsName'], wsName)
symbol = market['symbol']
timeframe = self.find_timeframe(interval)
duration = self.parse_timeframe(timeframe)
if timeframe is not None:
candle = self.safe_value(message, 1)
messageHash = name + ':' + timeframe + ':' + wsName
timestamp = self.safe_float(candle, 1)
timestamp -= duration
result = [
int(timestamp * 1000),
self.safe_float(candle, 2),
self.safe_float(candle, 3),
self.safe_float(candle, 4),
self.safe_float(candle, 5),
self.safe_float(candle, 7),
]
self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {})
stored = self.safe_value(self.ohlcvs[symbol], timeframe)
if stored is None:
limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
stored = ArrayCache(limit)
self.ohlcvs[symbol][timeframe] = stored
length = len(stored)
if length and result[0] == stored[length - 1][0]:
stored[length - 1] = result
else:
stored.append(result)
client.resolve(stored, messageHash)
def handle_my_trade(self, client, message):
#
# {
# event: 'fill',
# timestamp: 1590964470132,
# market: 'ETH-EUR',
# orderId: '85d082e1-eda4-4209-9580-248281a29a9a',
# fillId: '861d2da5-aa93-475c-8d9a-dce431bd4211',
# side: 'sell',
# amount: '0.1',
# price: '211.46',
# taker: True,
# fee: '0.056',
# feeCurrency: 'EUR'
# }
#
name = 'account'
event = self.safe_string(message, 'event')
marketId = self.safe_string(message, 'market')
messageHash = name + '@' + marketId + '_' + event
market = self.safe_market(marketId, None, '-')
trade = self.parse_trade(message, market)
if self.myTrades is None:
limit = self.safe_integer(self.options, 'tradesLimit', 1000)
self.myTrades = ArrayCache(limit)
array = self.myTrades
array.append(trade)
self.myTrades = array
client.resolve(array, messageHash)
def handle_ohlcv(self, client, message):
#
# {
# table: "spot/candle60s",
# data: [
# {
# candle: [
# "2020-03-16T14:29:00.000Z",
# "4948.3",
# "4966.7",
# "4939.1",
# "4945.3",
# "238.36021657"
# ],
# instrument_id: "BTC-USDT"
# }
# ]
# }
#
table = self.safe_string(message, 'table')
data = self.safe_value(message, 'data', [])
parts = table.split('/')
part1 = self.safe_string(parts, 1)
interval = part1.replace('candle', '')
interval = interval.replace('s', '')
# use a reverse lookup in a static map instead
timeframe = self.find_timeframe(interval)
for i in range(0, len(data)):
marketId = self.safe_string(data[i], 'instrument_id')
if marketId in self.markets_by_id:
candle = self.safe_value(data[i], 'candle')
market = self.markets_by_id[marketId]
symbol = market['symbol']
parsed = self.parse_ohlcv(candle, market)
self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {})
stored = self.safe_value(self.ohlcvs[symbol], timeframe)
if stored is None:
limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
stored = ArrayCache(limit)
self.ohlcvs[symbol][timeframe] = stored
length = len(stored)
if length and parsed[0] == stored[length - 1][0]:
stored[length - 1] = parsed
else:
stored.append(parsed)
messageHash = table + ':' + marketId
client.resolve(stored, messageHash)
def handle_trade(self, client, message):
# the trade streams push raw trade information in real-time
# each trade has a unique buyer and seller
marketId = self.safe_string(message, 's')
market = self.safe_market(marketId)
symbol = market['symbol']
lowerCaseId = self.safe_string_lower(message, 's')
event = self.safe_string(message, 'e')
messageHash = lowerCaseId + '@' + event
trade = self.parse_trade(message, market)
array = self.safe_value(self.trades, symbol)
if array is None:
limit = self.safe_integer(self.options, 'tradesLimit', 1000)
array = ArrayCache(limit)
array.append(trade)
self.trades[symbol] = array
client.resolve(array, messageHash)
def handle_ohlcv(self, client, message):
#
# {
# status: 'OK',
# destination: 'ohlc.event',
# payload: {
# interval: 'M1',
# symbol: 'BTC/USD_LEVERAGE',
# t: 1596650940000,
# h: 11670.05,
# l: 11658.1,
# o: 11668.55,
# c: 11666.05
# }
# }
#
# destination = self.safe_string(message, 'destination')
destination = 'OHLCMarketData.subscribe'
payload = self.safe_value(message, 'payload', {})
interval = self.safe_string(payload, 'interval')
timeframe = self.find_timeframe(interval)
marketId = self.safe_string(payload, 'symbol')
if marketId in self.markets_by_id:
market = self.markets_by_id[marketId]
symbol = market['symbol']
messageHash = destination + ':' + timeframe + ':' + symbol
result = [
self.safe_integer(payload, 't'),
self.safe_float(payload, 'o'),
self.safe_float(payload, 'h'),
self.safe_float(payload, 'l'),
self.safe_float(payload, 'c'),
None, # no volume v in OHLCV
]
self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {})
stored = self.safe_value(self.ohlcvs[symbol], timeframe)
if stored is None:
limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
stored = ArrayCache(limit)
self.ohlcvs[symbol][timeframe] = stored
length = len(stored)
if length and result[0] == stored[length - 1][0]:
stored[length - 1] = result
else:
stored.append(result)
client.resolve(stored, messageHash)
def handle_ohlcv(self, client, message):
# {type: 'candles',
# data:
# {m: 'DIL-ETH',
# t: 1599477340109,
# i: '1m',
# s: 1599477300000,
# e: 1599477360000,
# o: '0.09911040',
# h: '0.09911040',
# l: '0.09911040',
# c: '0.09911040',
# v: '0.15000000',
# n: 1,
# u: 6531}}
type = self.safe_string(message, 'type')
data = self.safe_value(message, 'data')
marketId = self.safe_string(data, 'm')
messageHash = type + ':' + marketId
parsed = [
self.safe_integer(data, 's'),
self.safe_float(data, 'o'),
self.safe_float(data, 'h'),
self.safe_float(data, 'l'),
self.safe_float(data, 'c'),
self.safe_float(data, 'v'),
]
symbol = None
if marketId in self.markets_by_id:
symbol = self.markets_by_id[marketId][symbol]
interval = self.safe_string(data, 'i')
timeframe = self.find_timeframe(interval)
# TODO: move to base class
self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {})
stored = self.safe_value(self.ohlcvs[symbol], timeframe)
if stored is None:
limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
stored = ArrayCache(limit)
self.ohlcvs[symbol][timeframe] = stored
length = len(stored)
if length and (parsed[0] == stored[length - 1][0]):
stored[length - 1] = parsed
else:
stored.append(parsed)
client.resolve(stored, messageHash)
def handle_trades(self, client, message):
#
# [
# 'BTC_USDT',
# [
# {
# id: 221994511,
# time: 1580311438.618647,
# price: '9309',
# amount: '0.0019',
# type: 'sell'
# },
# {
# id: 221994501,
# time: 1580311433.842509,
# price: '9311.31',
# amount: '0.01',
# type: 'buy'
# },
# ]
# ]
#
params = self.safe_value(message, 'params', [])
marketId = self.safe_string_lower(params, 0)
market = None
symbol = marketId
if marketId in self.markets_by_id:
market = self.markets_by_id[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
trades = self.safe_value(params, 1, [])
parsed = self.parse_trades(trades, market)
for i in range(0, len(parsed)):
stored.append(parsed[i])
methodType = message['method']
messageHash = methodType + ':' + marketId
client.resolve(stored, messageHash)
def handle_my_trades(self, client, message):
#
# subscription response
#
# {n: 'SubscribeToTrades', o: {}}
#
# regular update
#
# {
# "i": -1,
# "n": "TradeEvent",
# "o": {
# "tradeId": 74072, # trade ID
# "orderId": 453529, # order ID
# "side": 2, # 1(bid), 2(ask)
# "type": 1, # 1(limit), 2(market)
# "baseAmount": 0.01, # filled base asset amount(in ZEC for self case)
# "quoteAmount": 1, # filled quote asset amount(in KRW for self case)
# "fee": 0.0004, # fee
# "price": 100, # price
# "isSelfTrade": False, # whether both of matching orders are yours
# "occurredAt": 1603932107, # trade occurrence time
# "tradingPairName": "ZEC-KRW" # order book
# }
# }
#
o = self.safe_value(message, 'o', {})
name = 'myTrades'
messageHash = name
trade = self.parse_trade(o)
symbol = trade['symbol']
array = self.safe_value(self.myTrades, symbol)
if array is None:
limit = self.safe_integer(self.options, 'tradesLimit', 1000)
array = ArrayCache(limit)
array.append(trade)
self.myTrades[symbol] = array
client.resolve(array, messageHash)
client.resolve(array, messageHash + ':' + symbol)
def handle_trades(self, client, message):
#
# {
# ch: "market.btcusdt.trade.detail",
# ts: 1583495834011,
# tick: {
# id: 105004645372,
# ts: 1583495833751,
# data: [
# {
# id: 1.050046453727319e+22,
# ts: 1583495833751,
# tradeId: 102090727790,
# amount: 0.003893,
# price: 9150.01,
# direction: "sell"
# }
# ]
# }
# }
#
tick = self.safe_value(message, 'tick', {})
data = self.safe_value(tick, 'data', {})
ch = self.safe_string(message, 'ch')
parts = ch.split('.')
marketId = self.safe_string(parts, 1)
if marketId in self.markets_by_id:
market = self.markets_by_id[marketId]
symbol = market['symbol']
array = self.safe_value(self.trades, symbol)
if array is None:
limit = self.safe_integer(self.options, 'tradesLimit', 1000)
array = ArrayCache(limit)
self.trades[symbol] = array
for i in range(0, len(data)):
trade = self.parse_trade(data[i], market)
array.append(trade)
client.resolve(array, ch)
return message
def handle_ohlcv(self, client, message):
#
# {
# kline: [
# [1592905200, 60, 960688000000, 960709000000, 960709000000, 960400000000, 960400000000, 848100, 8146756046],
# [1592905140, 60, 960718000000, 960716000000, 960717000000, 960560000000, 960688000000, 4284900, 41163743512],
# [1592905080, 60, 960513000000, 960684000000, 960718000000, 960684000000, 960718000000, 4880500, 46887494349],
# ],
# sequence: 1804401474,
# symbol: 'sBTCUSDT',
# type: 'snapshot'
# }
#
name = 'kline'
marketId = self.safe_string(message, 'symbol')
if marketId in self.markets_by_id:
market = self.markets_by_id[marketId]
symbol = market['symbol']
candles = self.safe_value(message, name, [])
first = self.safe_value(candles, 0, [])
interval = self.safe_string(first, 1)
timeframe = self.find_timeframe(interval)
if timeframe is not None:
messageHash = name + ':' + timeframe + ':' + symbol
ohlcvs = self.parse_ohlcvs(candles, market)
self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {})
stored = self.safe_value(self.ohlcvs[symbol], timeframe)
if stored is None:
limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
stored = ArrayCache(limit)
self.ohlcvs[symbol][timeframe] = stored
for i in range(0, len(ohlcvs)):
candle = ohlcvs[i]
length = len(stored)
if length and (candle[0] == stored[length - 1][0]):
stored[length - 1] = candle
else:
stored.append(candle)
client.resolve(stored, messageHash)
def handle_ohlcv(self, client, message):
#
# {
# ch: 'market.btcusdt.kline.1min',
# ts: 1583501786794,
# tick: {
# id: 1583501760,
# open: 9094.5,
# close: 9094.51,
# low: 9094.5,
# high: 9094.51,
# amount: 0.44639786263800907,
# vol: 4059.76919054,
# count: 16
# }
# }
#
ch = self.safe_string(message, 'ch')
parts = ch.split('.')
marketId = self.safe_string(parts, 1)
if marketId in self.markets_by_id:
market = self.markets_by_id[marketId]
symbol = market['symbol']
interval = self.safe_string(parts, 3)
timeframe = self.find_timeframe(interval)
self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {})
stored = self.safe_value(self.ohlcvs[symbol], timeframe)
if stored is None:
limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
stored = ArrayCache(limit)
self.ohlcvs[symbol][timeframe] = stored
tick = self.safe_value(message, 'tick')
parsed = self.parse_ohlcv(tick, market)
length = len(stored)
if length and parsed[0] == stored[length - 1][0]:
stored[length - 1] = parsed
else:
stored.append(parsed)
client.resolve(stored, ch)
def handle_trade(self, client, message, subscription):
#
# {
# messageId: 'CAAQAA==',
# payload: 'eyJjcmVhdGVkX2F0IjogMTYwMTczNjI0NywgImFtb3VudCI6ICIwLjAwMjAwIiwgInByaWNlIjogIjEwNTkzLjk5MDAwMCIsICJzaWRlIjogIkJVWSIsICJwYWlyIjogIkJUQ19VU0RDIiwgInRha2VyX2ZlZSI6ICIwIiwgInRha2VyX3NpZGUiOiAiQlVZIiwgIm1ha2VyX2ZlZSI6ICIwIiwgInRha2VyIjogMjYxODU2NCwgIm1ha2VyIjogMjYxODU1N30=',
# properties: {},
# publishTime: '2020-10-03T14:44:09.881Z'
# }
#
payload = self.safe_string(message, 'payload')
if payload is None:
return message
data = json.loads(self.base64_to_string(payload))
#
# {
# created_at: 1601736247,
# amount: '0.00200',
# price: '10593.990000',
# side: 'BUY',
# pair: 'BTC_USDC',
# taker_fee: '0',
# taker_side: 'BUY',
# maker_fee: '0',
# taker: 2618564,
# maker: 2618557
# }
#
symbol = self.safe_string(subscription, 'symbol')
messageHash = self.safe_string(subscription, 'messageHash')
market = self.market(symbol)
trade = self.parse_trade(data, market)
array = self.safe_value(self.trades, symbol)
if array is None:
limit = self.safe_integer(self.options, 'tradesLimit', 1000)
array = ArrayCache(limit)
self.trades[symbol] = array
array.append(trade)
client.resolve(array, messageHash)
def handle_ohlcv(self, client, message):
#
# {
# sequence: 28286,
# marketSymbol: 'BTC-USD',
# interval: 'MINUTE_1',
# delta: {
# startsAt: '2020-10-05T18:52:00Z',
# open: '10706.62600000',
# high: '10706.62600000',
# low: '10703.25900000',
# close: '10703.26000000',
# volume: '0.86822264',
# quoteVolume: '9292.84594774'
# }
# }
#
name = 'candle'
marketId = self.safe_string(message, 'marketSymbol')
symbol = self.safe_symbol(marketId, None, '-')
interval = self.safe_string(message, 'interval')
messageHash = name + '_' + marketId + '_' + interval
timeframe = self.find_timeframe(interval)
delta = self.safe_value(message, 'delta', {})
parsed = self.parse_ohlcv(delta)
self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {})
stored = self.safe_value(self.ohlcvs[symbol], timeframe)
if stored is None:
limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
stored = ArrayCache(limit)
self.ohlcvs[symbol][timeframe] = stored
length = len(stored)
if length and (parsed[0] == stored[length - 1][0]):
stored[length - 1] = parsed
else:
stored.append(parsed)
client.resolve(stored, messageHash)
def handle_trades_message(self, client, message, market):
#
# {
# 'M': 'BTC-ETH',
# 'N': 2322248,
# 'Z': [],
# 'S': [
# {'TY': 0, 'R': 0.01938852, 'Q': 29.32758526},
# {'TY': 1, 'R': 0.02322822, 'Q': 0}
# ],
# 'f': [
# {
# FI: 50365744,
# OT: 'SELL',
# R: 9240.432,
# Q: 0.07602962,
# T: 1580480744050
# }
# ]
# }
#
f = self.safe_value(message, 'f', [])
trades = self.parse_trades(f, market)
tradesLength = len(trades)
if tradesLength > 0:
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
for i in range(0, len(trades)):
stored.append(trades[i])
name = 'trade'
messageHash = name + ':' + market['symbol']
client.resolve(stored, messageHash)
return message
def handle_transaction(self, client, message):
# Update Speed: Real time, updates on any deposit or withdrawal of the wallet
# {type: 'balances',
# data:
# {w: '0x0AB991497116f7F5532a4c2f4f7B1784488628e1',
# a: 'ETH',
# q: '0.11198667',
# f: '0.11198667',
# l: '0.00000000',
# d: '0.00'}}
type = self.safe_string(message, 'type')
data = self.safe_value(message, 'data')
currencyId = self.safe_string(data, 'a')
messageHash = type + ':' + currencyId
code = self.safe_currency_code(currencyId)
address = self.safe_string(data, 'w')
transaction = {
'info': message,
'id': None,
'currency': code,
'amount': None,
'address': address,
'addressTo': None,
'addressFrom': None,
'tag': None,
'tagTo': None,
'tagFrom': None,
'status': 'ok',
'type': None,
'updated': None,
'txid': None,
'timestamp': None,
'datetime': None,
'fee': None,
}
if not (code in self.transactions):
limit = self.safe_integer(self.options, 'transactionsLimit', 1000)
self.transactions[code] = ArrayCache(limit)
transactions = self.transactions[code]
transactions.append(transaction)
client.resolve(transactions, messageHash)
client.resolve(transactions, type)
def handle_trades(self, client, message, subscription):
#
# initial snapshot
#
# [
# 2,
# [
# [null, 1580565020, 9374.9, 0.005],
# [null, 1580565004, 9374.9, 0.005],
# [null, 1580565003, 9374.9, 0.005],
# ]
# ]
#
# when a trade does not have an id yet
#
# # channel id, update type, seq, time, price, amount
# [2, 'te', '28462857-BTCUSD', 1580565041, 9374.9, 0.005],
#
# when a trade already has an id
#
# # channel id, update type, seq, trade id, time, price, amount
# [2, 'tu', '28462857-BTCUSD', 413357662, 1580565041, 9374.9, 0.005]
#
channel = self.safe_value(subscription, 'channel')
marketId = self.safe_string(subscription, 'pair')
messageHash = channel + ':' + marketId
tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000)
if marketId in self.markets_by_id:
market = self.markets_by_id[marketId]
symbol = market['symbol']
data = self.safe_value(message, 1)
stored = self.safe_value(self.trades, symbol)
if stored is None:
stored = ArrayCache(tradesLimit)
self.trades[symbol] = stored
if isinstance(data, list):
trades = self.parse_trades(data, market)
for i in range(0, len(trades)):
stored.append(trades[i])
else:
second = self.safe_string(message, 1)
if second != 'tu':
return
trade = self.parse_trade(message, market)
stored.append(trade)
client.resolve(stored, messageHash)
return message
def handle_trades(self, client, message):
#
# {
# jsonrpc: '2.0',
# method: 'snapshotTrades', # updateTrades
# params: {
# data: [
# {
# id: 814145791,
# price: '6957.20',
# quantity: '0.02779',
# side: 'buy',
# timestamp: '2020-04-03T10:28:20.032Z'
# },
# {
# id: 814145792,
# price: '6957.20',
# quantity: '0.12918',
# side: 'buy',
# timestamp: '2020-04-03T10:28:20.039Z'
# },
# ],
# symbol: 'BTCUSD'
# }
# }
#
params = self.safe_value(message, 'params', {})
data = self.safe_value(params, 'data', [])
marketId = self.safe_string(params, 'symbol')
if marketId in self.markets_by_id:
market = self.markets_by_id[marketId]
symbol = market['symbol']
messageHash = 'trades:' + marketId
tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000)
stored = self.safe_value(self.trades, symbol)
if stored is None:
stored = ArrayCache(tradesLimit)
self.trades[symbol] = stored
if isinstance(data, list):
trades = self.parse_trades(data, market)
for i in range(0, len(trades)):
stored.append(trades[i])
else:
trade = self.parse_trade(message, market)
stored.append(trade)
client.resolve(stored, messageHash)
return message
def handle_trade(self, client, message):
#
# {
# channel: "trades",
# market: "BTC-PERP",
# type: "update",
# data: [
# {
# id: 33517246,
# price: 6661.5,
# size: 2.3137,
# side: "sell",
# liquidation: False,
# time: "2020-04-02T07:45:12.011352+00:00"
# }
# ]
# }
#
data = self.safe_value(message, 'data', {})
marketId = self.safe_string(message, 'market')
if marketId in self.markets_by_id:
market = self.markets_by_id[marketId]
symbol = market['symbol']
messageHash = self.get_message_hash(message)
tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000)
stored = self.safe_value(self.trades, symbol)
if stored is None:
stored = ArrayCache(tradesLimit)
self.trades[symbol] = stored
if isinstance(data, list):
trades = self.parse_trades(data, market)
for i in range(0, len(trades)):
stored.append(trades[i])
else:
trade = self.parse_trade(message, market)
stored.append(trade)
client.resolve(stored, messageHash)
return message