async def _trades(self, msg: dict, timestamp: float):
'''
{
'buyer_role': 'taker',
'price': '54900.0',
'product_id': 8320,
'seller_role': 'maker',
'size': '0.000695',
'symbol': 'BTC_USDT',
'timestamp': 1638132618257226,
'type': 'all_trades'
}
'''
if msg['type'] == 'all_trades':
t = Trade(self.id,
self.exchange_symbol_to_std_symbol(msg['symbol']),
BUY if msg['buyer_role'] == 'taker' else SELL,
Decimal(msg['size']),
Decimal(msg['price']),
self.timestamp_normalize(msg['timestamp']),
raw=msg)
await self.callback(TRADES, t, timestamp)
else:
for trade in msg['trades']:
t = Trade(self.id,
self.exchange_symbol_to_std_symbol(msg['symbol']),
BUY if trade['buyer_role'] == 'taker' else SELL,
Decimal(trade['size']),
Decimal(trade['price']),
self.timestamp_normalize(trade['timestamp']),
raw=trade)
await self.callback(TRADES, t, timestamp)
def test_trade():
t = Trade('COINBASE',
'BTC-USD',
BUY,
Decimal(10),
Decimal(100),
time(),
id=str(int(time())),
type='TEST')
d = t.to_dict(numeric_type=str)
d = json.dumps(d)
d = json.loads(d)
t2 = Trade.from_dict(d)
assert t == t2
async def _trade(self, msg: dict, timestamp: float):
"""
{
'ch': 'market.adausdt.trade.detail',
'ts': 1597792835344,
'tick': {
'id': 101801945127,
'ts': 1597792835336,
'data': [
{
'id': Decimal('10180194512782291967181675'), <- per docs this is deprecated
'ts': 1597792835336,
'tradeId': 100341530602,
'amount': Decimal('0.1'),
'price': Decimal('0.137031'),
'direction': 'sell'
}
]
}
}
"""
for trade in msg['tick']['data']:
t = Trade(self.id,
self.exchange_symbol_to_std_symbol(
msg['ch'].split('.')[1]),
BUY if trade['direction'] == 'buy' else SELL,
Decimal(trade['amount']),
Decimal(trade['price']),
self.timestamp_normalize(trade['ts']),
id=str(trade['tradeId']),
raw=trade)
await self.callback(TRADES, t, timestamp)
async def _trade(self, msg: dict, ts: float):
'''
{
'ch': 'trades',
'update': {
'BTCUSDT': [{
't': 1633803835228,
'i': 1633803835228,
'p': '54774.60',
'q': '0.00004',
's': 'buy'
}]
}
}
'''
for pair, update in msg['update'].items():
symbol = self.exchange_symbol_to_std_symbol(pair)
for trade in update:
t = Trade(self.id,
symbol,
BUY if trade['s'] == 'buy' else SELL,
Decimal(trade['q']),
Decimal(trade['p']),
self.timestamp_normalize(trade['t']),
id=str(trade['i']),
raw=msg)
await self.callback(TRADES, t, ts)
async def _book_update(self, msg: dict, timestamp: float):
'''
{
'type': 'match', or last_match
'trade_id': 43736593
'maker_order_id': '2663b65f-b74e-4513-909d-975e3910cf22',
'taker_order_id': 'd058d737-87f1-4763-bbb4-c2ccf2a40bde',
'side': 'buy',
'size': '0.01235647',
'price': '8506.26000000',
'product_id': 'BTC-USD',
'sequence': 5928276661,
'time': '2018-05-21T00:26:05.585000Z'
}
'''
pair = self.exchange_symbol_to_std_symbol(msg['product_id'])
ts = self.timestamp_normalize(msg['time'])
if self.keep_l3_book and 'full' in self.subscription and pair in self.subscription[
'full']:
delta = {BID: [], ASK: []}
price = Decimal(msg['price'])
side = ASK if msg['side'] == 'sell' else BID
size = Decimal(msg['size'])
maker_order_id = msg['maker_order_id']
_, new_size = self.order_map[maker_order_id]
new_size -= size
if new_size <= 0:
del self.order_map[maker_order_id]
self.order_type_map.pop(maker_order_id, None)
delta[side].append((maker_order_id, price, 0))
del self._l3_book[pair].book[side][price][maker_order_id]
if len(self._l3_book[pair].book[side][price]) == 0:
del self._l3_book[pair].book[side][price]
else:
self.order_map[maker_order_id] = (price, new_size)
self._l3_book[pair].book[side][price][
maker_order_id] = new_size
delta[side].append((maker_order_id, price, new_size))
await self.book_callback(L3_BOOK,
self._l3_book[pair],
timestamp,
timestamp=ts,
delta=delta,
raw=msg,
sequence_number=self.seq_no[pair])
order_type = self.order_type_map.get(msg['taker_order_id'])
t = Trade(self.id,
self.exchange_symbol_to_std_symbol(msg['product_id']),
SELL if msg['side'] == 'buy' else BUY,
Decimal(msg['size']),
Decimal(msg['price']),
ts,
id=str(msg['trade_id']),
type=order_type,
raw=msg)
await self.callback(TRADES, t, timestamp)
async def _trades(self, msg: dict, timestamp: float):
'''
{
'instrument_name': 'BTC_USDT',
'subscription': 'trade.BTC_USDT',
'channel': 'trade',
'data': [
{
'dataTime': 1637630445449,
'd': 2006341810221954784,
's': 'BUY',
'p': Decimal('56504.25'),
'q': Decimal('0.003802'),
't': 1637630445448,
'i': 'BTC_USDT'
}
]
}
'''
for entry in msg['data']:
t = Trade(
self.id,
self.exchange_symbol_to_std_symbol(msg['instrument_name']),
BUY if entry['s'] == 'BUY' else SELL,
entry['q'],
entry['p'],
self.timestamp_normalize(entry['t']),
id=str(entry['d']),
raw=entry
)
await self.callback(TRADES, t, timestamp)
async def _trade(self, msg: dict, pair: str, timestamp: float):
"""
{
"feed": "trade",
"product_id": "PI_XBTUSD",
"uid": "b5a1c239-7987-4207-96bf-02355a3263cf",
"side": "sell",
"type": "fill",
"seq": 85423,
"time": 1565342712903,
"qty": 1135.0,
"price": 11735.0
}
"""
t = Trade(
self.id,
pair,
BUY if msg['side'] == 'buy' else SELL,
Decimal(msg['qty']),
Decimal(msg['price']),
self.timestamp_normalize(msg['time']),
id=msg['uid'],
raw=msg
)
await self.callback(TRADES, t, timestamp)
async def _trades(self, msg: dict, symbol: str, timestamp: float):
"""
{
"type":"message",
"topic":"/market/match:BTC-USDT",
"subject":"trade.l3match",
"data":{
"sequence":"1545896669145",
"type":"match",
"symbol":"BTC-USDT",
"side":"buy",
"price":"0.08200000000000000000",
"size":"0.01022222000000000000",
"tradeId":"5c24c5da03aa673885cd67aa",
"takerOrderId":"5c24c5d903aa6772d55b371e",
"makerOrderId":"5c2187d003aa677bd09d5c93",
"time":"1545913818099033203"
}
}
"""
t = Trade(self.id,
symbol,
BUY if msg['data']['side'] == 'buy' else SELL,
Decimal(msg['data']['size']),
Decimal(msg['data']['price']),
float(msg['data']['time']) / 1000000000,
id=msg['data']['tradeId'],
raw=msg)
await self.callback(TRADES, t, timestamp)
async def _trades(self, msg: dict, timestamp: float):
"""
"params": {
"data": [
{
"id": 54469813,
"price": "0.054670",
"quantity": "0.183",
"side": "buy",
"timestamp": "2017-10-19T16:34:25.041Z"
}
],
"symbol": "ETHBTC"
}
"""
pair = self.exchange_symbol_to_std_symbol(msg['symbol'])
for update in msg['data']:
t = Trade(self.id,
pair,
BUY if update['side'] == 'buy' else SELL,
Decimal(update['quantity']),
Decimal(update['price']),
self.timestamp_normalize(update['timestamp']),
id=str(update['id']),
raw=update)
await self.callback(TRADES, t, timestamp)
async def _trade(self, msg: dict, timestamp: float):
"""
Doc : https://docs.upbit.com/v1.0.7/reference#시세-체결-조회
{
'ty': 'trade' // Event type
'cd': 'KRW-BTC', // Symbol
'tp': 6759000.0, // Trade Price
'tv': 0.03243003, // Trade volume(amount)
'tms': 1584257228806, // Timestamp
'ttms': 1584257228000, // Trade Timestamp
'ab': 'BID', // 'BID' or 'ASK'
'cp': 64000.0, // Change of price
'pcp': 6823000.0, // Previous closing price
'sid': 1584257228000000, // Sequential ID
'st': 'SNAPSHOT', // 'SNAPSHOT' or 'REALTIME'
'td': '2020-03-15', // Trade date utc
'ttm': '07:27:08', // Trade time utc
'c': 'FALL', // Change - 'FALL' / 'RISE' / 'EVEN'
}
"""
price = Decimal(msg['tp'])
amount = Decimal(msg['tv'])
t = Trade(
self.id,
self.exchange_symbol_to_std_symbol(msg['cd']),
BUY if msg['ab'] == 'BID' else SELL,
amount,
price,
self.timestamp_normalize(msg['ttms']),
id=str(msg['sid']),
raw=msg
)
await self.callback(TRADES, t, timestamp)
async def _trades(self, msg: dict, timestamp: float):
"""
{
"time": 1606292218,
"channel": "spot.trades",
"event": "update",
"result": {
"id": 309143071,
"create_time": 1606292218,
"create_time_ms": "1606292218213.4578",
"side": "sell",
"currency_pair": "GT_USDT",
"amount": "16.4700000000",
"price": "0.4705000000"
}
}
"""
t = Trade(self.id,
self.exchange_symbol_to_std_symbol(
msg['result']['currency_pair']),
SELL if msg['result']['side'] == 'sell' else BUY,
Decimal(msg['result']['amount']),
Decimal(msg['result']['price']),
float(msg['result']['create_time_ms']) / 1000,
id=str(msg['result']['id']),
raw=msg)
await self.callback(TRADES, t, timestamp)
async def _trade(self, msg: dict, timestamp: float):
"""
example message:
{"channel": "trades", "market": "BTC-PERP", "type": "update", "data": [{"id": null, "price": 10738.75,
"size": 0.3616, "side": "buy", "liquidation": false, "time": "2019-08-03T12:20:19.170586+00:00"}]}
"""
for trade in msg['data']:
t = Trade(self.id,
self.exchange_symbol_to_std_symbol(msg['market']),
BUY if trade['side'] == 'buy' else SELL,
Decimal(trade['size']),
Decimal(trade['price']),
float(self.timestamp_normalize(trade['time'])),
id=str(trade['id']),
raw=trade)
await self.callback(TRADES, t, timestamp)
if bool(trade['liquidation']):
liq = Liquidation(
self.id,
self.exchange_symbol_to_std_symbol(msg['market']),
BUY if trade['side'] == 'buy' else SELL,
Decimal(trade['size']),
Decimal(trade['price']),
str(trade['id']),
FILLED,
float(self.timestamp_normalize(trade['time'])),
raw=trade)
await self.callback(LIQUIDATIONS, liq, timestamp)
async def _trade(self, msg: dict, timestamp: float):
"""
trade msg example
{
"seqnum": 21,
"event": "updated",
"channel": "trades",
"symbol": "BTC-USD",
"timestamp": "2019-08-13T11:30:06.100140Z",
"side": "sell",
"qty": 8.5E-5,
"price": 11252.4,
"trade_id": "12884909920"
}
"""
t = Trade(
self.id,
msg['symbol'],
BUY if msg['side'] == 'buy' else SELL,
msg['qty'],
msg['price'],
self.timestamp_normalize(msg['timestamp']),
id=msg['trade_id'],
)
await self.callback(TRADES, t, timestamp)
async def _trade(self, msg: dict, timestamp: float):
"""
{
"arg": {
"channel": "trades",
"instId": "BTC-USD-191227"
},
"data": [
{
"instId": "BTC-USD-191227",
"tradeId": "9",
"px": "0.016",
"sz": "50",
"side": "buy",
"ts": "1597026383085"
}
]
}
"""
for trade in msg['data']:
t = Trade(self.id,
self.exchange_symbol_to_std_symbol(trade['instId']),
BUY if trade['side'] == 'buy' else SELL,
Decimal(trade['sz']),
Decimal(trade['px']),
self.timestamp_normalize(int(trade['ts'])),
id=trade['tradeId'],
raw=trade)
await self.callback(TRADES, t, timestamp)
async def _trades(self, msg: dict, timestamp: float):
"""
{'data':
{
'microtimestamp': '1562650233964229', // Event time (micros)
'amount': Decimal('0.014140160000000001'), // Quantity
'buy_order_id': 3709484695, // Buyer order ID
'sell_order_id': 3709484799, // Seller order ID
'amount_str': '0.01414016', // Quantity string
'price_str': '12700.00', // Price string
'timestamp': '1562650233', // Event time
'price': Decimal('12700.0'), // Price
'type': 1,
'id': 93215787
},
'event': 'trade',
'channel': 'live_trades_btcusd'
}
"""
data = msg['data']
chan = msg['channel']
pair = self.exchange_symbol_to_std_symbol(chan.split('_')[-1])
t = Trade(
self.id,
pair,
BUY if data['type'] == 0 else SELL,
Decimal(data['amount']),
Decimal(data['price']),
self.timestamp_normalize(int(data['microtimestamp'])),
id=str(data['id']),
raw=msg
)
await self.callback(TRADES, t, timestamp)
async def _trade(self, msg: dict, timestamp: float):
"""
trade msg example
{
'timestamp': '2018-05-19T12:25:26.632Z',
'symbol': 'XBTUSD',
'side': 'Buy',
'size': 40,
'price': 8335,
'tickDirection': 'PlusTick',
'trdMatchID': '5f4ecd49-f87f-41c0-06e3-4a9405b9cdde',
'grossValue': 479920,
'homeNotional': Decimal('0.0047992'),
'foreignNotional': 40
}
"""
for data in msg['data']:
ts = self.timestamp_normalize(data['timestamp'])
t = Trade(
self.id,
self.exchange_symbol_to_std_symbol(data['symbol']),
BUY if data['side'] == 'Buy' else SELL,
Decimal(data['size']),
Decimal(data['price']),
ts,
id=data['trdMatchID'],
raw=data
)
await self.callback(TRADES, t, timestamp)
async def _trade(self, msg: dict, timestamp: float):
"""
{
"e": "aggTrade", // Event type
"E": 123456789, // Event time
"s": "BNBBTC", // Symbol
"a": 12345, // Aggregate trade ID
"p": "0.001", // Price
"q": "100", // Quantity
"f": 100, // First trade ID
"l": 105, // Last trade ID
"T": 123456785, // Trade time
"m": true, // Is the buyer the market maker?
"M": true // Ignore
}
"""
t = Trade(self.id,
self.exchange_symbol_to_std_symbol(msg['s']),
SELL if msg['m'] else BUY,
Decimal(msg['q']),
Decimal(msg['p']),
self.timestamp_normalize(msg['T']),
id=str(msg['a']),
raw=msg)
await self.callback(TRADES, t, timestamp)
async def _trade(self, msg: dict, timestamp: float):
"""
{"topic":"trade.BTCUSD",
"data":[
{
"timestamp":"2019-01-22T15:04:33.461Z",
"symbol":"BTCUSD",
"side":"Buy",
"size":980,
"price":3563.5,
"tick_direction":"PlusTick",
"trade_id":"9d229f26-09a8-42f8-aff3-0ba047b0449d",
"cross_seq":163261271}]}
"""
data = msg['data']
for trade in data:
if isinstance(trade['trade_time_ms'], str):
ts = int(trade['trade_time_ms'])
else:
ts = trade['trade_time_ms']
t = Trade(
self.id,
self.exchange_symbol_to_std_symbol(trade['symbol']),
BUY if trade['side'] == 'Buy' else SELL,
Decimal(trade['size']),
Decimal(trade['price']),
self.timestamp_normalize(ts),
id=trade['trade_id'],
raw=trade
)
await self.callback(TRADES, t, timestamp)
async def _trade(self, data: dict, timestamp: float):
"""
{
'channel': 'trade',
'timestamp': 1639080717242,
'data': [{
'trade_id': '7016884324',
'instrument_id': 'BTC-PERPETUAL',
'price': '47482.50000000',
'qty': '6000.00000000',
'side': 'sell',
'sigma': '0.00000000',
'is_block_trade': False,
'created_at': 1639080717195
}]
}
"""
for t in data['data']:
trade = Trade(self.id,
self.exchange_symbol_to_std_symbol(
t.get('instrument_id') or t.get('pair')),
SELL if t['side'] == 'sell' else BUY,
Decimal(t['qty']),
Decimal(t['price']),
self.timestamp_normalize(t['created_at']),
id=t['trade_id'],
raw=t)
await self.callback(TRADES, trade, timestamp)
async def _trades(self, msg: dict, rtimestamp: float):
'''
{
"type": "transaction",
"content": {
"list": [
{
"symbol": "BTC_KRW", // currency code
"buySellGb": "1", // type of contract (1: sale contract, 2: buy contract)
"contPrice": "10579000", // execution price
"contQty": "0.01", // number of contracts
"contAmt": "105790.00", // execution amount
"contDtm": "2020-01-29 12:24:18.830039", // Signing time
"updn": "dn" // comparison with the previous price: up-up, dn-down
}
]
}
}
'''
trades = msg.get('content', {}).get('list', [])
for trade in trades:
# API ref list uses '-', but market data returns '_'
symbol = self.exchange_symbol_to_std_symbol(trade['symbol'])
timestamp = self.timestamp_normalize(trade['contDtm'])
price = Decimal(trade['contPrice'])
quantity = Decimal(trade['contQty'])
side = BUY if trade['buySellGb'] == '2' else SELL
t = Trade(self.id, symbol, side, quantity, price, timestamp, raw=trade)
await self.callback(TRADES, t, rtimestamp)
async def trades(self, msg: dict, timestamp: float):
"""
{
'deltas': [
{
'id': '8e7f693b-6504-4cb7-9484-835435b147f9',
'executedAt': datetime.datetime(2021, 6, 13, 22, 38, 11, 80000, tzinfo=datetime.timezone.utc),
'quantity': '0.00693216',
'rate': '38808.83000000',
'takerSide': 'BUY'
}
],
'sequence': 204392,
'marketSymbol': 'BTC-USD'
}
"""
pair = self.exchange_symbol_to_std_symbol(msg['marketSymbol'])
for trade in msg['deltas']:
t = Trade(self.id,
pair,
BUY if trade['takerSide'] == 'BUY' else SELL,
Decimal(trade['quantity']),
Decimal(trade['rate']),
self.timestamp_normalize(trade['executedAt']),
id=trade['id'],
raw=trade)
await self.callback(TRADES, t, timestamp)
async def _trade(self, msg: dict, timestamp: float):
"""
{
"jsonrpc":"2.0",
"method":"channelMessage",
"params":{
"channel":"lightning_executions_BTC_JPY",
"message":[
{
"id":2084881071,
"side":"BUY",
"price":2509125.0,
"size":0.005,
"exec_date":"2020-12-25T21:36:22.8840579Z",
"buy_child_order_acceptance_id":"JRF20201225-213620-004123",
"sell_child_order_acceptance_id":"JRF20201225-213620-133314"
}
]
}
}
"""
pair = self.exchange_symbol_to_std_symbol(msg['params']['channel'][21:])
for update in msg['params']['message']:
t = Trade(
self.id,
pair,
BUY if update['side'] == 'BUY' else SELL,
update['size'],
update['price'],
self.timestamp_normalize(update['exec_date']),
raw=update
)
await self.callback(TRADES, t, timestamp)
async def _trade(self, msg: dict, timestamp: float):
'''
{
'Channel': 'ticker-eth-aud',
'Nonce': 78,
'Data': {
'TradeGuid': '6d1c2e90-592a-409c-a8d8-58b2d25e0b0b',
'Pair': 'eth-aud',
'TradeDate': datetime.datetime(2022, 1, 31, 8, 28, 26, 552573, tzinfo=datetime.timezone(datetime.timedelta(seconds=39600))),
'Price': Decimal('3650.81'),
'Volume': Decimal('0.543'),
'BidGuid': '0430e003-c35e-410e-85f5-f0bb5c40193b',
'OfferGuid': '559c1dd2-e681-4efc-b49b-14a07c069de4',
'Side': 'Sell'
},
'Time': 1643578106584,
'Event': 'Trade'
}
'''
t = Trade(
self.id,
self.exchange_symbol_to_std_symbol(msg['Data']['Pair']),
SELL if msg['Data']['Side'] == 'Sell' else BUY,
Decimal(msg['Data']['Volume']),
Decimal(msg['Data']['Price']),
self.timestamp_normalize(msg['Data']['TradeDate']),
id=msg['Data']['TradeGuid'],
raw=msg
)
await self.callback(TRADES, t, timestamp)
async def _book(self, msg: dict, chan_id: int, timestamp: float):
delta = {BID: [], ASK: []}
msg_type = msg[0][0]
pair = None
# initial update (i.e. snapshot)
if msg_type == 'i':
delta = None
pair = msg[0][1]['currencyPair']
pair = self.exchange_symbol_to_std_symbol(pair)
self._l2_book[pair] = OrderBook(self.id,
pair,
max_depth=self.max_depth)
# 0 is asks, 1 is bids
order_book = msg[0][1]['orderBook']
for index, side in enumerate([ASK, BID]):
for key in order_book[index]:
amount = Decimal(order_book[index][key])
price = Decimal(key)
self._l2_book[pair].book[side][price] = amount
else:
pair = self._channel_map[chan_id]
pair = self.exchange_symbol_to_std_symbol(pair)
for update in msg:
msg_type = update[0]
# order book update
if msg_type == 'o':
side = ASK if update[1] == 0 else BID
price = Decimal(update[2])
amount = Decimal(update[3])
if amount == 0:
delta[side].append((price, 0))
del self._l2_book[pair].book[side][price]
else:
delta[side].append((price, amount))
self._l2_book[pair].book[side][price] = amount
elif msg_type == 't':
# index 1 is trade id, 2 is side, 3 is price, 4 is amount, 5 is timestamp, 6 is timestamp ms
_, order_id, _, price, amount, server_ts, _ = update
price = Decimal(price)
amount = Decimal(amount)
t = Trade(self.id,
pair,
BUY if update[2] == 1 else SELL,
amount,
price,
float(server_ts),
id=order_id,
raw=msg)
await self.callback(TRADES, t, timestamp)
else:
LOG.warning("%s: Unexpected message received: %s", self.id,
msg)
await self.book_callback(L2_BOOK,
self._l2_book[pair],
timestamp,
delta=delta,
raw=msg)
def _trade_normalize(self, symbol: str, data: dict) -> dict:
return Trade(self.id,
symbol,
SELL if data['side'] == 'buy' else BUY,
Decimal(data['size']),
Decimal(data['price']),
data['time'].timestamp(),
id=str(data['trade_id']),
raw=data)
async def _funding_update(funding: list, timestamp: float):
order_id, ts, amount, price, period = funding
t = Trade(self.id,
pair,
SELL if amount < 0 else BUY,
Decimal(abs(Decimal(amount))),
Decimal(price),
self.timestamp_normalize(ts),
id=order_id,
raw=funding)
await self.callback(TRADES, t, timestamp)
async def _trade_update(trade: list, timestamp: float):
order_id, ts, amount, price = trade
t = Trade(
self.id,
pair,
SELL if amount < 0 else BUY,
Decimal(abs(Decimal(amount))),
Decimal(price),
self.timestamp_normalize(ts),
id=str(order_id),
)
await self.callback(TRADES, t, timestamp)
async def _trade(self, msg: dict, timestamp: float):
"""
update:
{
'type': 'channel_data',
'connection_id': '7b4abf85-f9eb-4f6e-82c0-5479ad5681e9',
'message_id': 18,
'id': 'DOGE-USD',
'channel': 'v3_trades',
'contents': {
'trades': [{
'size': '390',
'side': 'SELL',
'price': '0.2334',
'createdAt': datetime.datetime(2021, 6, 23, 22, 36, 34, 520000, tzinfo=datetime.timezone.utc)
}]
}
}
initial message:
{
'type': 'subscribed',
'connection_id': 'ccd8b74c-97b3-491d-a9fc-4a92a171296e',
'message_id': 4,
'channel': 'v3_trades',
'id': 'UNI-USD',
'contents': {
'trades': [{
'side': 'BUY',
'size': '384.1',
'price': '17.23',
'createdAt': datetime.datetime(2021, 6, 23, 20, 28, 25, 465000, tzinfo=datetime.timezone.utc)
},
{
'side': 'SELL',
'size': '384.1',
'price': '17.138',
'createdAt': datetime.datetime(2021, 6, 23, 20, 22, 26, 466000, tzinfo=datetime.timezone.utc)},
}]
}
}
"""
pair = self.exchange_symbol_to_std_symbol(msg['id'])
for trade in msg['contents']['trades']:
t = Trade(self.id,
pair,
BUY if trade['side'] == 'BUY' else SELL,
Decimal(trade['size']),
Decimal(trade['price']),
self.timestamp_normalize(trade['createdAt']),
raw=trade)
await self.callback(TRADES, t, timestamp)
async def _trade(self, msg: dict, timestamp: float):
"""
{
"params":
{
"data":
[
{
"trade_seq": 933,
"trade_id": "9178",
"timestamp": 1550736299753,
"tick_direction": 3,
"price": 3948.69,
"instrument_name": "BTC-PERPETUAL",
"index_price": 3930.73,
"direction": "sell",
"amount": 10
}
],
"channel": "trades.BTC-PERPETUAL.raw"
},
"method": "subscription",
"jsonrpc": "2.0"
}
"""
for trade in msg["params"]["data"]:
t = Trade(
self.id,
self.exchange_symbol_to_std_symbol(trade["instrument_name"]),
BUY if trade['direction'] == 'buy' else SELL,
Decimal(trade['amount']),
Decimal(trade['price']),
self.timestamp_normalize(trade['timestamp']),
id=trade['trade_id'],
raw=trade
)
await self.callback(TRADES, t, timestamp)
if 'liquidation' in trade:
liq = Liquidation(
self.id,
self.exchange_symbol_to_std_symbol(trade["instrument_name"]),
BUY if trade['direction'] == 'buy' else SELL,
Decimal(trade['amount']),
Decimal(trade['price']),
trade['trade_id'],
FILLED,
self.timestamp_normalize(trade['timestamp']),
raw=trade
)
await self.callback(LIQUIDATIONS, liq, timestamp)
async def _trades(self, msg: dict, timestamp: float):
'''
{
"channel":"marketdata",
"market_id":"ETH-BTC",
"status":"ok","lag":0,
"recent_trades":[
{
"id":"ETH-BTC:4429182",
"price":"0.028229",
"quantity":"3.117",
"time":"2020-11-01T03:59:06.277Z",
"side":"buy","tick_direction":"down"
},{
"id":"ETH-BTC:4429183",
"price":"0.028227",
"quantity":"1.793",
"time":"2020-11-01T03:59:14.528Z",
"side":"buy",
"tick_direction":"down"
}
],"reset":true
}
{
"channel":"marketdata",
"market_id":"ETH-BTC",
"status":"ok","lag":0,
"recent_trades":[
{
"id":"ETH-BTC:4429282",
"price":"0.028235",
"quantity":"2.203",
"time":"2020-11-01T04:22:15.117Z",
"side":"buy",
"tick_direction":"down"
}
]
}
'''
pair = self.exchange_symbol_to_std_symbol(msg['market_id'])
for update in msg['recent_trades']:
t = Trade(self.id,
pair,
BUY if update['side'] == 'buy' else SELL,
Decimal(update['quantity']),
Decimal(update['price']),
self.timestamp_normalize(update['time']),
id=update['id'],
raw=update)
await self.callback(TRADES, t, timestamp)