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

ccxt/pro/kraken.py

@@ -641,7 +641,7 @@ class kraken(ccxt.async_support.kraken):
                 side = sides[key]
                 bookside = orderbook[side]
                 deltas = self.safe_value(message[1], key, [])
-                timestamp = self.handle_deltas(bookside, deltas, timestamp)
+                timestamp = self.custom_handle_deltas(bookside, deltas, timestamp)
             orderbook['symbol'] = symbol
             orderbook['timestamp'] = timestamp
             orderbook['datetime'] = self.iso8601(timestamp)
@@ -667,10 +667,10 @@ class kraken(ccxt.async_support.kraken):
             storedBids = orderbook['bids']
             example = None
             if a is not None:
-                timestamp = self.handle_deltas(storedAsks, a, timestamp)
+                timestamp = self.custom_handle_deltas(storedAsks, a, timestamp)
                 example = self.safe_value(a, 0)
             if b is not None:
-                timestamp = self.handle_deltas(storedBids, b, timestamp)
+                timestamp = self.custom_handle_deltas(storedBids, b, timestamp)
                 example = self.safe_value(b, 0)
             # don't remove self line or I will poop on your face
             orderbook.limit()
@@ -715,7 +715,7 @@ class kraken(ccxt.async_support.kraken):
         else:
             return joined
 
-    def handle_deltas(self, bookside, deltas, timestamp=None):
+    def custom_handle_deltas(self, bookside, deltas, timestamp=None):
         for j in range(0, len(deltas)):
             delta = deltas[j]
             price = self.parse_number(delta[0])
@@ -1222,7 +1222,7 @@ class kraken(ccxt.async_support.kraken):
         #         "subscription": {name: "ticker"}
         #     }
         #
-        errorMessage = self.safe_value(message, 'errorMessage')
+        errorMessage = self.safe_string(message, 'errorMessage')
         if errorMessage is not None:
             requestId = self.safe_value(message, 'reqid')
             if requestId is not None:
@@ -1230,7 +1230,7 @@ class kraken(ccxt.async_support.kraken):
                 broadKey = self.find_broadly_matched_key(broad, errorMessage)
                 exception = None
                 if broadKey is None:
-                    exception = ExchangeError(errorMessage)
+                    exception = ExchangeError(errorMessage)  # c# requirement to convert the errorMessage to string
                 else:
                     exception = broad[broadKey](errorMessage)
                 client.reject(exception, requestId)
@@ -1256,10 +1256,8 @@ class kraken(ccxt.async_support.kraken):
                 'ownTrades': self.handle_my_trades,
             }
             method = self.safe_value_2(methods, name, channelName)
-            if method is None:
-                return message
-            else:
-                return method(client, message, subscription)
+            if method is not None:
+                method(client, message, subscription)
         else:
             if self.handle_error_message(client, message):
                 event = self.safe_string(message, 'event')
@@ -1273,7 +1271,5 @@ class kraken(ccxt.async_support.kraken):
                     'cancelAllStatus': 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)

ccxt/pro/krakenfutures.py

@@ -1008,12 +1008,14 @@ class krakenfutures(ccxt.async_support.krakenfutures):
             bid = bids[i]
             price = self.safe_number(bid, 'price')
             qty = self.safe_number(bid, 'qty')
-            orderbook['bids'].store(price, qty)
+            bidsSide = orderbook['bids']
+            bidsSide.store(price, qty)
         for i in range(0, len(asks)):
             ask = asks[i]
             price = self.safe_number(ask, 'price')
             qty = self.safe_number(ask, 'qty')
-            orderbook['asks'].store(price, qty)
+            asksSide = orderbook['asks']
+            asksSide.store(price, qty)
         orderbook['timestamp'] = timestamp
         orderbook['datetime'] = self.iso8601(timestamp)
         orderbook['symbol'] = symbol
@@ -1041,9 +1043,11 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         qty = self.safe_number(message, 'qty')
         timestamp = self.safe_integer(message, 'timestamp')
         if side == 'sell':
-            orderbook['asks'].store(price, qty)
+            asks = orderbook['asks']
+            asks.store(price, qty)
         else:
-            orderbook['bids'].store(price, qty)
+            bids = orderbook['bids']
+            bids.store(price, qty)
         orderbook['timestamp'] = timestamp
         orderbook['datetime'] = self.iso8601(timestamp)
         client.resolve(orderbook, messageHash)
@@ -1366,7 +1370,7 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         if event == 'challenge':
             self.handle_authenticate(client, message)
         elif event == 'alert':
-            return self.handle_error_message(client, message)
+            self.handle_error_message(client, message)
         elif event == 'pong':
             client.lastPong = self.milliseconds()
         elif event is None:
@@ -1391,7 +1395,7 @@ class krakenfutures(ccxt.async_support.krakenfutures):
             }
             method = self.safe_value(methods, feed)
             if method is not None:
-                return method(client, message)
+                method(client, message)
 
     def handle_authenticate(self, client: Client, message):
         """

ccxt/pro/kucoin.py

@@ -54,18 +54,19 @@ class kucoin(ccxt.async_support.kucoin):
             },
         })
 
-    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)
         self.options['urls'] = urls
-        return urls[connectId]
+        future = urls[connectId]
+        return await future
 
     async def negotiate_helper(self, privateChannel, params={}):
         response = None
@@ -511,7 +512,7 @@ class kucoin(ccxt.async_support.kucoin):
             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:
@@ -924,7 +925,8 @@ class kucoin(ccxt.async_support.kucoin):
         #
         topic = self.safe_string(message, 'topic')
         if topic == '/market/ticker:all':
-            return self.handle_ticker(client, message)
+            self.handle_ticker(client, message)
+            return
         subject = self.safe_string(message, 'subject')
         methods = {
             'trade.l2update': self.handle_order_book,
@@ -938,10 +940,8 @@ class kucoin(ccxt.async_support.kucoin):
             'stopOrder': self.handle_order,
         }
         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
@@ -986,4 +986,4 @@ class kucoin(ccxt.async_support.kucoin):
         }
         method = self.safe_value(methods, type)
         if method is not None:
-            return method(client, message)
+            method(client, message)

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