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

ccxt/pro/coinbasepro.py

@@ -892,4 +892,4 @@ class coinbasepro(ccxt.async_support.coinbasepro):
                 else:
                     self.handle_trade(client, message)
         else:
-            return method(client, message)
+            method(client, message)

ccxt/pro/coinex.py

@@ -630,26 +630,26 @@ class coinex(ccxt.async_support.coinex):
         #
         params = self.safe_value(message, 'params', [])
         fullOrderBook = self.safe_value(params, 0)
-        orderBook = self.safe_value(params, 1)
+        orderbook = self.safe_value(params, 1)
         marketId = self.safe_string(params, 2)
         defaultType = self.safe_string(self.options, 'defaultType')
         market = self.safe_market(marketId, None, None, defaultType)
         symbol = market['symbol']
         name = 'orderbook'
         messageHash = name + ':' + symbol
-        timestamp = self.safe_integer(orderBook, 'time')
+        timestamp = self.safe_integer(orderbook, 'time')
         currentOrderBook = self.safe_value(self.orderbooks, symbol)
         if fullOrderBook:
-            snapshot = self.parse_order_book(orderBook, symbol, timestamp)
+            snapshot = self.parse_order_book(orderbook, symbol, timestamp)
             if currentOrderBook is None:
-                orderBook = self.order_book(snapshot)
-                self.orderbooks[symbol] = orderBook
+                orderbook = self.order_book(snapshot)
+                self.orderbooks[symbol] = orderbook
             else:
-                orderBook = self.orderbooks[symbol]
-                orderBook.reset(snapshot)
+                orderbook = self.orderbooks[symbol]
+                orderbook.reset(snapshot)
         else:
-            asks = self.safe_value(orderBook, 'asks', [])
-            bids = self.safe_value(orderBook, 'bids', [])
+            asks = self.safe_value(orderbook, 'asks', [])
+            bids = self.safe_value(orderbook, 'bids', [])
             self.handle_deltas(currentOrderBook['asks'], asks)
             self.handle_deltas(currentOrderBook['bids'], bids)
             currentOrderBook['nonce'] = timestamp
@@ -962,8 +962,9 @@ class coinex(ccxt.async_support.coinex):
         }
         handler = self.safe_value(handlers, method)
         if handler is not None:
-            return handler(client, message)
-        return self.handle_subscription_status(client, message)
+            handler(client, message)
+            return
+        self.handle_subscription_status(client, message)
 
     def handle_authentication_message(self, client: Client, message):
         #
@@ -987,13 +988,14 @@ class coinex(ccxt.async_support.coinex):
         if subscription is not None:
             futureIndex = self.safe_string(subscription, 'future')
             if futureIndex == 'ohlcv':
-                return self.handle_ohlcv(client, message)
+                self.handle_ohlcv(client, message)
+                return
             future = self.safe_value(client.futures, futureIndex)
             if future is not None:
                 future.resolve(True)
             del client.subscriptions[id]
 
-    def authenticate(self, params={}):
+    async def authenticate(self, params={}):
         type = None
         type, params = self.handle_market_type_and_params('authenticate', None, params)
         url = self.urls['api']['ws'][type]

ccxt/pro/currencycom.py

@@ -517,9 +517,10 @@ class currencycom(ccxt.async_support.currencycom):
                         }
                         method = self.safe_value(methods, subscriptionDestination)
                         if method is None:
-                            return message
+                            return
                         else:
-                            return method(client, message, subscription)
+                            method(client, message, subscription)
+                            return
         destination = self.safe_string(message, 'destination')
         if destination is not None:
             methods = {
@@ -529,7 +530,5 @@ class currencycom(ccxt.async_support.currencycom):
                 'ping': self.handle_pong,
             }
             method = self.safe_value(methods, destination)
-            if method is None:
-                return message
-            else:
-                return method(client, message)
+            if method is not None:
+                method(client, message)

ccxt/pro/deribit.py

@@ -728,13 +728,13 @@ class deribit(ccxt.async_support.deribit):
             }
             handler = self.safe_value(handlers, channelId)
             if handler is not None:
-                return handler(client, message)
+                handler(client, message)
+                return
             raise NotSupported(self.id + ' no handler found for self message ' + self.json(message))
         result = self.safe_value(message, 'result', {})
         accessToken = self.safe_string(result, 'access_token')
         if accessToken is not None:
-            return self.handle_authentication_message(client, message)
-        return message
+            self.handle_authentication_message(client, message)
 
     def handle_authentication_message(self, client: Client, message):
         #
@@ -758,7 +758,7 @@ class deribit(ccxt.async_support.deribit):
         client.resolve(message, messageHash)
         return message
 
-    def authenticate(self, params={}):
+    async def authenticate(self, params={}):
         url = self.urls['api']['ws']
         client = self.client(url)
         time = self.milliseconds()

ccxt/pro/exmo.py

@@ -495,22 +495,22 @@ class exmo(ccxt.async_support.exmo):
         orderBook = self.safe_value(message, 'data', {})
         messageHash = 'orderbook:' + symbol
         timestamp = self.safe_integer(message, 'ts')
-        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
         event = self.safe_string(message, 'event')
         if event == 'snapshot':
             snapshot = self.parse_order_book(orderBook, symbol, timestamp, 'bid', 'ask')
-            storedOrderBook.reset(snapshot)
+            orderbook.reset(snapshot)
         else:
             asks = self.safe_value(orderBook, 'ask', [])
             bids = self.safe_value(orderBook, 'bid', [])
-            self.handle_deltas(storedOrderBook['asks'], asks)
-            self.handle_deltas(storedOrderBook['bids'], bids)
-            storedOrderBook['timestamp'] = timestamp
-            storedOrderBook['datetime'] = self.iso8601(timestamp)
-        client.resolve(storedOrderBook, messageHash)
+            self.handle_deltas(orderbook['asks'], asks)
+            self.handle_deltas(orderbook['bids'], bids)
+            orderbook['timestamp'] = timestamp
+            orderbook['datetime'] = self.iso8601(timestamp)
+        client.resolve(orderbook, messageHash)
 
     def handle_delta(self, bookside, delta):
         bidAsk = self.parse_bid_ask(delta, 0, 1)
@@ -544,7 +544,8 @@ class exmo(ccxt.async_support.exmo):
         }
         eventHandler = self.safe_value(events, event)
         if eventHandler is not None:
-            return eventHandler(client, message)
+            eventHandler(client, message)
+            return
         if (event == 'update') or (event == 'snapshot'):
             topic = self.safe_string(message, 'topic')
             if topic is not None:
@@ -565,7 +566,8 @@ class exmo(ccxt.async_support.exmo):
                 }
                 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_subscribed(self, client: Client, message):
@@ -603,7 +605,7 @@ class exmo(ccxt.async_support.exmo):
         messageHash = 'authenticated'
         client.resolve(message, messageHash)
 
-    def authenticate(self, params={}):
+    async def authenticate(self, params={}):
         messageHash = 'authenticated'
         type, query = self.handle_market_type_and_params('authenticate', None, params)
         url = self.urls['api']['ws'][type]

ccxt/pro/gate.py

@@ -211,7 +211,7 @@ class gate(ccxt.async_support.gate):
                 # max limit is 100
                 subscription = client.subscriptions[messageHash]
                 limit = self.safe_integer(subscription, 'limit')
-                self.spawn(self.load_order_book, client, messageHash, symbol, limit)
+                self.spawn(self.load_order_book, client, messageHash, symbol, limit, {})  # needed for c#, number of args needs to match
             storedOrderBook.cache.append(delta)
             return
         elif nonce >= deltaEnd:

ccxt/pro/gemini.py

@@ -568,7 +568,8 @@ class gemini(ccxt.async_support.gemini):
         #
         isArray = isinstance(message, list)
         if isArray:
-            return self.handle_order(client, message)
+            self.handle_order(client, message)
+            return
         reason = self.safe_string(message, 'reason')
         if reason == 'error':
             self.handle_error(client, message)
@@ -580,7 +581,8 @@ class gemini(ccxt.async_support.gemini):
         }
         type = self.safe_string(message, 'type', '')
         if type.find('candles') >= 0:
-            return self.handle_ohlcv(client, message)
+            self.handle_ohlcv(client, message)
+            return
         method = self.safe_value(methods, type)
         if method is not None:
             method(client, message)

ccxt/pro/hitbtc.py

@@ -121,7 +121,7 @@ class hitbtc(ccxt.async_support.hitbtc):
             #
         return future
 
-    async def subscribe_public(self, name: str, symbols: Strings = None, params={}):
+    async def subscribe_public(self, name: str, messageHashPrefix: str, symbols: Strings = None, params={}):
         """
          * @ignore
         :param str name: websocket endpoint name
@@ -130,7 +130,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         """
         await self.load_markets()
         url = self.urls['api']['ws']['public']
-        messageHash = name
+        messageHash = messageHashPrefix
         if symbols is not None:
             messageHash = messageHash + '::' + ','.join(symbols)
         subscribe = {
@@ -215,7 +215,7 @@ class hitbtc(ccxt.async_support.hitbtc):
                 'symbols': [market['id']],
             },
         }
-        orderbook = await self.subscribe_public(name, [symbol], self.deep_extend(request, params))
+        orderbook = await self.subscribe_public(name, name, [symbol], self.deep_extend(request, params))
         return orderbook.limit()
 
     def handle_order_book(self, client: Client, message):
@@ -303,7 +303,7 @@ class hitbtc(ccxt.async_support.hitbtc):
                 'symbols': [market['id']],
             },
         }
-        result = await self.subscribe_public(name, [symbol], self.deep_extend(request, params))
+        result = await self.subscribe_public(name, 'ticker', [symbol], self.deep_extend(request, params))
         return self.safe_value(result, symbol)
 
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
@@ -334,7 +334,7 @@ class hitbtc(ccxt.async_support.hitbtc):
                 'symbols': marketIds,
             },
         }
-        tickers = await self.subscribe_public(name, symbols, self.deep_extend(request, params))
+        tickers = await self.subscribe_public(name, 'tickers', symbols, self.deep_extend(request, params))
         if self.newUpdates:
             return tickers
         return self.filter_by_array(self.tickers, 'symbol', symbols)
@@ -391,7 +391,7 @@ class hitbtc(ccxt.async_support.hitbtc):
             newTickers[symbol] = ticker
             messageHash = channel + '::' + symbol
             client.resolve(newTickers, messageHash)
-        messageHashes = self.find_message_hashes(client, channel + '::')
+        messageHashes = self.find_message_hashes(client, 'tickers::')
         for i in range(0, len(messageHashes)):
             messageHash = messageHashes[i]
             parts = messageHash.split('::')
@@ -479,7 +479,8 @@ class hitbtc(ccxt.async_support.hitbtc):
         }
         if limit is not None:
             request['limit'] = limit
-        trades = await self.subscribe_public('trades', [symbol], self.deep_extend(request, params))
+        name = 'trades'
+        trades = await self.subscribe_public(name, name, [symbol], self.deep_extend(request, params))
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp')
@@ -600,7 +601,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         }
         if limit is not None:
             request['params']['limit'] = limit
-        ohlcv = await self.subscribe_public(name, [symbol], self.deep_extend(request, params))
+        ohlcv = await self.subscribe_public(name, name, [symbol], self.deep_extend(request, params))
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
         return self.filter_by_since_limit(ohlcv, since, limit, 0)
@@ -940,7 +941,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         }
         return await self.subscribe_private(name, None, self.extend(request, params))
 
-    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://api.hitbtc.com/#create-new-spot-order

ccxt/pro/hollaex.py

@@ -213,7 +213,7 @@ class hollaex(ccxt.async_support.hollaex):
         # when the user does not have any trades yet
         dataLength = len(rawTrades)
         if dataLength == 0:
-            return 0
+            return
         if self.myTrades is None:
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
             self.myTrades = ArrayCache(limit)
@@ -319,7 +319,7 @@ class hollaex(ccxt.async_support.hollaex):
         # usually the first message is an empty array
         dataLength = len(data)
         if dataLength == 0:
-            return 0
+            return
         if self.orders is None:
             limit = self.safe_integer(self.options, 'ordersLimit', 1000)
             self.orders = ArrayCacheBySymbolById(limit)

ccxt/pro/htx.py

@@ -452,6 +452,7 @@ class htx(ccxt.async_support.htx):
         except Exception as e:
             del client.subscriptions[messageHash]
             client.reject(e, messageHash)
+        return None
 
     def handle_delta(self, bookside, delta):
         price = self.safe_float(delta, 0)
@@ -1581,11 +1582,11 @@ class htx(ccxt.async_support.htx):
         if subscription is not None:
             method = self.safe_value(subscription, 'method')
             if method is not None:
-                return method(client, message, subscription)
+                method(client, message, subscription)
+                return
             # clean up
             if id in client.subscriptions:
                 del client.subscriptions[id]
-        return message
 
     def handle_system_status(self, client: Client, message):
         #
@@ -1694,10 +1695,9 @@ class htx(ccxt.async_support.htx):
                 'kline': self.handle_ohlcv,
             }
             method = self.safe_value(methods, methodName)
-            if method is None:
-                return message
-            else:
-                return method(client, message)
+            if method is not None:
+                method(client, message)
+                return
         # private spot subjects
         privateParts = ch.split('#')
         privateType = self.safe_string(privateParts, 0, '')

ccxt/pro/huobijp.py

@@ -350,6 +350,7 @@ class huobijp(ccxt.async_support.huobijp):
         except Exception as e:
             del client.subscriptions[messageHash]
             client.reject(e, messageHash)
+        return None
 
     def handle_delta(self, bookside, delta):
         price = self.safe_float(delta, 0)
@@ -507,10 +508,8 @@ class huobijp(ccxt.async_support.huobijp):
                 # ...
             }
             method = self.safe_value(methods, methodName)
-            if method is None:
-                return message
-            else:
-                return method(client, message)
+            if method is not None:
+                method(client, message)
 
     async def pong(self, client, message):
         #

ccxt/pro/idex.py

@@ -319,7 +319,7 @@ class idex(ccxt.async_support.idex):
                         symbol = self.safe_symbol(marketId)
                         if not (symbol in self.orderbooks):
                             orderbook = self.counted_order_book({})
-                            orderbook.cache = []
+                            # orderbook.cache = []  # cache is never used?
                             self.orderbooks[symbol] = orderbook
                         self.spawn(self.fetch_order_book_snapshot, client, symbol)
                 break

ccxt/pro/independentreserve.py

@@ -181,25 +181,25 @@ class independentreserve(ccxt.async_support.independentreserve):
         subscription = self.safe_value(client.subscriptions, messageHash, {})
         receivedSnapshot = self.safe_bool(subscription, 'receivedSnapshot', False)
         timestamp = self.safe_integer(message, 'Time')
-        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
         if event == 'OrderBookSnapshot':
             snapshot = self.parse_order_book(orderBook, symbol, timestamp, 'Bids', 'Offers', 'Price', 'Volume')
-            storedOrderBook.reset(snapshot)
+            orderbook.reset(snapshot)
             subscription['receivedSnapshot'] = True
         else:
             asks = self.safe_value(orderBook, 'Offers', [])
             bids = self.safe_value(orderBook, 'Bids', [])
-            self.handle_deltas(storedOrderBook['asks'], asks)
-            self.handle_deltas(storedOrderBook['bids'], bids)
-            storedOrderBook['timestamp'] = timestamp
-            storedOrderBook['datetime'] = self.iso8601(timestamp)
+            self.handle_deltas(orderbook['asks'], asks)
+            self.handle_deltas(orderbook['bids'], bids)
+            orderbook['timestamp'] = timestamp
+            orderbook['datetime'] = self.iso8601(timestamp)
         checksum = self.safe_value(self.options, 'checksum', True)
         if checksum and receivedSnapshot:
-            storedAsks = storedOrderBook['asks']
-            storedBids = storedOrderBook['bids']
+            storedAsks = orderbook['asks']
+            storedBids = orderbook['bids']
             asksLength = len(storedAsks)
             bidsLength = len(storedBids)
             payload = ''
@@ -215,7 +215,7 @@ class independentreserve(ccxt.async_support.independentreserve):
                 error = InvalidNonce(self.id + ' invalid checksum')
                 client.reject(error, messageHash)
         if receivedSnapshot:
-            client.resolve(storedOrderBook, messageHash)
+            client.resolve(orderbook, messageHash)
 
     def value_to_checksum(self, value):
         result = format(value, '.8f')
@@ -263,5 +263,6 @@ class independentreserve(ccxt.async_support.independentreserve):
         }
         handler = self.safe_value(handlers, event)
         if handler is not None:
-            return handler(client, message)
+            handler(client, message)
+            return
         raise NotSupported(self.id + ' received an unsupported message: ' + self.json(message))

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)