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}"