712 lines
32 KiB
Python
712 lines
32 KiB
Python
# -*- 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, ArrayCacheBySymbolBySide, ArrayCacheByTimestamp
|
|
import hashlib
|
|
from ccxt.base.types import Any, Balances, Int, Market, Order, OrderBook, Position, Str, Strings, Ticker, Tickers, Trade
|
|
from ccxt.async_support.base.ws.client import Client
|
|
from typing import List
|
|
from ccxt.base.errors import ExchangeError
|
|
from ccxt.base.errors import ArgumentsRequired
|
|
from ccxt.base.errors import NotSupported
|
|
|
|
|
|
class blofin(ccxt.async_support.blofin):
|
|
|
|
def describe(self) -> Any:
|
|
return self.deep_extend(super(blofin, self).describe(), {
|
|
'has': {
|
|
'ws': True,
|
|
'watchTrades': True,
|
|
'watchTradesForSymbols': True,
|
|
'watchOrderBook': True,
|
|
'watchOrderBookForSymbols': True,
|
|
'watchTicker': True,
|
|
'watchTickers': True,
|
|
'watchBidsAsks': True,
|
|
'watchOHLCV': True,
|
|
'watchOHLCVForSymbols': True,
|
|
'watchOrders': True,
|
|
'watchOrdersForSymbols': True,
|
|
'watchPositions': True,
|
|
},
|
|
'urls': {
|
|
'api': {
|
|
'ws': {
|
|
'swap': {
|
|
'public': 'wss://openapi.blofin.com/ws/public',
|
|
'private': 'wss://openapi.blofin.com/ws/private',
|
|
},
|
|
},
|
|
},
|
|
'test': {
|
|
'ws': {
|
|
'swap': {
|
|
'public': 'wss://demo-trading-openapi.blofin.com/ws/public',
|
|
'private': 'wss://demo-trading-openapi.blofin.com/ws/private',
|
|
},
|
|
},
|
|
},
|
|
},
|
|
'options': {
|
|
'defaultType': 'swap',
|
|
'tradesLimit': 1000,
|
|
# orderbook channel can be one from:
|
|
# - "books": 200 depth levels will be pushed in the initial full snapshot. Incremental data will be pushed every 100 ms for the changes in the order book during that period of time.
|
|
# - "books5": 5 depth levels snapshot will be pushed every time. Snapshot data will be pushed every 100 ms when there are changes in the 5 depth levels snapshot.
|
|
'watchOrderBook': {
|
|
'channel': 'books',
|
|
},
|
|
'watchOrderBookForSymbols': {
|
|
'channel': 'books',
|
|
},
|
|
},
|
|
'streaming': {
|
|
'ping': self.ping,
|
|
'keepAlive': 25000, # 30 seconds max
|
|
},
|
|
})
|
|
|
|
def ping(self, client):
|
|
return 'ping'
|
|
|
|
def handle_pong(self, client: Client, message):
|
|
#
|
|
# 'pong'
|
|
#
|
|
client.lastPong = self.milliseconds()
|
|
|
|
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.blofin.com/index.html#ws-trades-channel
|
|
|
|
: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>`
|
|
"""
|
|
params['callerMethodName'] = 'watchTrades'
|
|
return await self.watch_trades_for_symbols([symbol], since, limit, params)
|
|
|
|
async def watch_trades_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}) -> List[Trade]:
|
|
"""
|
|
get the list of most recent trades for a list of symbols
|
|
|
|
https://docs.blofin.com/index.html#ws-trades-channel
|
|
|
|
:param str[] symbols: 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()
|
|
trades = await self.watch_multiple_wrapper(True, 'trades', 'watchTradesForSymbols', symbols, params)
|
|
if self.newUpdates:
|
|
firstMarket = self.safe_dict(trades, 0)
|
|
firstSymbol = self.safe_string(firstMarket, 'symbol')
|
|
limit = trades.getLimit(firstSymbol, limit)
|
|
return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
|
|
|
|
def handle_trades(self, client: Client, message):
|
|
#
|
|
# {
|
|
# arg: {
|
|
# channel: "trades",
|
|
# instId: "DOGE-USDT",
|
|
# },
|
|
# data : [
|
|
# <same object in REST example>,
|
|
# ...
|
|
# ]
|
|
# }
|
|
#
|
|
arg = self.safe_dict(message, 'arg')
|
|
channelName = self.safe_string(arg, 'channel')
|
|
data = self.safe_list(message, 'data')
|
|
if data is None:
|
|
return
|
|
for i in range(0, len(data)):
|
|
rawTrade = data[i]
|
|
trade = self.parse_ws_trade(rawTrade)
|
|
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)
|
|
messageHash = channelName + ':' + symbol
|
|
client.resolve(stored, messageHash)
|
|
|
|
def parse_ws_trade(self, trade, market: Market = None) -> Trade:
|
|
return self.parse_trade(trade, market)
|
|
|
|
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.blofin.com/index.html#ws-order-book-channel
|
|
|
|
: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
|
|
"""
|
|
params['callerMethodName'] = 'watchOrderBook'
|
|
return await self.watch_order_book_for_symbols([symbol], limit, params)
|
|
|
|
async def watch_order_book_for_symbols(self, symbols: List[str], limit: Int = None, params={}) -> OrderBook:
|
|
"""
|
|
watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
|
|
|
|
https://docs.blofin.com/index.html#ws-order-book-channel
|
|
|
|
:param str[] symbols: unified array of symbols
|
|
:param int [limit]: the maximum amount of order book entries to return
|
|
:param dict [params]: extra parameters specific to the exchange API endpoint
|
|
:param str [params.depth]: the type of order book to subscribe to, default is 'depth/increase100', also accepts 'depth5' or 'depth20' or depth50
|
|
:returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
|
|
"""
|
|
await self.load_markets()
|
|
callerMethodName = None
|
|
callerMethodName, params = self.handle_param_string(params, 'callerMethodName', 'watchOrderBookForSymbols')
|
|
channelName = None
|
|
channelName, params = self.handle_option_and_params(params, callerMethodName, 'channel', 'books')
|
|
# due to some problem, temporarily disable other channels
|
|
if channelName != 'books':
|
|
raise NotSupported(self.id + ' ' + callerMethodName + '() at self moment ' + channelName + ' is not supported, coming soon')
|
|
orderbook = await self.watch_multiple_wrapper(True, channelName, callerMethodName, symbols, params)
|
|
return orderbook.limit()
|
|
|
|
def handle_order_book(self, client: Client, message):
|
|
#
|
|
# {
|
|
# arg: {
|
|
# channel: "books",
|
|
# instId: "DOGE-USDT",
|
|
# },
|
|
# action: "snapshot", # can be 'snapshot' or 'update'
|
|
# data: {
|
|
# asks: [ [0.08096, 1], [0.08097, 123], ... ],
|
|
# bids: [ [0.08095, 4], [0.08094, 237], ... ],
|
|
# ts: "1707491587909",
|
|
# prevSeqId: "0", # in case of 'update' there will be some value, less then seqId
|
|
# seqId: "3374250786",
|
|
# },
|
|
# }
|
|
#
|
|
arg = self.safe_dict(message, 'arg')
|
|
channelName = self.safe_string(arg, 'channel')
|
|
data = self.safe_dict(message, 'data')
|
|
marketId = self.safe_string(arg, 'instId')
|
|
market = self.safe_market(marketId)
|
|
symbol = market['symbol']
|
|
messageHash = channelName + ':' + symbol
|
|
if not (symbol in self.orderbooks):
|
|
self.orderbooks[symbol] = self.order_book()
|
|
orderbook = self.orderbooks[symbol]
|
|
timestamp = self.safe_integer(data, 'ts')
|
|
action = self.safe_string(message, 'action')
|
|
if action == 'snapshot':
|
|
orderBookSnapshot = self.parse_order_book(data, symbol, timestamp)
|
|
orderBookSnapshot['nonce'] = self.safe_integer(data, 'seqId')
|
|
orderbook.reset(orderBookSnapshot)
|
|
else:
|
|
asks = self.safe_list(data, 'asks', [])
|
|
bids = self.safe_list(data, 'bids', [])
|
|
self.handle_deltas_with_keys(orderbook['asks'], asks)
|
|
self.handle_deltas_with_keys(orderbook['bids'], bids)
|
|
orderbook['timestamp'] = timestamp
|
|
orderbook['datetime'] = self.iso8601(timestamp)
|
|
self.orderbooks[symbol] = orderbook
|
|
client.resolve(orderbook, messageHash)
|
|
|
|
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.blofin.com/index.html#ws-tickers-channel
|
|
|
|
: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>`
|
|
"""
|
|
params['callerMethodName'] = 'watchTicker'
|
|
market = self.market(symbol)
|
|
symbol = market['symbol']
|
|
result = await self.watch_tickers([symbol], params)
|
|
return result[symbol]
|
|
|
|
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.blofin.com/index.html#ws-tickers-channel
|
|
|
|
: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>`
|
|
"""
|
|
if symbols is None:
|
|
raise NotSupported(self.id + ' watchTickers() requires a list of symbols')
|
|
ticker = await self.watch_multiple_wrapper(True, 'tickers', 'watchTickers', symbols, params)
|
|
if self.newUpdates:
|
|
tickers = {}
|
|
tickers[ticker['symbol']] = ticker
|
|
return tickers
|
|
return self.filter_by_array(self.tickers, 'symbol', symbols)
|
|
|
|
def handle_ticker(self, client: Client, message):
|
|
#
|
|
# message
|
|
#
|
|
# {
|
|
# arg: {
|
|
# channel: "tickers",
|
|
# instId: "DOGE-USDT",
|
|
# },
|
|
# data: [
|
|
# <same object in REST example>
|
|
# ],
|
|
# }
|
|
#
|
|
self.handle_bid_ask(client, message)
|
|
arg = self.safe_dict(message, 'arg')
|
|
channelName = self.safe_string(arg, 'channel')
|
|
data = self.safe_list(message, 'data')
|
|
for i in range(0, len(data)):
|
|
ticker = self.parse_ws_ticker(data[i])
|
|
symbol = ticker['symbol']
|
|
messageHash = channelName + ':' + symbol
|
|
self.tickers[symbol] = ticker
|
|
client.resolve(self.tickers[symbol], messageHash)
|
|
|
|
def parse_ws_ticker(self, ticker, market: Market = None) -> Ticker:
|
|
return self.parse_ticker(ticker, market)
|
|
|
|
async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
|
|
"""
|
|
watches best bid & ask for symbols
|
|
|
|
https://docs.blofin.com/index.html#ws-tickers-channel
|
|
|
|
: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)
|
|
firstMarket = self.market(symbols[0])
|
|
channel = 'tickers'
|
|
marketType = None
|
|
marketType, params = self.handle_market_type_and_params('watchBidsAsks', firstMarket, params)
|
|
url = self.implode_hostname(self.urls['api']['ws'][marketType]['public'])
|
|
messageHashes = []
|
|
args = []
|
|
for i in range(0, len(symbols)):
|
|
market = self.market(symbols[i])
|
|
messageHashes.append('bidask:' + market['symbol'])
|
|
args.append({
|
|
'channel': channel,
|
|
'instId': market['id'],
|
|
})
|
|
request = self.get_subscription_request(args)
|
|
ticker = await self.watch_multiple(url, messageHashes, self.deep_extend(request, params), messageHashes)
|
|
if self.newUpdates:
|
|
tickers = {}
|
|
tickers[ticker['symbol']] = ticker
|
|
return tickers
|
|
return self.filter_by_array(self.bidsasks, 'symbol', symbols)
|
|
|
|
def handle_bid_ask(self, client: Client, message):
|
|
data = self.safe_list(message, 'data')
|
|
for i in range(0, len(data)):
|
|
ticker = self.parse_ws_bid_ask(data[i])
|
|
symbol = ticker['symbol']
|
|
messageHash = 'bidask:' + symbol
|
|
self.bidsasks[symbol] = ticker
|
|
client.resolve(ticker, messageHash)
|
|
|
|
def parse_ws_bid_ask(self, ticker, market=None):
|
|
marketId = self.safe_string(ticker, 'instId')
|
|
market = self.safe_market(marketId, market, '-')
|
|
symbol = self.safe_string(market, 'symbol')
|
|
timestamp = self.safe_integer(ticker, 'ts')
|
|
return self.safe_ticker({
|
|
'symbol': symbol,
|
|
'timestamp': timestamp,
|
|
'datetime': self.iso8601(timestamp),
|
|
'ask': self.safe_string(ticker, 'askPrice'),
|
|
'askVolume': self.safe_string(ticker, 'askSize'),
|
|
'bid': self.safe_string(ticker, 'bidPrice'),
|
|
'bidVolume': self.safe_string(ticker, 'bidSize'),
|
|
'info': ticker,
|
|
}, market)
|
|
|
|
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
|
|
: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
|
|
"""
|
|
params['callerMethodName'] = 'watchOHLCV'
|
|
result = await self.watch_ohlcv_for_symbols([[symbol, timeframe]], since, limit, params)
|
|
return result[symbol][timeframe]
|
|
|
|
async def watch_ohlcv_for_symbols(self, symbolsAndTimeframes: List[List[str]], since: Int = None, limit: Int = None, params={}):
|
|
"""
|
|
watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
|
|
|
|
https://docs.blofin.com/index.html#ws-candlesticks-channel
|
|
|
|
:param str[][] symbolsAndTimeframes: array of arrays containing unified symbols and timeframes to fetch OHLCV data for, example [['BTC/USDT', '1m'], ['LTC/USDT', '5m']]
|
|
: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
|
|
"""
|
|
symbolsLength = len(symbolsAndTimeframes)
|
|
if symbolsLength == 0 or not isinstance(symbolsAndTimeframes[0], list):
|
|
raise ArgumentsRequired(self.id + " watchOHLCVForSymbols() requires a an array of symbols and timeframes, like [['BTC/USDT', '1m'], ['LTC/USDT', '5m']]")
|
|
await self.load_markets()
|
|
symbol, timeframe, candles = await self.watch_multiple_wrapper(True, 'candle', 'watchOHLCVForSymbols', symbolsAndTimeframes, params)
|
|
if self.newUpdates:
|
|
limit = candles.getLimit(symbol, limit)
|
|
filtered = self.filter_by_since_limit(candles, since, limit, 0, True)
|
|
return self.create_ohlcv_object(symbol, timeframe, filtered)
|
|
|
|
def handle_ohlcv(self, client: Client, message):
|
|
#
|
|
# message
|
|
#
|
|
# {
|
|
# arg: {
|
|
# channel: "candle1m",
|
|
# instId: "DOGE-USDT",
|
|
# },
|
|
# data: [
|
|
# [same object in REST example]
|
|
# ],
|
|
# }
|
|
#
|
|
arg = self.safe_dict(message, 'arg')
|
|
channelName = self.safe_string(arg, 'channel')
|
|
data = self.safe_list(message, 'data')
|
|
marketId = self.safe_string(arg, 'instId')
|
|
market = self.safe_market(marketId)
|
|
symbol = market['symbol']
|
|
interval = channelName.replace('candle', '')
|
|
unifiedTimeframe = self.find_timeframe(interval)
|
|
self.ohlcvs[symbol] = self.safe_dict(self.ohlcvs, symbol, {})
|
|
stored = self.safe_value(self.ohlcvs[symbol], unifiedTimeframe)
|
|
if stored is None:
|
|
limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
|
|
stored = ArrayCacheByTimestamp(limit)
|
|
self.ohlcvs[symbol][unifiedTimeframe] = stored
|
|
for i in range(0, len(data)):
|
|
candle = data[i]
|
|
parsed = self.parse_ohlcv(candle, market)
|
|
stored.append(parsed)
|
|
resolveData = [symbol, unifiedTimeframe, stored]
|
|
messageHash = 'candle' + interval + ':' + symbol
|
|
client.resolve(resolveData, messageHash)
|
|
|
|
async def watch_balance(self, params={}) -> Balances:
|
|
"""
|
|
query for balance and get the amount of funds available for trading or funds locked in orders
|
|
|
|
https://docs.blofin.com/index.html#ws-account-channel
|
|
|
|
:param dict [params]: extra parameters specific to the exchange API endpoint
|
|
:returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
|
|
"""
|
|
await self.load_markets()
|
|
await self.authenticate()
|
|
marketType = None
|
|
marketType, params = self.handle_market_type_and_params('watchBalance', None, params)
|
|
if marketType == 'spot':
|
|
raise NotSupported(self.id + ' watchBalance() is not supported for spot markets yet')
|
|
messageHash = marketType + ':balance'
|
|
sub = {
|
|
'channel': 'account',
|
|
}
|
|
request = self.get_subscription_request([sub])
|
|
url = self.implode_hostname(self.urls['api']['ws'][marketType]['private'])
|
|
return await self.watch(url, messageHash, self.deep_extend(request, params), messageHash)
|
|
|
|
def handle_balance(self, client: Client, message):
|
|
#
|
|
# {
|
|
# arg: {
|
|
# channel: "account",
|
|
# },
|
|
# data: <same object in REST example>,
|
|
# }
|
|
#
|
|
marketType = 'swap' # for now
|
|
if not (marketType in self.balance):
|
|
self.balance[marketType] = {}
|
|
self.balance[marketType] = self.parse_ws_balance(message)
|
|
messageHash = marketType + ':balance'
|
|
client.resolve(self.balance[marketType], messageHash)
|
|
|
|
def parse_ws_balance(self, message):
|
|
return self.parse_balance(message)
|
|
|
|
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.blofin.com/index.html#ws-order-channel
|
|
https://docs.blofin.com/index.html#ws-algo-orders-channel
|
|
|
|
: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
|
|
:param boolean [params.trigger]: set to True for trigger orders
|
|
:returns dict[]: a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure
|
|
"""
|
|
params['callerMethodName'] = 'watchOrders'
|
|
symbolsArray = [symbol] if (symbol is not None) else []
|
|
return await self.watch_orders_for_symbols(symbolsArray, since, limit, params)
|
|
|
|
async def watch_orders_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}) -> List[Order]:
|
|
"""
|
|
watches information on multiple orders made by the user across multiple symbols
|
|
|
|
https://docs.blofin.com/index.html#ws-order-channel
|
|
https://docs.blofin.com/index.html#ws-algo-orders-channel
|
|
|
|
:param str[] symbols:
|
|
: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
|
|
:param boolean [params.trigger]: set to True for trigger orders
|
|
:returns dict[]: a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure
|
|
"""
|
|
await self.authenticate()
|
|
await self.load_markets()
|
|
trigger = self.safe_value_2(params, 'stop', 'trigger')
|
|
params = self.omit(params, ['stop', 'trigger'])
|
|
channel = 'orders-algo' if trigger else 'orders'
|
|
orders = await self.watch_multiple_wrapper(False, channel, 'watchOrdersForSymbols', symbols, params)
|
|
if self.newUpdates:
|
|
first = self.safe_value(orders, 0)
|
|
tradeSymbol = self.safe_string(first, 'symbol')
|
|
limit = orders.getLimit(tradeSymbol, limit)
|
|
return self.filter_by_since_limit(orders, since, limit, 'timestamp', True)
|
|
|
|
def handle_orders(self, client: Client, message):
|
|
#
|
|
# {
|
|
# action: 'update',
|
|
# arg: {channel: 'orders'},
|
|
# data: [
|
|
# <same object in REST example>
|
|
# ]
|
|
# }
|
|
#
|
|
if self.orders is None:
|
|
limit = self.safe_integer(self.options, 'ordersLimit', 1000)
|
|
self.orders = ArrayCacheBySymbolById(limit)
|
|
orders = self.orders
|
|
arg = self.safe_dict(message, 'arg')
|
|
channelName = self.safe_string(arg, 'channel')
|
|
data = self.safe_list(message, 'data')
|
|
for i in range(0, len(data)):
|
|
order = self.parse_ws_order(data[i])
|
|
symbol = order['symbol']
|
|
messageHash = channelName + ':' + symbol
|
|
orders.append(order)
|
|
client.resolve(orders, messageHash)
|
|
client.resolve(orders, channelName)
|
|
|
|
def parse_ws_order(self, order, market: Market = None) -> Order:
|
|
return self.parse_order(order, market)
|
|
|
|
async def watch_positions(self, symbols: Strings = None, since: Int = None, limit: Int = None, params={}) -> List[Position]:
|
|
"""
|
|
|
|
https://docs.blofin.com/index.html#ws-positions-channel
|
|
|
|
watch all open positions
|
|
:param str[]|None symbols: list of unified market symbols
|
|
:param int [since]: the earliest time in ms to fetch positions for
|
|
:param int [limit]: the maximum number of positions to retrieve
|
|
:param dict params: extra parameters specific to the exchange API endpoint
|
|
:returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
|
|
"""
|
|
await self.authenticate()
|
|
await self.load_markets()
|
|
newPositions = await self.watch_multiple_wrapper(False, 'positions', 'watchPositions', symbols, params)
|
|
if self.newUpdates:
|
|
return newPositions
|
|
return self.filter_by_symbols_since_limit(self.positions, symbols, since, limit)
|
|
|
|
def handle_positions(self, client: Client, message):
|
|
#
|
|
# {
|
|
# arg: {channel: 'positions'},
|
|
# data: [
|
|
# <same object in REST example>
|
|
# ]
|
|
# }
|
|
#
|
|
if self.positions is None:
|
|
self.positions = ArrayCacheBySymbolBySide()
|
|
cache = self.positions
|
|
arg = self.safe_dict(message, 'arg')
|
|
channelName = self.safe_string(arg, 'channel')
|
|
data = self.safe_list(message, 'data')
|
|
newPositions = []
|
|
for i in range(0, len(data)):
|
|
position = self.parse_ws_position(data[i])
|
|
newPositions.append(position)
|
|
cache.append(position)
|
|
messageHash = channelName + ':' + position['symbol']
|
|
client.resolve(position, messageHash)
|
|
|
|
def parse_ws_position(self, position, market: Market = None) -> Position:
|
|
return self.parse_position(position, market)
|
|
|
|
async def watch_multiple_wrapper(self, isPublic: bool, channelName: str, callerMethodName: str, symbolsArray: List[Any] = None, params={}):
|
|
# underlier method for all watch-multiple symbols
|
|
await self.load_markets()
|
|
callerMethodName, params = self.handle_param_string(params, 'callerMethodName', callerMethodName)
|
|
# if OHLCV method are being called, then symbols would be symbolsAndTimeframes(multi-dimensional) array
|
|
isOHLCV = (channelName == 'candle')
|
|
symbols = self.get_list_from_object_values(symbolsArray, 0) if isOHLCV else symbolsArray
|
|
symbols = self.market_symbols(symbols, None, True, True)
|
|
firstMarket = None
|
|
firstSymbol = self.safe_string(symbols, 0)
|
|
if firstSymbol is not None:
|
|
firstMarket = self.market(firstSymbol)
|
|
marketType = None
|
|
marketType, params = self.handle_market_type_and_params(callerMethodName, firstMarket, params)
|
|
if marketType != 'swap':
|
|
raise NotSupported(self.id + ' ' + callerMethodName + '() does not support ' + marketType + ' markets yet')
|
|
rawSubscriptions = []
|
|
messageHashes = []
|
|
if symbols is None:
|
|
symbols = []
|
|
symbolsLength = len(symbols)
|
|
if symbolsLength > 0:
|
|
for i in range(0, len(symbols)):
|
|
current = symbols[i]
|
|
market = None
|
|
channel = channelName
|
|
if isOHLCV:
|
|
market = self.market(current)
|
|
tfArray = symbolsArray[i]
|
|
tf = tfArray[1]
|
|
interval = self.safe_string(self.timeframes, tf, tf)
|
|
channel += interval
|
|
else:
|
|
market = self.market(current)
|
|
topic = {
|
|
'channel': channel,
|
|
'instId': market['id'],
|
|
}
|
|
rawSubscriptions.append(topic)
|
|
messageHashes.append(channel + ':' + market['symbol'])
|
|
else:
|
|
rawSubscriptions.append({'channel': channelName})
|
|
messageHashes.append(channelName)
|
|
# private channel are difference, they only need plural channel name for multiple symbols
|
|
if self.in_array(channelName, ['orders', 'orders-algo', 'positions']):
|
|
rawSubscriptions = [{'channel': channelName}]
|
|
request = self.get_subscription_request(rawSubscriptions)
|
|
privateOrPublic = 'public' if isPublic else 'private'
|
|
url = self.implode_hostname(self.urls['api']['ws'][marketType][privateOrPublic])
|
|
return await self.watch_multiple(url, messageHashes, self.deep_extend(request, params), messageHashes)
|
|
|
|
def get_subscription_request(self, args):
|
|
return {
|
|
'op': 'subscribe',
|
|
'args': args,
|
|
}
|
|
|
|
def handle_message(self, client: Client, message):
|
|
#
|
|
# message examples
|
|
#
|
|
# {
|
|
# arg: {
|
|
# channel: "trades",
|
|
# instId: "DOGE-USDT",
|
|
# },
|
|
# event: "subscribe"
|
|
# }
|
|
#
|
|
# incoming data updates' examples can be seen under each handler method
|
|
#
|
|
methods = {
|
|
# public
|
|
'pong': self.handle_pong,
|
|
'trades': self.handle_trades,
|
|
'books': self.handle_order_book,
|
|
'tickers': self.handle_ticker,
|
|
'candle': self.handle_ohlcv, # candle1m, candle5m, etc
|
|
# private
|
|
'account': self.handle_balance,
|
|
'orders': self.handle_orders,
|
|
'orders-algo': self.handle_orders,
|
|
'positions': self.handle_positions,
|
|
}
|
|
method = None
|
|
if message == 'pong':
|
|
method = self.safe_value(methods, 'pong')
|
|
else:
|
|
event = self.safe_string(message, 'event')
|
|
if event == 'subscribe':
|
|
return
|
|
elif event == 'login':
|
|
future = self.safe_value(client.futures, 'authenticate_hash')
|
|
future.resolve(True)
|
|
return
|
|
elif event == 'error':
|
|
raise ExchangeError(self.id + ' error: ' + self.json(message))
|
|
arg = self.safe_dict(message, 'arg')
|
|
channelName = self.safe_string(arg, 'channel')
|
|
method = self.safe_value(methods, channelName)
|
|
if not method and channelName.find('candle') >= 0:
|
|
method = methods['candle']
|
|
if method:
|
|
method(client, message)
|
|
|
|
async def authenticate(self, params={}):
|
|
self.check_required_credentials()
|
|
milliseconds = self.milliseconds()
|
|
messageHash = 'authenticate_hash'
|
|
timestamp = str(milliseconds)
|
|
nonce = 'n_' + timestamp
|
|
auth = '/users/self/verify' + 'GET' + timestamp + '' + nonce
|
|
signature = self.string_to_base64(self.hmac(self.encode(auth), self.encode(self.secret), hashlib.sha256))
|
|
request = {
|
|
'op': 'login',
|
|
'args': [
|
|
{
|
|
'apiKey': self.apiKey,
|
|
'passphrase': self.password,
|
|
'timestamp': timestamp,
|
|
'nonce': nonce,
|
|
'sign': signature,
|
|
},
|
|
],
|
|
}
|
|
marketType = 'swap' # for now
|
|
url = self.implode_hostname(self.urls['api']['ws'][marketType]['private'])
|
|
await self.watch(url, messageHash, self.deep_extend(request, params), messageHash)
|