ccxt-ir 4.3.46.0.2__py2.py3-none-any.whl → 4.5.0__py2.py3-none-any.whl

ccxt/pro/kucoinfutures.py

@@ -5,7 +5,7 @@
 
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
-from ccxt.base.types import Balances, Int, Order, OrderBook, Position, Str, Strings, Ticker, Tickers, Trade
+from ccxt.base.types import Any, Balances, Bool, Int, Order, OrderBook, Position, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -14,7 +14,7 @@ from ccxt.base.errors import ArgumentsRequired
 
 class kucoinfutures(ccxt.async_support.kucoinfutures):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(kucoinfutures, self).describe(), {
             'has': {
                 'ws': True,
@@ -175,10 +175,30 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         }
         return await self.watch_multiple(url, messageHashes, self.extend(request, params), subscriptionHashes, subscriptionArgs)
 
+    async def un_subscribe_multiple(self, url, messageHashes, topic, subscriptionHashes, params={}, subscription: dict = None):
+        requestId = str(self.request_id())
+        request: dict = {
+            'id': requestId,
+            'type': 'unsubscribe',
+            'topic': topic,
+            'response': True,
+        }
+        message = self.extend(request, params)
+        if subscription is not None:
+            subscription[requestId] = requestId
+        client = self.client(url)
+        for i in range(0, len(subscriptionHashes)):
+            subscriptionHash = subscriptionHashes[i]
+            if not (subscriptionHash in client.subscriptions):
+                client.subscriptions[requestId] = subscriptionHash
+        return await self.watch_multiple(url, messageHashes, message, subscriptionHashes, subscription)
+
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
-        :see: https://www.kucoin.com/docs/websocket/futures-trading/public-channels/get-ticker
+
+        https://www.kucoin.com/docs/websocket/futures-trading/public-channels/get-ticker
+
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -236,7 +256,9 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
 
     async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
         """
-        :see: https://www.kucoin.com/docs/websocket/futures-trading/public-channels/get-ticker-v2
+
+        https://www.kucoin.com/docs/websocket/futures-trading/public-channels/get-ticker-v2
+
         watches best bid & ask for symbols
         :param str[] symbols: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -320,7 +342,9 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
     async def watch_position(self, symbol: Str = None, params={}) -> Position:
         """
         watch open positions for a specific symbol
-        :see: https://docs.kucoin.com/futures/#position-change-events
+
+        https://docs.kucoin.com/futures/#position-change-events
+
         :param str|None symbol: unified market symbol
         :param dict params: extra parameters specific to the exchange API endpoint
         :returns dict: a `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
@@ -338,7 +362,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         client = self.client(url)
         self.set_position_cache(client, symbol)
         fetchPositionSnapshot = self.handle_option('watchPosition', 'fetchPositionSnapshot', True)
-        awaitPositionSnapshot = self.safe_bool('watchPosition', 'awaitPositionSnapshot', True)
+        awaitPositionSnapshot = self.handle_option('watchPosition', 'awaitPositionSnapshot', True)
         currentPosition = self.get_current_position(symbol)
         if fetchPositionSnapshot and awaitPositionSnapshot and currentPosition is None:
             snapshot = await client.future('fetchPositionSnapshot:' + symbol)
@@ -485,7 +509,9 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
-        :see: https://docs.kucoin.com/futures/#execution-data
+
+        https://docs.kucoin.com/futures/#execution-data
+
         :param str symbol: unified symbol of the market to fetch trades for
         :param int [since]: timestamp in ms of the earliest trade to fetch
         :param int [limit]: the maximum amount of trades to fetch
@@ -497,7 +523,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
     async def watch_trades_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
-        :param str symbol: unified symbol of the market to fetch trades for
+        :param str[] symbols:
         :param int [since]: timestamp in ms of the earliest trade to fetch
         :param int [limit]: the maximum amount of trades to fetch
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -526,6 +552,46 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
             limit = trades.getLimit(tradeSymbol, limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
+    async def un_watch_trades(self, symbol: str, params={}) -> Any:
+        """
+        unWatches trades stream
+
+        https://docs.kucoin.com/futures/#execution-data
+
+        :param str symbol: unified symbol of the market to fetch trades for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
+        """
+        return await self.un_watch_trades_for_symbols([symbol], params)
+
+    async def un_watch_trades_for_symbols(self, symbols: List[str], params={}) -> Any:
+        """
+        get the list of most recent trades for a particular symbol
+        :param str[] symbols:
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        url = await self.negotiate(False)
+        symbols = self.market_symbols(symbols)
+        marketIds = self.market_ids(symbols)
+        topic = '/contractMarket/execution:' + ','.join(marketIds)
+        subscriptionHashes = []
+        messageHashes = []
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            messageHashes.append('unsubscribe:trades:' + symbol)
+            subscriptionHashes.append('trades:' + symbol)
+        subscription = {
+            'messageHashes': messageHashes,
+            'subMessageHashes': subscriptionHashes,
+            'topic': 'trades',
+            'unsubscribe': True,
+            'symbols': symbols,
+        }
+        return await self.un_subscribe_multiple(url, messageHashes, topic, messageHashes, params, subscription)
+
     def handle_trade(self, client: Client, message):
         #
         #    {
@@ -562,7 +628,9 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
 
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
-        :see: https://www.kucoin.com/docs/websocket/futures-trading/public-channels/klines
+
+        https://www.kucoin.com/docs/websocket/futures-trading/public-channels/klines
+
         watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents
@@ -634,13 +702,15 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
-         *   1. After receiving the websocket Level 2 data flow, cache the data.
-         *   2. Initiate a REST request to get the snapshot data of Level 2 order book.
-         *   3. Playback the cached Level 2 data flow.
-         *   4. Apply the new Level 2 data flow to the local snapshot to ensure that the sequence of the new Level 2 update lines up with the sequence of the previous Level 2 data. Discard all the message prior to that sequence, and then playback the change to snapshot.
-         *   5. Update the level2 full data based on sequence according to the size. If the price is 0, ignore the messages and update the sequence. If the size=0, update the sequence and remove the price of which the size is 0 out of level 2. For other cases, please update the price.
-         *   6. If the sequence of the newly pushed message does not line up to the sequence of the last message, you could pull through REST Level 2 message request to get the updated messages. Please note that the difference between the start and end parameters cannot exceed 500.
-        :see: https://docs.kucoin.com/futures/#level-2-market-data
+   1. After receiving the websocket Level 2 data flow, cache the data.
+   2. Initiate a REST request to get the snapshot data of Level 2 order book.
+   3. Playback the cached Level 2 data flow.
+   4. Apply the new Level 2 data flow to the local snapshot to ensure that the sequence of the new Level 2 update lines up with the sequence of the previous Level 2 data. Discard all the message prior to that sequence, and then playback the change to snapshot.
+   5. Update the level2 full data based on sequence according to the size. If the price is 0, ignore the messages and update the sequence. If the size=0, update the sequence and remove the price of which the size is 0 out of level 2. For other cases, please update the price.
+   6. If the sequence of the newly pushed message does not line up to the sequence of the last message, you could pull through REST Level 2 message request to get the updated messages. Please note that the difference between the start and end parameters cannot exceed 500.
+
+        https://docs.kucoin.com/futures/#level-2-market-data
+
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -651,6 +721,9 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
     async def watch_order_book_for_symbols(self, symbols: List[str], limit: Int = None, params={}) -> OrderBook:
         """
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+
+        https://docs.kucoin.com/futures/#level-2-market-data
+
         :param str[] symbols: unified array of symbols
         :param int [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -680,6 +753,45 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         orderbook = await self.subscribe_multiple(url, messageHashes, topic, subscriptionHashes, subscriptionArgs, params)
         return orderbook.limit()
 
+    async def un_watch_order_book(self, symbol: str, params={}) -> Any:
+        """
+        unWatches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+
+        https://docs.kucoin.com/futures/#level-2-market-data
+
+        :param str symbol: unified symbol of the market to fetch the order book for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
+        """
+        return await self.un_watch_order_book_for_symbols([symbol], params)
+
+    async def un_watch_order_book_for_symbols(self, symbols: List[str], params={}) -> Any:
+        """
+        unWatches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        :param str[] symbols: unified array of symbols
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols)
+        marketIds = self.market_ids(symbols)
+        url = await self.negotiate(False)
+        topic = '/contractMarket/level2:' + ','.join(marketIds)
+        subscriptionHashes = []
+        messageHashes = []
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            messageHashes.append('unsubscribe:orderbook:' + symbol)
+            subscriptionHashes.append('orderbook:' + symbol)
+        subscription = {
+            'messageHashes': messageHashes,
+            'symbols': symbols,
+            'unsubscribe': True,
+            'topic': 'orderbook',
+            'subMessageHashes': subscriptionHashes,
+        }
+        return await self.un_subscribe_multiple(url, messageHashes, topic, messageHashes, params, subscription)
+
     def handle_delta(self, orderbook, delta):
         orderbook['nonce'] = self.safe_integer(delta, 'sequence')
         timestamp = self.safe_integer(delta, 'timestamp')
@@ -784,7 +896,9 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         watches information on multiple orders made by the user
-        :see: https://docs.kucoin.com/futures/#trade-orders-according-to-the-market
+
+        https://docs.kucoin.com/futures/#trade-orders-according-to-the-market
+
         :param str symbol: unified market symbol of the market orders were made in
         :param int [since]: the earliest time in ms to fetch orders for
         :param int [limit]: the maximum number of order structures to retrieve
@@ -900,7 +1014,9 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
     async def watch_balance(self, params={}) -> Balances:
         """
         watch balance and get the amount of funds available for trading or funds locked in orders
-        :see: https://docs.kucoin.com/futures/#account-balance-events
+
+        https://docs.kucoin.com/futures/#account-balance-events
+
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
         """
@@ -1035,7 +1151,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         else:
             return elementName + 's@all'
 
-    def ping(self, client):
+    def ping(self, client: Client):
         # kucoin does not support built-in ws protocol-level ping-pong
         # instead it requires a custom json-based text ping-pong
         # https://docs.kucoin.com/#ping
@@ -1050,7 +1166,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         client.lastPong = self.milliseconds()
         return message
 
-    def handle_error_message(self, client: Client, message):
+    def handle_error_message(self, client: Client, message) -> Bool:
         #
         #    {
         #        "id": "64d8732c856851144bded10d",
@@ -1065,7 +1181,34 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
             if client.url.find('connectId=private') >= 0:
                 type = 'private'
             self.options['urls'][type] = None
-        self.handle_errors(None, None, client.url, None, None, data, message, None, None)
+        self.handle_errors(1, '', client.url, '', {}, data, message, {}, {})
+        return True
+
+    def handle_subscription_status(self, client: Client, message):
+        #
+        #     {
+        #         "id": "1578090438322",
+        #         "type": "ack"
+        #     }
+        #
+        id = self.safe_string(message, 'id')
+        if not (id in client.subscriptions):
+            return
+        subscriptionHash = self.safe_string(client.subscriptions, id)
+        subscription = self.safe_value(client.subscriptions, subscriptionHash)
+        del client.subscriptions[id]
+        method = self.safe_value(subscription, 'method')
+        if method is not None:
+            method(client, message, subscription)
+        isUnSub = self.safe_bool(subscription, 'unsubscribe', False)
+        if isUnSub:
+            messageHashes = self.safe_list(subscription, 'messageHashes', [])
+            subMessageHashes = self.safe_list(subscription, 'subMessageHashes', [])
+            for i in range(0, len(messageHashes)):
+                messageHash = messageHashes[i]
+                subHash = subMessageHashes[i]
+                self.clean_unsubscription(client, subHash, messageHash)
+            self.clean_cache(subscription)
 
     def handle_message(self, client: Client, message):
         type = self.safe_string(message, 'type')
@@ -1075,6 +1218,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
             'message': self.handle_subject,
             'pong': self.handle_pong,
             'error': self.handle_error_message,
+            'ack': self.handle_subscription_status,
         }
         method = self.safe_value(methods, type)
         if method is not None:

ccxt/pro/lbank.py

@@ -6,7 +6,7 @@
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
 import math
-from ccxt.base.types import Int, Order, OrderBook, Str, Ticker, Trade
+from ccxt.base.types import Any, Balances, Int, Order, OrderBook, Str, Ticker, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -14,7 +14,7 @@ from ccxt.base.errors import ExchangeError
 
 class lbank(ccxt.async_support.lbank):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(lbank, self).describe(), {
             'has': {
                 'ws': True,
@@ -22,10 +22,11 @@ class lbank(ccxt.async_support.lbank):
                 'fetchOrderBookWs': True,
                 'fetchTickerWs': True,
                 'fetchTradesWs': True,
-                'watchBalance': False,
+                'watchBalance': True,
                 'watchTicker': True,
                 'watchTickers': False,
                 'watchTrades': True,
+                'watchTradesForSymbols': False,
                 'watchMyTrades': False,
                 'watchOrders': True,
                 'watchOrderBook': True,
@@ -66,7 +67,9 @@ class lbank(ccxt.async_support.lbank):
 
     async def fetch_ohlcv_ws(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
-        :see: https://www.lbank.com/en-US/docs/index.html#request-amp-subscription-instruction
+
+        https://www.lbank.com/en-US/docs/index.html#request-amp-subscription-instruction
+
         watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents
@@ -98,7 +101,9 @@ class lbank(ccxt.async_support.lbank):
 
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
-        :see: https://www.lbank.com/en-US/docs/index.html#subscription-of-k-line-data
+
+        https://www.lbank.com/en-US/docs/index.html#subscription-of-k-line-data
+
         watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents
@@ -229,7 +234,9 @@ class lbank(ccxt.async_support.lbank):
 
     async def fetch_ticker_ws(self, symbol: str, params={}) -> Ticker:
         """
-        :see: https://www.lbank.com/en-US/docs/index.html#request-amp-subscription-instruction
+
+        https://www.lbank.com/en-US/docs/index.html#request-amp-subscription-instruction
+
         fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the cex api endpoint
@@ -250,7 +257,9 @@ class lbank(ccxt.async_support.lbank):
 
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
-        :see: https://www.lbank.com/en-US/docs/index.html#market
+
+        https://www.lbank.com/en-US/docs/index.html#market
+
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict params: extra parameters specific to the lbank api endpoint
@@ -352,7 +361,9 @@ class lbank(ccxt.async_support.lbank):
     async def fetch_trades_ws(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
-        :see: https://www.lbank.com/en-US/docs/index.html#request-amp-subscription-instruction
+
+        https://www.lbank.com/en-US/docs/index.html#request-amp-subscription-instruction
+
         :param str symbol: unified symbol of the market to fetch trades for
         :param int [since]: timestamp in ms of the earliest trade to fetch
         :param int [limit]: the maximum amount of trades to fetch
@@ -377,7 +388,9 @@ class lbank(ccxt.async_support.lbank):
 
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
-        :see: https://www.lbank.com/en-US/docs/index.html#trade-record
+
+        https://www.lbank.com/en-US/docs/index.html#trade-record
+
         get the list of most recent trades for a particular symbol
         :param str symbol: unified symbol of the market to fetch trades for
         :param int [since]: timestamp in ms of the earliest trade to fetch
@@ -416,7 +429,7 @@ class lbank(ccxt.async_support.lbank):
         #             "volume":6.3607,
         #             "amount":77148.9303,
         #             "price":12129,
-        #             "direction":"sell",  # or "sell_market"
+        #             "direction":"sell",  # buy, sell, buy_market, sell_market, buy_maker, sell_maker, buy_ioc, sell_ioc, buy_fok, sell_fok
         #             "TS":"2019-06-28T19:55:49.460"
         #         },
         #         "type":"trade",
@@ -454,7 +467,7 @@ class lbank(ccxt.async_support.lbank):
         #        "volume":6.3607,
         #        "amount":77148.9303,
         #        "price":12129,
-        #        "direction":"sell",  # or "sell_market"
+        #        "direction":"sell",  # buy, sell, buy_market, sell_market, buy_maker, sell_maker, buy_ioc, sell_ioc, buy_fok, sell_fok
         #        "TS":"2019-06-28T19:55:49.460"
         #    }
         #
@@ -462,8 +475,14 @@ class lbank(ccxt.async_support.lbank):
         datetime = (self.iso8601(timestamp)) if (timestamp is not None) else (self.safe_string(trade, 'TS'))
         if timestamp is None:
             timestamp = self.parse8601(datetime)
-        side = self.safe_string_2(trade, 'direction', 3)
-        side = side.replace('_market', '')
+        rawSide = self.safe_string_2(trade, 'direction', 3)
+        parts = rawSide.split('_')
+        firstPart = self.safe_string(parts, 0)
+        secondPart = self.safe_string(parts, 1)
+        side = firstPart
+        # reverse if it was 'maker'
+        if secondPart is not None and secondPart == 'maker':
+            side = 'sell' if (side == 'buy') else 'buy'
         return self.safe_trade({
             'timestamp': timestamp,
             'datetime': datetime,
@@ -482,7 +501,9 @@ class lbank(ccxt.async_support.lbank):
 
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
-        :see: https://github.com/LBank-exchange/lbank-official-api-docs/blob/master/API-For-Spot-EN/WebSocket%20API(Asset%20%26%20Order).md#websocketsubscribeunsubscribe
+
+        https://www.lbank.com/en-US/docs/index.html#update-subscribed-orders
+
         get the list of trades associated with the user
         :param str [symbol]: unified symbol of the market to fetch trades for
         :param int [since]: timestamp in ms of the earliest trade to fetch
@@ -637,9 +658,64 @@ class lbank(ccxt.async_support.lbank):
         }
         return self.safe_string(statuses, status, status)
 
+    async def watch_balance(self, params={}) -> Balances:
+        """
+        watch balance and get the amount of funds available for trading or funds locked in orders
+
+        https://www.lbank.com/docs/index.html#update-subscribed-asset
+
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
+        """
+        await self.load_markets()
+        key = await self.authenticate(params)
+        url = self.urls['api']['ws']
+        messageHash = 'balance'
+        message: dict = {
+            'action': 'subscribe',
+            'subscribe': 'assetUpdate',
+            'subscribeKey': key,
+        }
+        request = self.deep_extend(message, params)
+        return await self.watch(url, messageHash, request, messageHash, request)
+
+    def handle_balance(self, client: Client, message):
+        #
+        #     {
+        #         "data": {
+        #             "asset": "114548.31881315",
+        #             "assetCode": "usdt",
+        #             "free": "97430.6739041",
+        #             "freeze": "17117.64490905",
+        #             "time": 1627300043270,
+        #             "type": "ORDER_CREATE"
+        #         },
+        #         "SERVER": "V2",
+        #         "type": "assetUpdate",
+        #         "TS": "2021-07-26T19:48:03.548"
+        #     }
+        #
+        data = self.safe_dict(message, 'data', {})
+        timestamp = self.parse8601(self.safe_string(message, 'TS'))
+        datetime = self.iso8601(timestamp)
+        self.balance['info'] = data
+        self.balance['timestamp'] = timestamp
+        self.balance['datetime'] = datetime
+        currencyId = self.safe_string(data, 'assetCode')
+        code = self.safe_currency_code(currencyId)
+        account = self.account()
+        account['free'] = self.safe_string(data, 'free')
+        account['used'] = self.safe_string(data, 'freeze')
+        account['total'] = self.safe_string(data, 'asset')
+        self.balance[code] = account
+        self.balance = self.safe_balance(self.balance)
+        client.resolve(self.balance, 'balance')
+
     async def fetch_order_book_ws(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
-        :see: https://www.lbank.com/en-US/docs/index.html#request-amp-subscription-instruction
+
+        https://www.lbank.com/en-US/docs/index.html#request-amp-subscription-instruction
+
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int|None limit: the maximum amount of order book entries to return
@@ -664,8 +740,9 @@ class lbank(ccxt.async_support.lbank):
 
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
-        :see: https://www.lbank.com/en-US/docs/index.html#market-depth
-        :see: https://www.lbank.com/en-US/docs/index.html#market-increment-depth
+
+        https://www.lbank.com/en-US/docs/index.html#market-depth
+
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int|None limit: the maximum amount of order book entries to return
@@ -780,10 +857,13 @@ class lbank(ccxt.async_support.lbank):
         #  {ping: 'a13a939c-5f25-4e06-9981-93cb3b890707', action: 'ping'}
         #
         pingId = self.safe_string(message, 'ping')
-        await client.send({
-            'action': 'pong',
-            'pong': pingId,
-        })
+        try:
+            await client.send({
+                'action': 'pong',
+                'pong': pingId,
+            })
+        except Exception as e:
+            self.on_error(client, e)
 
     def handle_message(self, client, message):
         status = self.safe_string(message, 'status')
@@ -800,6 +880,7 @@ class lbank(ccxt.async_support.lbank):
             'trade': self.handle_trades,
             'tick': self.handle_ticker,
             'orderUpdate': self.handle_orders,
+            'assetUpdate': self.handle_balance,
         }
         handler = self.safe_value(handlers, type)
         if handler is not None:

ccxt/pro/luno.py

@@ -5,20 +5,21 @@
 
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache
-from ccxt.base.types import IndexType, Int, OrderBook, Trade
+from ccxt.base.types import Any, IndexType, Int, OrderBook, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 
 
 class luno(ccxt.async_support.luno):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(luno, self).describe(), {
             'has': {
                 'ws': True,
                 'watchTicker': False,
                 'watchTickers': False,
                 'watchTrades': True,
+                'watchTradesForSymbols': False,
                 'watchMyTrades': False,
                 'watchOrders': None,  # is in beta
                 'watchOrderBook': True,
@@ -41,7 +42,9 @@ class luno(ccxt.async_support.luno):
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
-        :see: https://www.luno.com/en/developers/api#tag/Streaming-API
+
+        https://www.luno.com/en/developers/api#tag/Streaming-API
+
         :param str symbol: unified symbol of the market to fetch trades for
         :param int [since]: timestamp in ms of the earliest trade to fetch
         :param int [limit]: the maximum amount of    trades to fetch
@@ -193,15 +196,16 @@ class luno(ccxt.async_support.luno):
         timestamp = self.safe_integer(message, 'timestamp')
         if not (symbol in self.orderbooks):
             self.orderbooks[symbol] = self.indexed_order_book({})
-        orderbook = self.orderbooks[symbol]
         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')
-            orderbook.reset(snapshot)
+            self.orderbooks[symbol] = self.indexed_order_book(snapshot)
         else:
-            self.handle_delta(orderbook, message)
-            orderbook['timestamp'] = timestamp
-            orderbook['datetime'] = self.iso8601(timestamp)
+            ob = self.orderbooks[symbol]
+            self.handle_delta(ob, message)
+            ob['timestamp'] = timestamp
+            ob['datetime'] = self.iso8601(timestamp)
+        orderbook = self.orderbooks[symbol]
         nonce = self.safe_integer(message, 'sequence')
         orderbook['nonce'] = nonce
         client.resolve(orderbook, messageHash)