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

ccxt/pro/kucoinfutures.py

@@ -64,18 +64,19 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
             },
         })
 
-    def negotiate(self, privateChannel, params={}):
+    async def negotiate(self, privateChannel, params={}):
         connectId = 'private' if privateChannel else 'public'
         urls = self.safe_value(self.options, 'urls', {})
         spawaned = self.safe_value(urls, connectId)
         if spawaned is not None:
-            return spawaned
+            return await spawaned
         # we store an awaitable to the url
         # so that multiple calls don't asynchronously
         # fetch different urls and overwrite each other
-        urls[connectId] = self.spawn(self.negotiate_helper, privateChannel, params)
+        urls[connectId] = self.spawn(self.negotiate_helper, privateChannel, params)  # we have to wait here otherwsie in c# will not work
         self.options['urls'] = urls
-        return urls[connectId]
+        future = urls[connectId]
+        return await future
 
     async def negotiate_helper(self, privateChannel, params={}):
         response = None
@@ -550,6 +551,8 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         messageHash = 'orderbook:' + symbol
         storedOrderBook = self.safe_value(self.orderbooks, symbol)
         nonce = self.safe_integer(storedOrderBook, 'nonce')
+        if storedOrderBook is None:
+            return  # self shouldn't be needed, but for some reason sometimes self runs before handleOrderBookSubscription in c#
         deltaEnd = self.safe_integer(data, 'sequence')
         if nonce is None:
             cacheLength = len(storedOrderBook.cache)
@@ -566,7 +569,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
             limit = self.safe_integer(subscription, 'limit')
             snapshotDelay = self.handle_option('watchOrderBook', 'snapshotDelay', 5)
             if cacheLength == snapshotDelay:
-                self.spawn(self.load_order_book, client, messageHash, symbol, limit)
+                self.spawn(self.load_order_book, client, messageHash, symbol, limit, {})
             storedOrderBook.cache.append(data)
             return
         elif nonce >= deltaEnd:
@@ -871,10 +874,8 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
             'position.adjustRiskLimit': self.handle_position,
         }
         method = self.safe_value(methods, subject)
-        if method is None:
-            return message
-        else:
-            return method(client, message)
+        if method is not None:
+            method(client, message)
 
     def ping(self, client):
         # kucoin does not support built-in ws protocol-level ping-pong
@@ -920,4 +921,4 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         }
         method = self.safe_value(methods, type)
         if method is not None:
-            return method(client, message)
+            method(client, message)

ccxt/pro/lbank.py

@@ -749,16 +749,16 @@ class lbank(ccxt.async_support.lbank):
         orderBook = self.safe_value(message, 'depth', message)
         datetime = self.safe_string(message, 'TS')
         timestamp = self.parse8601(datetime)
-        storedOrderBook = self.safe_value(self.orderbooks, symbol)
-        if storedOrderBook is None:
-            storedOrderBook = self.order_book({})
-            self.orderbooks[symbol] = storedOrderBook
+        orderbook = self.safe_value(self.orderbooks, symbol)
+        if orderbook is None:
+            orderbook = self.order_book({})
+            self.orderbooks[symbol] = orderbook
         snapshot = self.parse_order_book(orderBook, symbol, timestamp, 'bids', 'asks')
-        storedOrderBook.reset(snapshot)
+        orderbook.reset(snapshot)
         messageHash = 'orderbook:' + symbol
-        client.resolve(storedOrderBook, messageHash)
+        client.resolve(orderbook, messageHash)
         messageHash = 'fetchOrderbook:' + symbol
-        client.resolve(storedOrderBook, messageHash)
+        client.resolve(orderbook, messageHash)
 
     def handle_error_message(self, client, message):
         #
@@ -786,7 +786,8 @@ class lbank(ccxt.async_support.lbank):
     def handle_message(self, client, message):
         status = self.safe_string(message, 'status')
         if status == 'error':
-            return self.handle_error_message(client, message)
+            self.handle_error_message(client, message)
+            return
         type = self.safe_string_2(message, 'type', 'action')
         if type == 'ping':
             self.spawn(self.handle_ping, client, message)
@@ -800,8 +801,7 @@ class lbank(ccxt.async_support.lbank):
         }
         handler = self.safe_value(handlers, type)
         if handler is not None:
-            return handler(client, message)
-        return message
+            handler(client, message)
 
     async def authenticate(self, params={}):
         # when we implement more private streams, we need to refactor the authentication

ccxt/pro/luno.py

@@ -191,21 +191,21 @@ class luno(ccxt.async_support.luno):
         symbol = subscription['symbol']
         messageHash = 'orderbook:' + symbol
         timestamp = self.safe_string(message, 'timestamp')
-        storedOrderBook = self.safe_value(self.orderbooks, symbol)
-        if storedOrderBook is None:
-            storedOrderBook = self.indexed_order_book({})
-            self.orderbooks[symbol] = storedOrderBook
+        orderbook = self.safe_value(self.orderbooks, symbol)
+        if orderbook is None:
+            orderbook = self.indexed_order_book({})
+            self.orderbooks[symbol] = orderbook
         asks = self.safe_value(message, 'asks')
         if asks is not None:
             snapshot = self.custom_parse_order_book(message, symbol, timestamp, 'bids', 'asks', 'price', 'volume', 'id')
-            storedOrderBook.reset(snapshot)
+            orderbook.reset(snapshot)
         else:
-            self.handle_delta(storedOrderBook, message)
-            storedOrderBook['timestamp'] = timestamp
-            storedOrderBook['datetime'] = self.iso8601(timestamp)
+            self.handle_delta(orderbook, message)
+            orderbook['timestamp'] = timestamp
+            orderbook['datetime'] = self.iso8601(timestamp)
         nonce = self.safe_integer(message, 'sequence')
-        storedOrderBook['nonce'] = nonce
-        client.resolve(storedOrderBook, messageHash)
+        orderbook['nonce'] = nonce
+        client.resolve(orderbook, messageHash)
 
     def custom_parse_order_book(self, orderbook, symbol, timestamp=None, bidsKey='bids', asksKey: IndexType = 'asks', priceKey: IndexType = 'price', amountKey: IndexType = 'volume', countOrIdKey: IndexType = 2):
         bids = self.parse_bids_asks(self.safe_value(orderbook, bidsKey, []), priceKey, amountKey, countOrIdKey)
@@ -291,9 +291,8 @@ class luno(ccxt.async_support.luno):
         deleteUpdate = self.safe_value(message, 'delete_update')
         if deleteUpdate is not None:
             orderId = self.safe_string(deleteUpdate, 'order_id')
-            asksOrderSide.storeArray(0, 0, orderId)
-            bidsOrderSide.storeArray(0, 0, orderId)
-        return message
+            asksOrderSide.storeArray([0, 0, orderId])
+            bidsOrderSide.storeArray([0, 0, orderId])
 
     def handle_message(self, client: Client, message):
         if message == '':
@@ -303,4 +302,3 @@ class luno(ccxt.async_support.luno):
         for j in range(0, len(handlers)):
             handler = handlers[j]
             handler(client, message, subscriptions[0])
-        return message

ccxt/pro/mexc.py

@@ -1048,7 +1048,7 @@ class mexc(ccxt.async_support.mexc):
         #
         msg = self.safe_string(message, 'msg')
         if msg == 'PONG':
-            return self.handle_pong(client, message)
+            self.handle_pong(client, message)
         elif msg.find('@') > -1:
             parts = msg.split('@')
             channel = self.safe_string(parts, 1)
@@ -1066,7 +1066,8 @@ class mexc(ccxt.async_support.mexc):
                 client.reject(error)
             return
         if 'msg' in message:
-            return self.handle_subscription_status(client, message)
+            self.handle_subscription_status(client, message)
+            return
         c = self.safe_string(message, 'c')
         channel = None
         if c is None:

ccxt/pro/ndax.py

@@ -370,12 +370,12 @@ class ndax(ccxt.async_support.ndax):
         firstBidAsk = self.safe_value(payload, 0, [])
         marketId = self.safe_string(firstBidAsk, 7)
         if marketId is None:
-            return message
+            return
         market = self.safe_market(marketId)
         symbol = market['symbol']
         orderbook = self.safe_value(self.orderbooks, symbol)
         if orderbook is None:
-            return message
+            return
         timestamp = None
         nonce = None
         for i in range(0, len(payload)):
@@ -460,10 +460,8 @@ class ndax(ccxt.async_support.ndax):
         subscription = self.safe_value(subscriptionsById, id)
         if subscription is not None:
             method = self.safe_value(subscription, 'method')
-            if method is None:
-                return message
-            else:
-                return method(client, message, subscription)
+            if method is not None:
+                method(client, message, subscription)
 
     def handle_message(self, client: Client, message):
         #
@@ -490,7 +488,7 @@ class ndax(ccxt.async_support.ndax):
         #
         payload = self.safe_string(message, 'o')
         if payload is None:
-            return message
+            return
         message['o'] = json.loads(payload)
         methods = {
             'SubscribeLevel2': self.handle_subscription_status,
@@ -504,7 +502,5 @@ class ndax(ccxt.async_support.ndax):
         }
         event = self.safe_string(message, 'n')
         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/okcoin.py

@@ -452,7 +452,7 @@ class okcoin(ccxt.async_support.okcoin):
                 ],
             }
             self.spawn(self.watch, url, messageHash, request, messageHash, future)
-        return await future
+        return future
 
     async def watch_balance(self, params={}) -> Balances:
         """
@@ -662,7 +662,8 @@ class okcoin(ccxt.async_support.okcoin):
         # }
         #
         if message == 'pong':
-            return self.handle_pong(client, message)
+            self.handle_pong(client, message)
+            return
         table = self.safe_string(message, 'table')
         if table is None:
             event = self.safe_string(message, 'event')
@@ -674,10 +675,8 @@ class okcoin(ccxt.async_support.okcoin):
                     '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:
             parts = table.split('/')
             name = self.safe_string(parts, 1)
@@ -695,7 +694,5 @@ class okcoin(ccxt.async_support.okcoin):
             method = self.safe_value(methods, name)
             if name.find('candle') >= 0:
                 method = self.handle_ohlcv
-            if method is None:
-                return message
-            else:
-                return method(client, message)
+            if method is not None:
+                method(client, message)

ccxt/pro/okx.py

@@ -710,7 +710,7 @@ class okx(ccxt.async_support.okx):
             }
             message = self.extend(request, params)
             self.watch(url, messageHash, message, messageHash)
-        return future
+        return await future
 
     async def watch_balance(self, params={}) -> Balances:
         """
@@ -1453,7 +1453,8 @@ class okx(ccxt.async_support.okx):
         #
         #
         if message == 'pong':
-            return self.handle_pong(client, message)
+            self.handle_pong(client, message)
+            return
         # table = self.safe_string(message, 'table')
         # if table is None:
         event = self.safe_string_2(message, 'event', 'op')
@@ -1471,10 +1472,8 @@ class okx(ccxt.async_support.okx):
                 'mass-cancel': self.handle_cancel_all_orders,
             }
             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:
             arg = self.safe_value(message, 'arg', {})
             channel = self.safe_string(arg, 'channel')
@@ -1499,7 +1498,5 @@ class okx(ccxt.async_support.okx):
             if method is None:
                 if channel.find('candle') == 0:
                     self.handle_ohlcv(client, message)
-                else:
-                    return message
             else:
-                return method(client, message)
+                method(client, message)

ccxt/pro/onetrading.py

@@ -355,22 +355,22 @@ class onetrading(ccxt.async_support.onetrading):
         dateTime = self.safe_string(message, 'time')
         timestamp = self.parse8601(dateTime)
         channel = 'book:' + symbol
-        storedOrderBook = self.safe_value(self.orderbooks, symbol)
-        if storedOrderBook is None:
-            storedOrderBook = self.order_book({})
+        orderbook = self.safe_value(self.orderbooks, symbol)
+        if orderbook is None:
+            orderbook = self.order_book({})
         if type == 'ORDER_BOOK_SNAPSHOT':
             snapshot = self.parse_order_book(message, symbol, timestamp, 'bids', 'asks')
-            storedOrderBook.reset(snapshot)
+            orderbook.reset(snapshot)
         elif type == 'ORDER_BOOK_UPDATE':
             changes = self.safe_value(message, 'changes', [])
-            self.handle_deltas(storedOrderBook, changes)
+            self.handle_deltas(orderbook, changes)
         else:
             raise NotSupported(self.id + ' watchOrderBook() did not recognize message type ' + type)
-        storedOrderBook['nonce'] = timestamp
-        storedOrderBook['timestamp'] = timestamp
-        storedOrderBook['datetime'] = self.iso8601(timestamp)
-        self.orderbooks[symbol] = storedOrderBook
-        client.resolve(storedOrderBook, channel)
+        orderbook['nonce'] = timestamp
+        orderbook['timestamp'] = timestamp
+        orderbook['datetime'] = self.iso8601(timestamp)
+        self.orderbooks[symbol] = orderbook
+        client.resolve(orderbook, channel)
 
     def handle_delta(self, orderbook, delta):
         #
@@ -938,13 +938,14 @@ class onetrading(ccxt.async_support.onetrading):
             status = self.parse_ws_order_status(updateType)
             if updateType == 'ORDER_CLOSED' and filled == 0:
                 status = 'canceled'
-            orders.append({
+            orderObject = {
                 'id': orderId,
                 'symbol': symbol,
                 'status': status,
                 'timestamp': self.parse8601(datetime),
                 'datetime': datetime,
-            })
+            }
+            orders.append(orderObject)
         else:
             parsed = self.parse_order(update)
             symbol = self.safe_string(parsed, 'symbol', '')
@@ -1162,7 +1163,8 @@ class onetrading(ccxt.async_support.onetrading):
     def handle_message(self, client: Client, message):
         error = self.safe_value(message, 'error')
         if error is not None:
-            return self.handle_error_message(client, message)
+            self.handle_error_message(client, message)
+            return
         type = self.safe_value(message, 'type')
         handlers = {
             'ORDER_BOOK_UPDATE': self.handle_order_book,
@@ -1192,8 +1194,7 @@ class onetrading(ccxt.async_support.onetrading):
         }
         handler = self.safe_value(handlers, type)
         if handler is not None:
-            return handler(client, message)
-        raise NotSupported(self.id + ' no handler found for self message ' + self.json(message))
+            handler(client, message)
 
     def handle_price_point_updates(self, client: Client, message):
         #

ccxt/pro/p2b.py

@@ -349,13 +349,15 @@ class p2b(ccxt.async_support.p2b):
                 bid = self.safe_value(bids, i)
                 price = self.safe_number(bid, 0)
                 amount = self.safe_number(bid, 1)
-                orderbook['bids'].store(price, amount)
+                bookSide = orderbook['bids']
+                bookSide.store(price, amount)
         if asks is not None:
             for i in range(0, len(asks)):
                 ask = self.safe_value(asks, i)
                 price = self.safe_number(ask, 0)
                 amount = self.safe_number(ask, 1)
-                orderbook['asks'].store(price, amount)
+                bookside = orderbook['asks']
+                bookside.store(price, amount)
         orderbook['symbol'] = symbol
         client.resolve(orderbook, messageHash)
 
@@ -376,7 +378,7 @@ class p2b(ccxt.async_support.p2b):
         }
         endpoint = self.safe_value(methods, method)
         if endpoint is not None:
-            return endpoint(client, message)
+            endpoint(client, message)
 
     def handle_error_message(self, client: Client, message):
         error = self.safe_string(message, 'error')

ccxt/pro/phemex.py

@@ -603,13 +603,13 @@ class phemex(ccxt.async_support.phemex):
             limit = ohlcv.getLimit(symbol, limit)
         return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
-    def handle_delta(self, bookside, delta, market=None):
+    def custom_handle_delta(self, bookside, delta, market=None):
         bidAsk = self.custom_parse_bid_ask(delta, 0, 1, market)
         bookside.storeArray(bidAsk)
 
-    def handle_deltas(self, bookside, deltas, market=None):
+    def custom_handle_deltas(self, bookside, deltas, market=None):
         for i in range(0, len(deltas)):
-            self.handle_delta(bookside, deltas[i], market)
+            self.custom_handle_delta(bookside, deltas[i], market)
 
     def handle_order_book(self, client: Client, message):
         #
@@ -677,8 +677,8 @@ class phemex(ccxt.async_support.phemex):
                 changes = self.safe_value_2(message, 'book', 'orderbook_p', {})
                 asks = self.safe_value(changes, 'asks', [])
                 bids = self.safe_value(changes, 'bids', [])
-                self.handle_deltas(orderbook['asks'], asks, market)
-                self.handle_deltas(orderbook['bids'], bids, market)
+                self.custom_handle_deltas(orderbook['asks'], asks, market)
+                self.custom_handle_deltas(orderbook['bids'], bids, market)
                 orderbook['nonce'] = nonce
                 orderbook['timestamp'] = timestamp
                 orderbook['datetime'] = self.iso8601(timestamp)
@@ -1343,16 +1343,21 @@ class phemex(ccxt.async_support.phemex):
             method = client.subscriptions[id]
             del client.subscriptions[id]
             if method is not True:
-                return method(client, message)
+                method(client, message)
+                return
         methodName = self.safe_string(message, 'method', '')
         if ('market24h' in message) or ('spot_market24h' in message) or (methodName.find('perp_market24h_pack_p') >= 0):
-            return self.handle_ticker(client, message)
+            self.handle_ticker(client, message)
+            return
         elif ('trades' in message) or ('trades_p' in message):
-            return self.handle_trades(client, message)
+            self.handle_trades(client, message)
+            return
         elif ('kline' in message) or ('kline_p' in message):
-            return self.handle_ohlcv(client, message)
+            self.handle_ohlcv(client, message)
+            return
         elif ('book' in message) or ('orderbook_p' in message):
-            return self.handle_order_book(client, message)
+            self.handle_order_book(client, message)
+            return
         if ('orders' in message) or ('orders_p' in message):
             orders = self.safe_value_2(message, 'orders', 'orders_p', {})
             self.handle_orders(client, orders)
@@ -1428,4 +1433,4 @@ class phemex(ccxt.async_support.phemex):
                 client.subscriptions[subscriptionHash] = self.handle_authenticate
             future = self.watch(url, messageHash, message)
             client.subscriptions[messageHash] = future
-        return await future
+        return future

ccxt/pro/poloniex.py

@@ -974,13 +974,15 @@ class poloniex(ccxt.async_support.poloniex):
                         bid = self.safe_value(bids, j)
                         price = self.safe_number(bid, 0)
                         amount = self.safe_number(bid, 1)
-                        orderbook['bids'].store(price, amount)
+                        bidsSide = orderbook['bids']
+                        bidsSide.store(price, amount)
                 if asks is not None:
                     for j in range(0, len(asks)):
                         ask = self.safe_value(asks, j)
                         price = self.safe_number(ask, 0)
                         amount = self.safe_number(ask, 1)
-                        orderbook['asks'].store(price, amount)
+                        asksSide = orderbook['asks']
+                        asksSide.store(price, amount)
                 orderbook['symbol'] = symbol
                 orderbook['timestamp'] = timestamp
                 orderbook['datetime'] = self.iso8601(timestamp)
@@ -1104,12 +1106,12 @@ class poloniex(ccxt.async_support.poloniex):
             if orderId == '0':
                 self.handle_error_message(client, item)
             else:
-                return self.handle_order_request(client, message)
+                self.handle_order_request(client, message)
         else:
             data = self.safe_value(message, 'data', [])
             dataLength = len(data)
             if dataLength > 0:
-                return method(client, message)
+                method(client, message)
 
     def handle_error_message(self, client: Client, message):
         #

ccxt/pro/poloniexfutures.py

@@ -68,17 +68,20 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
             },
         })
 
-    def negotiate(self, privateChannel, params={}):
+    async def negotiate(self, privateChannel, params={}):
         connectId = 'private' if privateChannel else 'public'
         urls = self.safe_value(self.options, 'urls', {})
         if connectId in urls:
-            return urls[connectId]
+            # return urls[connectId]
+            storedFuture = urls[connectId]
+            return await storedFuture
         # we store an awaitable to the url
         # so that multiple calls don't asynchronously
         # fetch different urls and overwrite each other
         urls[connectId] = self.spawn(self.negotiate_helper, privateChannel, params)
         self.options['urls'] = urls
-        return urls[connectId]
+        future = urls[connectId]
+        return await future
 
     async def negotiate_helper(self, privateChannel, params={}):
         response = None
@@ -685,7 +688,7 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
         messageHash = self.safe_string(message, 'topic')
         subject = self.safe_string(message, 'subject')
         if subject == 'received':
-            return message
+            return
         # At the time of writting self, there is no implementation to easily convert each order into the orderbook so raw messages are returned
         client.resolve(message, messageHash)
 
@@ -703,8 +706,9 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
         topic = self.safe_string(message, 'topic')
         isSnapshot = topic.find('Depth') >= 0
         if isSnapshot:
-            return self.hande_l2_snapshot(client, message)
-        return self.handle_l2_order_book(client, message)
+            self.hande_l2_snapshot(client, message)
+            return
+        self.handle_l2_order_book(client, message)
 
     def handle_l2_order_book(self, client: Client, message):
         #
@@ -740,7 +744,7 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
             snapshotDelay = self.handle_option('watchOrderBook', 'snapshotDelay', 5)
             if cacheLength == snapshotDelay:
                 limit = 0
-                self.spawn(self.load_order_book, client, messageHash, symbol, limit)
+                self.spawn(self.load_order_book, client, messageHash, symbol, limit, {})
             orderBook.cache.append(data)
             return
         try:
@@ -920,7 +924,7 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
         }
         method = self.safe_value(methods, subject)
         if method is not None:
-            return method(client, message)
+            method(client, message)
 
     def ping(self, client: Client):
         id = str(self.request_id())
@@ -955,7 +959,7 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
         }
         method = self.safe_value(methods, type)
         if method is not None:
-            return method(client, message)
+            method(client, message)
 
     def handle_authenticate(self, client, message):
         #

ccxt/pro/probit.py

@@ -428,17 +428,17 @@ class probit(ccxt.async_support.probit):
         symbol = self.safe_symbol(marketId)
         dataBySide = self.group_by(orderBook, 'side')
         messageHash = 'orderbook:' + symbol
-        storedOrderBook = self.safe_value(self.orderbooks, symbol)
-        if storedOrderBook is None:
-            storedOrderBook = self.order_book({})
-            self.orderbooks[symbol] = storedOrderBook
+        orderbook = self.safe_value(self.orderbooks, symbol)
+        if orderbook is None:
+            orderbook = self.order_book({})
+            self.orderbooks[symbol] = orderbook
         reset = self.safe_bool(message, 'reset', False)
         if reset:
             snapshot = self.parse_order_book(dataBySide, symbol, None, 'buy', 'sell', 'price', 'quantity')
-            storedOrderBook.reset(snapshot)
+            orderbook.reset(snapshot)
         else:
-            self.handle_delta(storedOrderBook, dataBySide)
-        client.resolve(storedOrderBook, messageHash)
+            self.handle_delta(orderbook, dataBySide)
+        client.resolve(orderbook, messageHash)
 
     def handle_bid_asks(self, bookSide, bidAsks):
         for i in range(0, len(bidAsks)):
@@ -505,10 +505,12 @@ class probit(ccxt.async_support.probit):
         #
         errorCode = self.safe_string(message, 'errorCode')
         if errorCode is not None:
-            return self.handle_error_message(client, message)
+            self.handle_error_message(client, message)
+            return
         type = self.safe_string(message, 'type')
         if type == 'authorization':
-            return self.handle_authenticate(client, message)
+            self.handle_authenticate(client, message)
+            return
         handlers = {
             'marketdata': self.handle_market_data,
             'balance': self.handle_balance,
@@ -519,7 +521,8 @@ class probit(ccxt.async_support.probit):
         channel = self.safe_string(message, 'channel')
         handler = self.safe_value(handlers, channel)
         if handler is not None:
-            return handler(client, message)
+            handler(client, message)
+            return
         error = NotSupported(self.id + ' handleMessage: unknown message: ' + self.json(message))
         client.reject(error)
 
@@ -530,7 +533,7 @@ class probit(ccxt.async_support.probit):
         expires = self.safe_integer(self.options, 'expires', 0)
         future = self.safe_value(client.subscriptions, messageHash)
         if (future is None) or (self.milliseconds() > expires):
-            response = await self.signIn()
+            response = await self.sign_in()
             #
             #     {
             #         "access_token": "0ttDv/2hTTn3bLi8GP1gKaneiEQ6+0hOBenPrxNQt2s=",
@@ -545,4 +548,4 @@ class probit(ccxt.async_support.probit):
             }
             future = self.watch(url, messageHash, self.extend(request, params))
             client.subscriptions[messageHash] = future
-        return await future
+        return future