async def subscribe_to_order_book_streams(self, trading_pairs: List[str]):
try:
channels = []
for pair in trading_pairs:
channels.extend(
[
f"{self.DIFF_CHANNEL_ID}.{crypto_com_utils.convert_to_exchange_trading_pair(pair)}.150",
f"{self.TRADE_CHANNEL_ID}.{crypto_com_utils.convert_to_exchange_trading_pair(pair)}",
]
)
subscription_payload = {
self._ID_FIELD_NAME: get_tracking_nonce(),
self._METHOD_FIELD_NAME: self._SUBSCRIPTION_OPERATION,
self._NONCE_FIELD_NAME: get_ms_timestamp(),
self._PARAMS_FIELD_NAME: {self._CHANNEL_PARAMS: channels},
}
await self.send_request(subscription_payload)
except asyncio.CancelledError:
raise
except Exception:
self.logger().error(
"Unexpected error occurred subscribing to order book trading and delta streams...", exc_info=True
)
raise
def get_new_client_order_id(trade_type: TradeType, trading_pair: str) -> str:
side = ""
if trade_type is TradeType.BUY:
side = "buy"
if trade_type is TradeType.SELL:
side = "sell"
tracking_nonce = get_tracking_nonce()
return f"{BROKER_ID}-{side}-{trading_pair}-{tracking_nonce}"
async def generate_ws_auth_dict(self) -> Dict[str, Any]:
session_data = await self.__get_session_data()
headers = {"X-Deltix-Nonce": str(get_tracking_nonce()), "X-Deltix-Session-Id": session_data["session_id"]}
payload = self.__build_ws_payload(headers)
hmac = HMAC.new(key= self.__int_to_bytes(session_data["sign_key"], signed=True), msg=bytes(payload, 'utf-8'), digestmod=SHA384)
digestb64 = base64.b64encode(hmac.digest())
headers["X-Deltix-Signature"] = digestb64.decode('utf-8')
return headers
def sell(self, trading_pair: str, amount: Decimal, order_type: OrderType = OrderType.MARKET,
price: Decimal = s_decimal_NaN, **kwargs) -> str:
tracking_nonce = int(get_tracking_nonce())
order_id = str(f"sell-{trading_pair}-{tracking_nonce}")
safe_ensure_future(self.execute_sell(order_id, trading_pair, amount, order_type, price))
return order_id
def get_client_order_id(order_side: str, trading_pair: object):
nonce = get_tracking_nonce()
symbols: str = trading_pair.split("-")
base: str = symbols[0].upper()
quote: str = symbols[1].upper()
base_str = f"{base[0]}{base[-1]}"
quote_str = f"{quote[0]}{quote[-1]}"
client_instance_id = hex(abs(
hash(f"{socket.gethostname()}{os.getpid()}")))[2:6]
return f"{BROKER_ID}-{order_side.upper()[0]}{base_str}{quote_str}{client_instance_id}{nonce}"
async def authenticate(self):
request_id = get_tracking_nonce()
nonce = get_ms_timestamp()
auth = self._auth.generate_auth_dict(
self.AUTH_REQUEST,
request_id=request_id,
nonce=nonce,
)
auth_payload = {
self._ID_FIELD_NAME: request_id,
self._METHOD_FIELD_NAME: self.AUTH_REQUEST,
self._NONCE_FIELD_NAME: nonce,
self._SIGNATURE_FIELD_NAME: auth["sig"],
self._API_KEY_FIELD_NAME: auth["api_key"],
}
await self.send_request(auth_payload)
async def subscribe_to_user_streams(self):
try:
channels = self._USER_CHANNEL_LIST
subscription_payload = {
self._ID_FIELD_NAME: get_tracking_nonce(),
self._METHOD_FIELD_NAME: self._SUBSCRIPTION_OPERATION,
self._NONCE_FIELD_NAME: get_ms_timestamp(),
self._PARAMS_FIELD_NAME: {self._CHANNEL_PARAMS: channels},
}
await self.send_request(subscription_payload)
self.logger().info("Successfully subscribed to user stream...")
except asyncio.CancelledError:
raise
except Exception:
self.logger().error("Unexpected error occurred subscribing to user streams...", exc_info=True)
raise
async def listen_for_user_stream(self, ev_loop: asyncio.BaseEventLoop,
output: asyncio.Queue):
"""
*required
Subscribe to user stream via web socket, and keep the connection open for incoming messages
:param ev_loop: ev_loop to execute this function in
:param output: an async queue where the incoming messages are stored
"""
while True:
try:
async with websockets.connect(
BeaxyConstants.TradingApi.WS_BASE_URL) as ws:
ws: websockets.WebSocketClientProtocol = ws
connect_request = BeaxyStompMessage("CONNECT")
connect_request.headers = await self._beaxy_auth.generate_ws_auth_dict(
)
await ws.send(connect_request.serialize())
orders_sub_request = BeaxyStompMessage("SUBSCRIBE")
orders_sub_request.headers[
"id"] = f"sub-humming-{get_tracking_nonce()}"
orders_sub_request.headers[
"destination"] = "/user/v1/orders"
orders_sub_request.headers["X-Deltix-Nonce"] = str(
get_tracking_nonce())
await ws.send(orders_sub_request.serialize())
async for raw_msg in self._inner_messages(ws):
stomp_message = BeaxyStompMessage.deserialize(raw_msg)
if stomp_message.has_error():
raise Exception(
f"Got error from ws. Headers - {stomp_message.headers}"
)
msg = ujson.loads(stomp_message.body)
output.put_nowait(msg)
except asyncio.CancelledError:
raise
except Exception:
self.logger().error(
"Unexpected error with Beaxy connection. "
"Retrying after 30 seconds...",
exc_info=True)
await asyncio.sleep(30.0)
def generate_request_id(cls) -> int:
return get_tracking_nonce()
def get_client_order_id(order_side: str, trading_pair: object):
nonce = get_tracking_nonce()
symbols: str = trading_pair.split("-")
base: str = symbols[0].upper()
quote: str = symbols[1].upper()
return f"{BROKER_ID}-{order_side.upper()[0]}{base[0]}{base[-1]}{quote[0]}{quote[-1]}{nonce}"
def next_message_id() -> str:
return str(get_tracking_nonce())
def test_get_tracking_nonce(self):
nonce = tracking_nonce.get_tracking_nonce()
self.assertIsNotNone(nonce)
new_nonce = tracking_nonce.get_tracking_nonce()
self.assertGreater(new_nonce, nonce)
async def task():
return tracking_nonce.get_tracking_nonce()
def get_new_client_order_id(is_buy: bool, trading_pair: str) -> str:
ts_micro_sec: int = get_tracking_nonce()
return f"{HUMMINGBOT_ID_PREFIX}{ts_micro_sec}"
