ccxt 4.2.31__py2.py3-none-any.whl → 4.2.34__py2.py3-none-any.whl

ccxt/pro/ascendex.py

@@ -843,7 +843,6 @@ class ascendex(ccxt.async_support.ascendex):
             self.handle_order(client, message)
             if subject == 'order':
                 self.handle_balance(client, message)
-        return message
 
     def handle_subscription_status(self, client: Client, message):
         #
@@ -879,7 +878,7 @@ class ascendex(ccxt.async_support.ascendex):
     def handle_ping(self, client: Client, message):
         self.spawn(self.pong, client, message)
 
-    def authenticate(self, url, params={}):
+    async def authenticate(self, url, params={}):
         self.check_required_credentials()
         messageHash = 'authenticated'
         client = self.client(url)

ccxt/pro/binance.py

@@ -491,7 +491,7 @@ class binance(ccxt.async_support.binance):
         """
         return await self.watch_trades_for_symbols([symbol], since, limit, params)
 
-    def parse_trade(self, trade, market=None) -> Trade:
+    def parse_ws_trade(self, trade, market=None) -> Trade:
         #
         # public watchTrades
         #
@@ -599,7 +599,7 @@ class binance(ccxt.async_support.binance):
         executionType = self.safe_string(trade, 'x')
         isTradeExecution = (executionType == 'TRADE')
         if not isTradeExecution:
-            return super(binance, self).parse_trade(trade, market)
+            return self.parse_trade(trade, market)
         id = self.safe_string_2(trade, 't', 'a')
         timestamp = self.safe_integer(trade, 'T')
         price = self.safe_string_2(trade, 'L', 'p')
@@ -657,7 +657,7 @@ class binance(ccxt.async_support.binance):
         lowerCaseId = self.safe_string_lower(message, 's')
         event = self.safe_string(message, 'e')
         messageHash = lowerCaseId + '@' + event
-        trade = self.parse_trade(message, market)
+        trade = self.parse_ws_trade(message, market)
         tradesArray = self.safe_value(self.trades, symbol)
         if tradesArray is None:
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
@@ -1146,11 +1146,12 @@ class binance(ccxt.async_support.binance):
             for j in range(0, len(subscriptionKeys)):
                 subscribeType = subscriptionKeys[j]
                 if subscribeType == type:
-                    return self.delay(listenKeyRefreshRate, self.keep_alive_listen_key, params)
+                    self.delay(listenKeyRefreshRate, self.keep_alive_listen_key, params)
+                    return
 
     def set_balance_cache(self, client: Client, type):
         if type in client.subscriptions:
-            return None
+            return
         options = self.safe_value(self.options, 'watchBalance')
         fetchBalanceSnapshot = self.safe_bool(options, 'fetchBalanceSnapshot', False)
         if fetchBalanceSnapshot:
@@ -1245,7 +1246,7 @@ class binance(ccxt.async_support.binance):
         #
         messageHash = self.safe_string(message, 'id')
         result = self.safe_value(message, 'result', {})
-        parsedBalances = self.parse_balance(result, 'spot')
+        parsedBalances = self.parse_balance(result)
         client.resolve(parsedBalances, messageHash)
 
     async def watch_balance(self, params={}) -> Balances:
@@ -2501,12 +2502,14 @@ class binance(ccxt.async_support.binance):
         status = self.safe_string(message, 'status')
         error = self.safe_value(message, 'error')
         if (error is not None) or (status is not None and status != '200'):
-            return self.handle_ws_error(client, message)
+            self.handle_ws_error(client, message)
+            return
         id = self.safe_string(message, 'id')
         subscriptions = self.safe_value(client.subscriptions, id)
         method = self.safe_value(subscriptions, 'method')
         if method is not None:
-            return method(client, message)
+            method(client, message)
+            return
         # handle other APIs
         methods = {
             'depthUpdate': self.handle_order_book,
@@ -2534,7 +2537,8 @@ class binance(ccxt.async_support.binance):
         if method is None:
             requestId = self.safe_string(message, 'id')
             if requestId is not None:
-                return self.handle_subscription_status(client, message)
+                self.handle_subscription_status(client, message)
+                return
             # special case for the real-time bookTicker, since it comes without an event identifier
             #
             #     {
@@ -2550,4 +2554,4 @@ class binance(ccxt.async_support.binance):
                 self.handle_ticker(client, message)
                 self.handle_tickers(client, message)
         else:
-            return method(client, message)
+            method(client, message)

ccxt/pro/bingx.py

@@ -675,7 +675,7 @@ class bingx(ccxt.async_support.bingx):
 
     def set_balance_cache(self, client: Client, type, subscriptionHash, params):
         if subscriptionHash in client.subscriptions:
-            return None
+            return
         fetchBalanceSnapshot = self.handle_option_and_params(params, 'watchBalance', 'fetchBalanceSnapshot', True)
         if fetchBalanceSnapshot:
             messageHash = type + ':fetchBalanceSnapshot'

ccxt/pro/bitfinex.py

@@ -129,7 +129,6 @@ class bitfinex(ccxt.async_support.bitfinex):
             trade = self.parse_trade(message, market)
             stored.append(trade)
         client.resolve(stored, messageHash)
-        return message
 
     def parse_trade(self, trade, market=None) -> Trade:
         #
@@ -308,35 +307,39 @@ class bitfinex(ccxt.async_support.bitfinex):
                     delta = deltas[i]
                     id = self.safe_string(delta, 0)
                     price = self.safe_float(delta, 1)
-                    size = -delta[2] if (delta[2] < 0) else delta[2]
-                    side = 'asks' if (delta[2] < 0) else 'bids'
+                    delta2Value = delta[2]
+                    size = -delta2Value if (delta2Value < 0) else delta2Value
+                    side = 'asks' if (delta2Value < 0) else 'bids'
                     bookside = orderbook[side]
                     bookside.store(price, size, id)
             else:
                 deltas = message[1]
                 for i in range(0, len(deltas)):
                     delta = deltas[i]
-                    size = -delta[2] if (delta[2] < 0) else delta[2]
-                    side = 'asks' if (delta[2] < 0) else 'bids'
-                    bookside = orderbook[side]
-                    bookside.store(delta[0], size, delta[1])
+                    delta2 = delta[2]
+                    size = -delta2 if (delta2 < 0) else delta2
+                    side = 'asks' if (delta2 < 0) else 'bids'
+                    countedBookSide = orderbook[side]
+                    countedBookSide.store(delta[0], size, delta[1])
             client.resolve(orderbook, messageHash)
         else:
             orderbook = self.orderbooks[symbol]
             if isRaw:
                 id = self.safe_string(message, 1)
                 price = self.safe_string(message, 2)
-                size = -message[3] if (message[3] < 0) else message[3]
-                side = 'asks' if (message[3] < 0) else 'bids'
+                message3 = message[3]
+                size = -message3 if (message3 < 0) else message3
+                side = 'asks' if (message3 < 0) else 'bids'
                 bookside = orderbook[side]
                 # price = 0 means that you have to remove the order from your book
                 amount = size if Precise.string_gt(price, '0') else '0'
                 bookside.store(self.parse_number(price), self.parse_number(amount), id)
             else:
-                size = -message[3] if (message[3] < 0) else message[3]
-                side = 'asks' if (message[3] < 0) else 'bids'
-                bookside = orderbook[side]
-                bookside.store(message[1], size, message[2])
+                message3Value = message[3]
+                size = -message3Value if (message3Value < 0) else message3Value
+                side = 'asks' if (message3Value < 0) else 'bids'
+                countedBookSide = orderbook[side]
+                countedBookSide.store(message[1], size, message[2])
             client.resolve(orderbook, messageHash)
 
     def handle_heartbeat(self, client: Client, message):
@@ -579,7 +582,7 @@ class bitfinex(ccxt.async_support.bitfinex):
             #     ]
             #
             if message[1] == 'hb':
-                return message  # skip heartbeats within subscription channels for now
+                return  # skip heartbeats within subscription channels for now
             subscription = self.safe_value(client.subscriptions, channelId, {})
             channel = self.safe_string(subscription, 'channel')
             name = self.safe_string(message, 1)
@@ -593,10 +596,8 @@ class bitfinex(ccxt.async_support.bitfinex):
                 'oc': self.handle_orders,
             }
             method = self.safe_value_2(methods, channel, name)
-            if method is None:
-                return message
-            else:
-                return method(client, message, subscription)
+            if method is not None:
+                method(client, message, subscription)
         else:
             # todo add bitfinex handleErrorMessage
             #
@@ -616,7 +617,5 @@ class bitfinex(ccxt.async_support.bitfinex):
                     'auth': self.handle_authentication_message,
                 }
                 method = self.safe_value(methods, event)
-                if method is None:
-                    return message
-                else:
-                    return method(client, message)
+                if method is not None:
+                    method(client, message)

ccxt/pro/bitfinex2.py

@@ -324,7 +324,6 @@ class bitfinex2(ccxt.async_support.bitfinex2):
             parsed = self.parse_ws_trade(trade, market)
             stored.append(parsed)
         client.resolve(stored, messageHash)
-        return message
 
     def parse_ws_trade(self, trade, market=None):
         #
@@ -563,8 +562,9 @@ class bitfinex2(ccxt.async_support.bitfinex2):
                 deltas = message[1]
                 for i in range(0, len(deltas)):
                     delta = deltas[i]
-                    size = -delta[2] if (delta[2] < 0) else delta[2]
-                    side = 'asks' if (delta[2] < 0) else 'bids'
+                    delta2 = delta[2]
+                    size = -delta2 if (delta2 < 0) else delta2
+                    side = 'asks' if (delta2 < 0) else 'bids'
                     bookside = orderbook[side]
                     idString = self.safe_string(delta, 0)
                     price = self.safe_float(delta, 1)
@@ -587,8 +587,9 @@ class bitfinex2(ccxt.async_support.bitfinex2):
             orderbookItem = self.orderbooks[symbol]
             if isRaw:
                 price = self.safe_string(deltas, 1)
-                size = -deltas[2] if (deltas[2] < 0) else deltas[2]
-                side = 'asks' if (deltas[2] < 0) else 'bids'
+                deltas2 = deltas[2]
+                size = -deltas2 if (deltas2 < 0) else deltas2
+                side = 'asks' if (deltas2 < 0) else 'bids'
                 bookside = orderbookItem[side]
                 # price = 0 means that you have to remove the order from your book
                 amount = size if Precise.string_gt(price, '0') else '0'
@@ -631,7 +632,8 @@ class bitfinex2(ccxt.async_support.bitfinex2):
                 stringArray.append(self.number_to_string(bids[i][1]))
             if ask is not None:
                 stringArray.append(self.number_to_string(asks[i][idToCheck]))
-                stringArray.append(self.number_to_string(-asks[i][1]))
+                aski1 = asks[i][1]
+                stringArray.append(self.number_to_string(-aski1))
         payload = ':'.join(stringArray)
         localChecksum = self.crc32(payload, True)
         responseChecksum = self.safe_integer(message, 2)
@@ -1036,7 +1038,7 @@ class bitfinex2(ccxt.async_support.bitfinex2):
         #
         if isinstance(message, list):
             if message[1] == 'hb':
-                return message  # skip heartbeats within subscription channels for now
+                return  # skip heartbeats within subscription channels for now
             subscription = self.safe_value(client.subscriptions, channelId, {})
             channel = self.safe_string(subscription, 'channel')
             name = self.safe_string(message, 1)
@@ -1061,10 +1063,8 @@ class bitfinex2(ccxt.async_support.bitfinex2):
                 method = self.safe_value(privateMethods, name)
             else:
                 method = self.safe_value_2(publicMethods, name, channel)
-            if method is None:
-                return message
-            else:
-                return method(client, message, subscription)
+            if method is not None:
+                method(client, message, subscription)
         else:
             event = self.safe_string(message, 'event')
             if event is not None:
@@ -1074,7 +1074,5 @@ class bitfinex2(ccxt.async_support.bitfinex2):
                     'auth': self.handle_authentication_message,
                 }
                 method = self.safe_value(methods, event)
-                if method is None:
-                    return message
-                else:
-                    return method(client, message)
+                if method is not None:
+                    method(client, message)

ccxt/pro/bitget.py

@@ -100,7 +100,9 @@ class bitget(ccxt.async_support.bitget):
             instType, params = self.handleProductTypeAndParams(market, params)
         else:
             instType = 'SPOT'
-        instType, params = self.handle_option_and_params(params, 'getInstType', 'instType', instType)
+        instypeAux = None
+        instypeAux, params = self.handle_option_and_params(params, 'getInstType', 'instType', instType)
+        instType = instypeAux
         return [instType, params]
 
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:

ccxt/pro/bitmart.py

@@ -766,7 +766,6 @@ class bitmart(ccxt.async_support.bitmart):
         if isSpot:
             messageHash += ':' + self.safe_string(data[0], 'symbol')
         client.resolve(stored, messageHash)
-        return message
 
     def parse_ws_trade(self, trade, market: Market = None):
         # spot
@@ -864,7 +863,6 @@ class bitmart(ccxt.async_support.bitmart):
             self.tickers[symbol] = ticker
             client.resolve(ticker, 'tickers::swap')
             self.resolve_message_hashes_for_symbol(client, symbol, ticker, 'tickers::')
-        return message
 
     def resolve_message_hashes_for_symbol(self, client, symbol, result, prexif):
         prefixSeparator = '::'
@@ -1357,10 +1355,8 @@ class bitmart(ccxt.async_support.bitmart):
                     'subscribe': self.handle_subscription_status,
                 }
                 method = self.safe_value(methods, event)
-                if method is None:
-                    return message
-                else:
-                    return method(client, message)
+                if method is not None:
+                    method(client, message)
         else:
             methods = {
                 'depth': self.handle_order_book,
@@ -1377,4 +1373,4 @@ class bitmart(ccxt.async_support.bitmart):
                 key = keys[i]
                 if channel.find(key) >= 0:
                     method = self.safe_value(methods, key)
-                    return method(client, message)
+                    method(client, message)

ccxt/pro/bitmex.py

@@ -1462,7 +1462,7 @@ class bitmex(ccxt.async_support.bitmex):
         #
         #     {"error": "Rate limit exceeded, retry in 29 seconds."}
         #
-        error = self.safe_value(message, 'error')
+        error = self.safe_string(message, 'error')
         if error is not None:
             request = self.safe_value(message, 'request', {})
             args = self.safe_value(request, 'args', [])
@@ -1473,7 +1473,7 @@ class bitmex(ccxt.async_support.bitmex):
                 broadKey = self.find_broadly_matched_key(broad, error)
                 exception = None
                 if broadKey is None:
-                    exception = ExchangeError(error)
+                    exception = ExchangeError(error)  # c# requirement for now
                 else:
                     exception = broad[broadKey](error)
                 client.reject(exception, messageHash)
@@ -1537,8 +1537,6 @@ class bitmex(ccxt.async_support.bitmex):
                 request = self.safe_value(message, 'request', {})
                 op = self.safe_value(request, 'op')
                 if op == 'authKeyExpires':
-                    return self.handle_authentication_message(client, message)
-                else:
-                    return message
+                    self.handle_authentication_message(client, message)
             else:
-                return method(client, message)
+                method(client, message)

ccxt/pro/bitopro.py

@@ -440,7 +440,5 @@ class bitopro(ccxt.async_support.bitopro):
         }
         event = self.safe_string(message, 'event')
         method = self.safe_value(methods, event)
-        if method is None:
-            return message
-        else:
-            return method(client, message)
+        if method is not None:
+            method(client, message)

ccxt/pro/bitrue.py

@@ -408,7 +408,7 @@ class bitrue(ccxt.async_support.bitrue):
             except Exception as error:
                 self.options['listenKey'] = None
                 self.options['listenKeyUrl'] = None
-                return
+                return None
             #
             #     {
             #         "msg": "succ",

ccxt/pro/bitstamp.py

@@ -482,9 +482,9 @@ class bitstamp(ccxt.async_support.bitstamp):
         #
         event = self.safe_string(message, 'event')
         if event == 'bts:subscription_succeeded':
-            return self.handle_subscription_status(client, message)
+            self.handle_subscription_status(client, message)
         else:
-            return self.handle_subject(client, message)
+            self.handle_subject(client, message)
 
     async def authenticate(self, params={}):
         self.check_required_credentials()
@@ -506,7 +506,6 @@ class bitstamp(ccxt.async_support.bitstamp):
                 self.options['expiresIn'] = self.sum(time, validity)
                 self.options['userId'] = userId
                 self.options['wsSessionToken'] = sessionToken
-                return response
 
     async def subscribe_private(self, subscription, messageHash, params={}):
         url = self.urls['api']['ws']

ccxt/pro/bitvavo.py

@@ -400,7 +400,7 @@ class bitvavo(ccxt.async_support.bitvavo):
         #
         response = self.safe_value(message, 'response')
         if response is None:
-            return message
+            return
         marketId = self.safe_string(response, 'market')
         symbol = self.safe_symbol(marketId, None, '-')
         name = 'book'
@@ -502,7 +502,7 @@ class bitvavo(ccxt.async_support.bitvavo):
             limit = trades.getLimit(symbol, limit)
         return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
 
-    async def create_order_ws(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}) -> Order:
+    async def create_order_ws(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: float = None, params={}) -> Order:
         """
         create a trade order
         :see: https://docs.bitvavo.com/#tag/Orders/paths/~1order/post
@@ -1122,7 +1122,7 @@ class bitvavo(ccxt.async_support.bitvavo):
                 method(client, message, subscription)
         return message
 
-    def authenticate(self, params={}):
+    async def authenticate(self, params={}):
         url = self.urls['api']['ws']
         client = self.client(url)
         messageHash = 'authenticated'
@@ -1259,7 +1259,12 @@ class bitvavo(ccxt.async_support.bitvavo):
             'getCandles': self.handle_fetch_ohlcv,
             'getMarkets': self.handle_markets,
         }
-        event = self.safe_string_2(message, 'event', 'action')
+        event = self.safe_string(message, 'event')
         method = self.safe_value(methods, event)
-        if method is not None:
+        if method is None:
+            action = self.safe_string(message, 'action')
+            method = self.safe_value(methods, action)
+            if method is not None:
+                method(client, message)
+        else:
             method(client, message)

ccxt/pro/blockchaincom.py

@@ -107,7 +107,7 @@ class blockchaincom(ccxt.async_support.blockchaincom):
         #
         event = self.safe_string(message, 'event')
         if event == 'subscribed':
-            return message
+            return
         result = {'info': message}
         balances = self.safe_value(message, 'balances', [])
         for i in range(0, len(balances)):
@@ -172,10 +172,9 @@ class blockchaincom(ccxt.async_support.blockchaincom):
         #     }
         #
         event = self.safe_string(message, 'event')
-        if event == 'subscribed':
-            return message
-        elif event == 'rejected':
-            raise ExchangeError(self.id + ' ' + self.json(message))
+        if event == 'rejected':
+            jsonMessage = self.json(message)
+            raise ExchangeError(self.id + ' ' + jsonMessage)
         elif event == 'updated':
             marketId = self.safe_string(message, 'symbol')
             symbol = self.safe_symbol(marketId, None, '-')
@@ -192,7 +191,7 @@ class blockchaincom(ccxt.async_support.blockchaincom):
                 self.ohlcvs[symbol][timeframe] = stored
             stored.append(ohlcv)
             client.resolve(stored, messageHash)
-        else:
+        elif event != 'subscribed':
             raise NotSupported(self.id + ' ' + self.json(message))
 
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
@@ -251,7 +250,7 @@ class blockchaincom(ccxt.async_support.blockchaincom):
         symbol = market['symbol']
         ticker = None
         if event == 'subscribed':
-            return message
+            return
         elif event == 'snapshot':
             ticker = self.parse_ticker(message, market)
         elif event == 'updated':
@@ -345,7 +344,7 @@ class blockchaincom(ccxt.async_support.blockchaincom):
         #
         event = self.safe_string(message, 'event')
         if event != 'updated':
-            return message
+            return
         marketId = self.safe_string(message, 'symbol')
         symbol = self.safe_symbol(marketId)
         market = self.safe_market(marketId)
@@ -500,7 +499,7 @@ class blockchaincom(ccxt.async_support.blockchaincom):
             limit = self.safe_integer(self.options, 'ordersLimit', 1000)
             self.orders = ArrayCacheBySymbolById(limit)
         if event == 'subscribed':
-            return message
+            return
         elif event == 'rejected':
             raise ExchangeError(self.id + ' ' + self.json(message))
         elif event == 'snapshot':
@@ -662,25 +661,25 @@ class blockchaincom(ccxt.async_support.blockchaincom):
         messageHash = 'orderbook:' + symbol + ':' + type
         datetime = self.safe_string(message, 'timestamp')
         timestamp = self.parse8601(datetime)
-        storedOrderBook = self.safe_value(self.orderbooks, symbol)
-        if storedOrderBook is None:
-            storedOrderBook = self.counted_order_book({})
-            self.orderbooks[symbol] = storedOrderBook
+        orderbook = self.safe_value(self.orderbooks, symbol)
+        if orderbook is None:
+            orderbook = self.counted_order_book({})
+            self.orderbooks[symbol] = orderbook
         if event == 'subscribed':
-            return message
+            return
         elif event == 'snapshot':
             snapshot = self.parse_order_book(message, symbol, timestamp, 'bids', 'asks', 'px', 'qty', 'num')
-            storedOrderBook.reset(snapshot)
+            orderbook.reset(snapshot)
         elif event == 'updated':
             asks = self.safe_value(message, 'asks', [])
             bids = self.safe_value(message, 'bids', [])
-            self.handle_deltas(storedOrderBook['asks'], asks)
-            self.handle_deltas(storedOrderBook['bids'], bids)
-            storedOrderBook['timestamp'] = timestamp
-            storedOrderBook['datetime'] = datetime
+            self.handle_deltas(orderbook['asks'], asks)
+            self.handle_deltas(orderbook['bids'], bids)
+            orderbook['timestamp'] = timestamp
+            orderbook['datetime'] = datetime
         else:
             raise NotSupported(self.id + ' watchOrderBook() does not support ' + event + ' yet')
-        client.resolve(storedOrderBook, messageHash)
+        client.resolve(orderbook, messageHash)
 
     def handle_delta(self, bookside, delta):
         bookArray = self.parse_bid_ask(delta, 'px', 'qty', 'num')
@@ -717,7 +716,8 @@ class blockchaincom(ccxt.async_support.blockchaincom):
         }
         handler = self.safe_value(handlers, channel)
         if handler is not None:
-            return handler(client, message)
+            handler(client, message)
+            return
         raise NotSupported(self.id + ' received an unsupported message: ' + self.json(message))
 
     def handle_authentication_message(self, client: Client, message):
@@ -736,7 +736,7 @@ class blockchaincom(ccxt.async_support.blockchaincom):
         if future is not None:
             future.resolve(True)
 
-    def authenticate(self, params={}):
+    async def authenticate(self, params={}):
         url = self.urls['api']['ws']
         client = self.client(url)
         messageHash = 'authenticated'

ccxt/pro/bybit.py

@@ -853,7 +853,7 @@ class bybit(ccxt.async_support.bybit):
         """
         :see: https://bybit-exchange.github.io/docs/v5/websocket/private/position
         watch all open positions
-        :param str[]|None symbols: list of unified market symbols
+        :param str[] [symbols]: list of unified market symbols
         :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>`
         """
@@ -883,7 +883,7 @@ class bybit(ccxt.async_support.bybit):
 
     def set_positions_cache(self, client: Client, symbols: Strings = None):
         if self.positions is not None:
-            return self.positions
+            return
         fetchPositionsSnapshot = self.handle_option('watchPositions', 'fetchPositionsSnapshot', True)
         if fetchPositionsSnapshot:
             messageHash = 'fetchPositionsSnapshot'
@@ -1002,7 +1002,7 @@ class bybit(ccxt.async_support.bybit):
             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):
+    def handle_order(self, client: Client, message):
         #
         #     spot
         #     {
@@ -1532,7 +1532,7 @@ class bybit(ccxt.async_support.bybit):
         authenticated = self.safe_value(client.subscriptions, messageHash)
         if authenticated is None:
             expiresInt = self.milliseconds() + 10000
-            expires = str(expiresInt)
+            expires = self.number_to_string(expiresInt)
             path = 'GET/realtime'
             auth = path + expires
             signature = self.hmac(self.encode(auth), self.encode(self.secret), hashlib.sha256, 'hex')
@@ -1544,7 +1544,7 @@ class bybit(ccxt.async_support.bybit):
             }
             message = self.extend(request, params)
             self.watch(url, messageHash, message, messageHash)
-        return future
+        return await future
 
     def handle_error_message(self, client: Client, message):
         #

ccxt/pro/cex.py

@@ -912,15 +912,15 @@ class cex(ccxt.async_support.cex):
         messageHash = 'orderbook:' + symbol
         timestamp = self.safe_integer_2(data, 'timestamp_ms', 'timestamp')
         incrementalId = self.safe_number(data, 'id')
-        storedOrderBook = self.order_book({})
+        orderbook = self.order_book({})
         snapshot = self.parse_order_book(data, symbol, timestamp, 'bids', 'asks')
         snapshot['nonce'] = incrementalId
-        storedOrderBook.reset(snapshot)
+        orderbook.reset(snapshot)
         self.options['orderbook'][symbol] = {
             'incrementalId': incrementalId,
         }
-        self.orderbooks[symbol] = storedOrderBook
-        client.resolve(storedOrderBook, messageHash)
+        self.orderbooks[symbol] = orderbook
+        client.resolve(orderbook, messageHash)
 
     def pair_to_symbol(self, pair):
         parts = pair.split(':')
@@ -1355,7 +1355,8 @@ class cex(ccxt.async_support.cex):
     def handle_message(self, client: Client, message):
         ok = self.safe_string(message, 'ok')
         if ok == 'error':
-            return self.handle_error_message(client, message)
+            self.handle_error_message(client, message)
+            return
         event = self.safe_string(message, 'e')
         handlers = {
             'auth': self.handle_authentication_message,
@@ -1382,8 +1383,7 @@ class cex(ccxt.async_support.cex):
         }
         handler = self.safe_value(handlers, event)
         if handler is not None:
-            return handler(client, message)
-        return message
+            handler(client, message)
 
     def handle_authentication_message(self, client: Client, message):
         #

ccxt/pro/coinbase.py

@@ -437,7 +437,8 @@ class coinbase(ccxt.async_support.coinbase):
             side = self.safe_string(self.options['sides'], sideId)
             price = self.safe_number(trade, 'price_level')
             amount = self.safe_number(trade, 'new_quantity')
-            orderbook[side].store(price, amount)
+            orderbookSide = orderbook[side]
+            orderbookSide.store(price, amount)
 
     def handle_order_book(self, client, message):
         #
@@ -525,4 +526,4 @@ class coinbase(ccxt.async_support.coinbase):
             errorMessage = self.safe_string(message, 'message')
             raise ExchangeError(errorMessage)
         method = self.safe_value(methods, channel)
-        return method(client, message)
+        method(client, message)