580 lines
22 KiB
Python
580 lines
22 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
|
|
import hashlib
|
|
from ccxt.base.types import Any, Balances, Bool, Int, Order, OrderBook, Str, 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 BadRequest
|
|
from ccxt.base.errors import BadSymbol
|
|
|
|
|
|
class hollaex(ccxt.async_support.hollaex):
|
|
|
|
def describe(self) -> Any:
|
|
return self.deep_extend(super(hollaex, self).describe(), {
|
|
'has': {
|
|
'ws': True,
|
|
'watchBalance': True,
|
|
'watchMyTrades': False,
|
|
'watchOHLCV': False,
|
|
'watchOrderBook': True,
|
|
'watchOrders': True,
|
|
'watchTicker': False,
|
|
'watchTickers': False, # for now
|
|
'watchTrades': True,
|
|
'watchTradesForSymbols': False,
|
|
},
|
|
'urls': {
|
|
'api': {
|
|
'ws': 'wss://api.hollaex.com/stream',
|
|
},
|
|
'test': {
|
|
'ws': 'wss://api.sandbox.hollaex.com/stream',
|
|
},
|
|
},
|
|
'options': {
|
|
'watchBalance': {
|
|
# 'api-expires': None,
|
|
},
|
|
'watchOrders': {
|
|
# 'api-expires': None,
|
|
},
|
|
},
|
|
'streaming': {
|
|
'ping': self.ping,
|
|
},
|
|
'exceptions': {
|
|
'ws': {
|
|
'exact': {
|
|
'Bearer or HMAC authentication required': BadSymbol, # {error: 'Bearer or HMAC authentication required'}
|
|
'Error: wrong input': BadRequest, # {error: 'Error: wrong input'}
|
|
},
|
|
},
|
|
},
|
|
})
|
|
|
|
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://apidocs.hollaex.com/#sending-receiving-messages
|
|
|
|
: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)
|
|
messageHash = 'orderbook' + ':' + market['id']
|
|
orderbook = await self.watch_public(messageHash, params)
|
|
return orderbook.limit()
|
|
|
|
def handle_order_book(self, client: Client, message):
|
|
#
|
|
# {
|
|
# "topic":"orderbook",
|
|
# "action":"partial",
|
|
# "symbol":"ltc-usdt",
|
|
# "data":{
|
|
# "bids":[
|
|
# [104.29, 5.2264],
|
|
# [103.86,1.3629],
|
|
# [101.82,0.5942]
|
|
# ],
|
|
# "asks":[
|
|
# [104.81,9.5531],
|
|
# [105.54,0.6416],
|
|
# [106.18,1.4141],
|
|
# ],
|
|
# "timestamp":"2022-04-12T08:17:05.932Z"
|
|
# },
|
|
# "time":1649751425
|
|
# }
|
|
#
|
|
marketId = self.safe_string(message, 'symbol')
|
|
channel = self.safe_string(message, 'topic')
|
|
market = self.safe_market(marketId)
|
|
symbol = market['symbol']
|
|
data = self.safe_value(message, 'data')
|
|
timestamp = self.safe_string(data, 'timestamp')
|
|
timestampMs = self.parse8601(timestamp)
|
|
snapshot = self.parse_order_book(data, symbol, timestampMs)
|
|
orderbook = None
|
|
if not (symbol in self.orderbooks):
|
|
orderbook = self.order_book(snapshot)
|
|
self.orderbooks[symbol] = orderbook
|
|
else:
|
|
orderbook = self.orderbooks[symbol]
|
|
orderbook.reset(snapshot)
|
|
messageHash = channel + ':' + marketId
|
|
client.resolve(orderbook, messageHash)
|
|
|
|
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://apidocs.hollaex.com/#sending-receiving-messages
|
|
|
|
: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 = 'trade' + ':' + market['id']
|
|
trades = await self.watch_public(messageHash, 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):
|
|
#
|
|
# {
|
|
# "topic": "trade",
|
|
# "action": "partial",
|
|
# "symbol": "btc-usdt",
|
|
# "data": [
|
|
# {
|
|
# "size": 0.05145,
|
|
# "price": 41977.9,
|
|
# "side": "buy",
|
|
# "timestamp": "2022-04-11T09:40:10.881Z"
|
|
# },
|
|
# ]
|
|
# }
|
|
#
|
|
channel = self.safe_string(message, 'topic')
|
|
marketId = self.safe_string(message, 'symbol')
|
|
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(message, 'data', [])
|
|
parsedTrades = self.parse_trades(data, market)
|
|
for j in range(0, len(parsedTrades)):
|
|
stored.append(parsedTrades[j])
|
|
messageHash = channel + ':' + marketId
|
|
client.resolve(stored, messageHash)
|
|
client.resolve(stored, channel)
|
|
|
|
async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
|
|
"""
|
|
watches information on multiple trades made by the user
|
|
|
|
https://apidocs.hollaex.com/#sending-receiving-messages
|
|
|
|
:param str symbol: unified market symbol of the market trades were made in
|
|
:param int [since]: the earliest time in ms to fetch trades for
|
|
:param int [limit]: the maximum number of trade 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>`
|
|
"""
|
|
await self.load_markets()
|
|
messageHash = 'usertrade'
|
|
market = None
|
|
if symbol is not None:
|
|
market = self.market(symbol)
|
|
symbol = market['symbol']
|
|
messageHash += ':' + market['id']
|
|
trades = await self.watch_private(messageHash, 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):
|
|
#
|
|
# {
|
|
# "topic":"usertrade",
|
|
# "action":"insert",
|
|
# "user_id":"103",
|
|
# "symbol":"xht-usdt",
|
|
# "data":[
|
|
# {
|
|
# "size":1,
|
|
# "side":"buy",
|
|
# "price":0.24,
|
|
# "symbol":"xht-usdt",
|
|
# "timestamp":"2022-05-13T09:30:15.014Z",
|
|
# "order_id":"6065a66e-e9a4-44a3-9726-4f8fa54b6bb6",
|
|
# "fee":0.001,
|
|
# "fee_coin":"xht",
|
|
# "is_same":true
|
|
# }
|
|
# ],
|
|
# "time":1652434215
|
|
# }
|
|
#
|
|
channel = self.safe_string(message, 'topic')
|
|
rawTrades = self.safe_value(message, 'data')
|
|
# usually the first message is an empty array
|
|
# when the user does not have any trades yet
|
|
dataLength = len(rawTrades)
|
|
if dataLength == 0:
|
|
return
|
|
if self.myTrades is None:
|
|
limit = self.safe_integer(self.options, 'tradesLimit', 1000)
|
|
self.myTrades = ArrayCache(limit)
|
|
stored = self.myTrades
|
|
marketIds: dict = {}
|
|
for i in range(0, len(rawTrades)):
|
|
trade = rawTrades[i]
|
|
parsed = self.parse_trade(trade)
|
|
stored.append(parsed)
|
|
symbol = trade['symbol']
|
|
market = self.market(symbol)
|
|
marketId = market['id']
|
|
marketIds[marketId] = True
|
|
# non-symbol specific
|
|
client.resolve(self.myTrades, channel)
|
|
keys = list(marketIds.keys())
|
|
for i in range(0, len(keys)):
|
|
marketId = keys[i]
|
|
messageHash = channel + ':' + marketId
|
|
client.resolve(self.myTrades, messageHash)
|
|
|
|
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://apidocs.hollaex.com/#sending-receiving-messages
|
|
|
|
: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>`
|
|
"""
|
|
await self.load_markets()
|
|
messageHash = 'order'
|
|
market = None
|
|
if symbol is not None:
|
|
market = self.market(symbol)
|
|
symbol = market['symbol']
|
|
messageHash += ':' + market['id']
|
|
orders = await self.watch_private(messageHash, params)
|
|
if self.newUpdates:
|
|
limit = orders.getLimit(symbol, limit)
|
|
return self.filter_by_symbol_since_limit(orders, symbol, since, limit, True)
|
|
|
|
def handle_order(self, client: Client, message, subscription=None):
|
|
#
|
|
# {
|
|
# "topic": "order",
|
|
# "action": "insert",
|
|
# "user_id": 155328,
|
|
# "symbol": "ltc-usdt",
|
|
# "data": {
|
|
# "symbol": "ltc-usdt",
|
|
# "side": "buy",
|
|
# "size": 0.05,
|
|
# "type": "market",
|
|
# "price": 0,
|
|
# "fee_structure": {maker: 0.1, taker: 0.1},
|
|
# "fee_coin": "ltc",
|
|
# "id": "ce38fd48-b336-400b-812b-60c636454231",
|
|
# "created_by": 155328,
|
|
# "filled": 0.05,
|
|
# "method": "market",
|
|
# "created_at": "2022-04-11T14:09:00.760Z",
|
|
# "updated_at": "2022-04-11T14:09:00.760Z",
|
|
# "status": "filled"
|
|
# },
|
|
# "time": 1649686140
|
|
# }
|
|
#
|
|
# {
|
|
# "topic":"order",
|
|
# "action":"partial",
|
|
# "user_id":155328,
|
|
# "data":[
|
|
# {
|
|
# "created_at":"2022-05-13T08:19:07.694Z",
|
|
# "fee":0,
|
|
# "meta":{
|
|
#
|
|
# },
|
|
# "symbol":"ltc-usdt",
|
|
# "side":"buy",
|
|
# "size":0.1,
|
|
# "type":"limit",
|
|
# "price":55,
|
|
# "fee_structure":{
|
|
# "maker":0.1,
|
|
# "taker":0.1
|
|
# },
|
|
# "fee_coin":"ltc",
|
|
# "id":"d5e77182-ad4c-4ac9-8ce4-a97f9b43e33c",
|
|
# "created_by":155328,
|
|
# "filled":0,
|
|
# "status":"new",
|
|
# "updated_at":"2022-05-13T08:19:07.694Z",
|
|
# "stop":null
|
|
# }
|
|
# ],
|
|
# "time":1652430035
|
|
# }
|
|
#
|
|
channel = self.safe_string(message, 'topic')
|
|
data = self.safe_value(message, 'data', {})
|
|
# usually the first message is an empty array
|
|
dataLength = len(data)
|
|
if dataLength == 0:
|
|
return
|
|
if self.orders is None:
|
|
limit = self.safe_integer(self.options, 'ordersLimit', 1000)
|
|
self.orders = ArrayCacheBySymbolById(limit)
|
|
stored = self.orders
|
|
rawOrders = None
|
|
if not isinstance(data, list):
|
|
rawOrders = [data]
|
|
else:
|
|
rawOrders = data
|
|
marketIds: dict = {}
|
|
for i in range(0, len(rawOrders)):
|
|
order = rawOrders[i]
|
|
parsed = self.parse_order(order)
|
|
stored.append(parsed)
|
|
symbol = order['symbol']
|
|
market = self.market(symbol)
|
|
marketId = market['id']
|
|
marketIds[marketId] = True
|
|
# non-symbol specific
|
|
client.resolve(self.orders, channel)
|
|
keys = list(marketIds.keys())
|
|
for i in range(0, len(keys)):
|
|
marketId = keys[i]
|
|
messageHash = channel + ':' + marketId
|
|
client.resolve(self.orders, messageHash)
|
|
|
|
async def watch_balance(self, params={}) -> Balances:
|
|
"""
|
|
watch balance and get the amount of funds available for trading or funds locked in orders
|
|
|
|
https://apidocs.hollaex.com/#sending-receiving-messages
|
|
|
|
:param dict [params]: extra parameters specific to the exchange API endpoint
|
|
:returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
|
|
"""
|
|
messageHash = 'wallet'
|
|
return await self.watch_private(messageHash, params)
|
|
|
|
def handle_balance(self, client: Client, message):
|
|
#
|
|
# {
|
|
# "topic": "wallet",
|
|
# "action": "partial",
|
|
# "user_id": 155328,
|
|
# "data": {
|
|
# "eth_balance": 0,
|
|
# "eth_available": 0,
|
|
# "usdt_balance": 18.94344188,
|
|
# "usdt_available": 18.94344188,
|
|
# "ltc_balance": 0.00005,
|
|
# "ltc_available": 0.00005,
|
|
# },
|
|
# "time": 1649687396
|
|
# }
|
|
#
|
|
messageHash = self.safe_string(message, 'topic')
|
|
data = self.safe_value(message, 'data')
|
|
keys = list(data.keys())
|
|
timestamp = self.safe_timestamp(message, 'time')
|
|
self.balance['info'] = data
|
|
self.balance['timestamp'] = timestamp
|
|
self.balance['datetime'] = self.iso8601(timestamp)
|
|
for i in range(0, len(keys)):
|
|
key = keys[i]
|
|
parts = key.split('_')
|
|
currencyId = self.safe_string(parts, 0)
|
|
code = self.safe_currency_code(currencyId)
|
|
account = self.balance[code] if (code in self.balance) else self.account()
|
|
second = self.safe_string(parts, 1)
|
|
freeOrTotal = 'free' if (second == 'available') else 'total'
|
|
account[freeOrTotal] = self.safe_string(data, key)
|
|
self.balance[code] = account
|
|
self.balance = self.safe_balance(self.balance)
|
|
client.resolve(self.balance, messageHash)
|
|
|
|
async def watch_public(self, messageHash, params={}):
|
|
url = self.urls['api']['ws']
|
|
request: dict = {
|
|
'op': 'subscribe',
|
|
'args': [messageHash],
|
|
}
|
|
message = self.extend(request, params)
|
|
return await self.watch(url, messageHash, message, messageHash)
|
|
|
|
async def watch_private(self, messageHash, params={}):
|
|
self.check_required_credentials()
|
|
expires = self.safe_string(self.options, 'ws-expires')
|
|
if expires is None:
|
|
timeout = int((self.timeout / str(1000)))
|
|
expires = self.sum(self.seconds(), timeout)
|
|
expires = str(expires)
|
|
# we need to memoize these values to avoid generating a new url on each method execution
|
|
# that would trigger a new connection on each received message
|
|
self.options['ws-expires'] = expires
|
|
url = self.urls['api']['ws']
|
|
auth = 'CONNECT' + '/stream' + expires
|
|
signature = self.hmac(self.encode(auth), self.encode(self.secret), hashlib.sha256)
|
|
authParams: dict = {
|
|
'api-key': self.apiKey,
|
|
'api-signature': signature,
|
|
'api-expires': expires,
|
|
}
|
|
signedUrl = url + '?' + self.urlencode(authParams)
|
|
request: dict = {
|
|
'op': 'subscribe',
|
|
'args': [messageHash],
|
|
}
|
|
message = self.extend(request, params)
|
|
return await self.watch(signedUrl, messageHash, message, messageHash)
|
|
|
|
def handle_error_message(self, client: Client, message) -> Bool:
|
|
#
|
|
# {error: "Bearer or HMAC authentication required"}
|
|
# {error: "Error: wrong input"}
|
|
#
|
|
error = self.safe_integer(message, 'error')
|
|
try:
|
|
if error is not None:
|
|
feedback = self.id + ' ' + self.json(message)
|
|
self.throw_exactly_matched_exception(self.exceptions['ws']['exact'], error, feedback)
|
|
except Exception as e:
|
|
if isinstance(e, AuthenticationError):
|
|
return False
|
|
return message
|
|
|
|
def handle_message(self, client: Client, message):
|
|
#
|
|
# pong
|
|
#
|
|
# {message: "pong"}
|
|
#
|
|
# trade
|
|
#
|
|
# {
|
|
# "topic": "trade",
|
|
# "action": "partial",
|
|
# "symbol": "btc-usdt",
|
|
# "data": [
|
|
# {
|
|
# "size": 0.05145,
|
|
# "price": 41977.9,
|
|
# "side": "buy",
|
|
# "timestamp": "2022-04-11T09:40:10.881Z"
|
|
# },
|
|
# ]
|
|
# }
|
|
#
|
|
# orderbook
|
|
#
|
|
# {
|
|
# "topic": "orderbook",
|
|
# "action": "partial",
|
|
# "symbol": "ltc-usdt",
|
|
# "data": {
|
|
# "bids": [
|
|
# [104.29, 5.2264],
|
|
# [103.86,1.3629],
|
|
# [101.82,0.5942]
|
|
# ],
|
|
# "asks": [
|
|
# [104.81,9.5531],
|
|
# [105.54,0.6416],
|
|
# [106.18,1.4141],
|
|
# ],
|
|
# "timestamp": "2022-04-11T10:37:01.227Z"
|
|
# },
|
|
# "time": 1649673421
|
|
# }
|
|
#
|
|
# order
|
|
#
|
|
# {
|
|
# "topic": "order",
|
|
# "action": "insert",
|
|
# "user_id": 155328,
|
|
# "symbol": "ltc-usdt",
|
|
# "data": {
|
|
# "symbol": "ltc-usdt",
|
|
# "side": "buy",
|
|
# "size": 0.05,
|
|
# "type": "market",
|
|
# "price": 0,
|
|
# "fee_structure": {maker: 0.1, taker: 0.1},
|
|
# "fee_coin": "ltc",
|
|
# "id": "ce38fd48-b336-400b-812b-60c636454231",
|
|
# "created_by": 155328,
|
|
# "filled": 0.05,
|
|
# "method": "market",
|
|
# "created_at": "2022-04-11T14:09:00.760Z",
|
|
# "updated_at": "2022-04-11T14:09:00.760Z",
|
|
# "status": "filled"
|
|
# },
|
|
# "time": 1649686140
|
|
# }
|
|
#
|
|
# balance
|
|
#
|
|
# {
|
|
# "topic": "wallet",
|
|
# "action": "partial",
|
|
# "user_id": 155328,
|
|
# "data": {
|
|
# "eth_balance": 0,
|
|
# "eth_available": 0,
|
|
# "usdt_balance": 18.94344188,
|
|
# "usdt_available": 18.94344188,
|
|
# "ltc_balance": 0.00005,
|
|
# "ltc_available": 0.00005,
|
|
# }
|
|
# }
|
|
#
|
|
if not self.handle_error_message(client, message):
|
|
return
|
|
content = self.safe_string(message, 'message')
|
|
if content == 'pong':
|
|
self.handle_pong(client, message)
|
|
return
|
|
methods: dict = {
|
|
'trade': self.handle_trades,
|
|
'orderbook': self.handle_order_book,
|
|
'order': self.handle_order,
|
|
'wallet': self.handle_balance,
|
|
'usertrade': self.handle_my_trades,
|
|
}
|
|
topic = self.safe_value(message, 'topic')
|
|
method = self.safe_value(methods, topic)
|
|
if method is not None:
|
|
method(client, message)
|
|
|
|
def ping(self, client: Client):
|
|
# hollaex does not support built-in ws protocol-level ping-pong
|
|
return {'op': 'ping'}
|
|
|
|
def handle_pong(self, client: Client, message):
|
|
client.lastPong = self.milliseconds()
|
|
return message
|
|
|
|
def on_error(self, client: Client, error):
|
|
self.options['ws-expires'] = None
|
|
super(hollaex, self).on_error(client, error)
|
|
|
|
def on_close(self, client: Client, error):
|
|
self.options['ws-expires'] = None
|
|
super(hollaex, self).on_close(client, error)
|