ccxt 4.2.77__py2.py3-none-any.whl → 4.4.49__py2.py3-none-any.whl

ccxt/pro/okx.py

@@ -6,13 +6,16 @@
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide, ArrayCacheByTimestamp
 import hashlib
-from ccxt.base.types import Balances, Int, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade
+from ccxt.base.types import Balances, Int, Liquidation, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
+from typing import Any
+from ccxt.base.errors import ExchangeError
+from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import InvalidNonce
-from ccxt.base.errors import AuthenticationError
+from ccxt.base.errors import ChecksumError
 
 
 class okx(ccxt.async_support.okx):
@@ -22,17 +25,26 @@ class okx(ccxt.async_support.okx):
             'has': {
                 'ws': True,
                 'watchTicker': True,
+                'watchMarkPrice': True,
+                'watchMarkPrices': True,
                 'watchTickers': True,
+                'watchBidsAsks': True,
                 'watchOrderBook': True,
                 'watchTrades': True,
                 'watchTradesForSymbols': True,
                 'watchOrderBookForSymbols': True,
                 'watchBalance': True,
+                'watchLiquidations': 'emulated',
+                'watchLiquidationsForSymbols': True,
+                'watchMyLiquidations': 'emulated',
+                'watchMyLiquidationsForSymbols': True,
                 'watchOHLCV': True,
                 'watchOHLCVForSymbols': True,
                 'watchOrders': True,
                 'watchMyTrades': True,
                 'watchPositions': True,
+                'watchFundingRate': True,
+                'watchFundingRates': True,
                 'createOrderWs': True,
                 'editOrderWs': True,
                 'cancelOrderWs': True,
@@ -49,6 +61,7 @@ class okx(ccxt.async_support.okx):
             },
             'options': {
                 'watchOrderBook': {
+                    'checksum': True,
                     #
                     # bbo-tbt
                     # 1. Newly added channel that sends tick-by-tick Level 1 data
@@ -96,13 +109,12 @@ class okx(ccxt.async_support.okx):
                 'ws': {
                     # 'inflate': True,
                 },
-                'checksum': True,
             },
             'streaming': {
                 # okex does not support built-in ws protocol-level ping-pong
                 # instead it requires a custom text-based ping-pong
                 'ping': self.ping,
-                'keepAlive': 20000,
+                'keepAlive': 18000,
             },
         })
 
@@ -125,33 +137,33 @@ class okx(ccxt.async_support.okx):
             symbols = self.symbols
         symbols = self.market_symbols(symbols)
         url = self.get_url(channel, access)
-        messageHash = channel
+        messageHashes = []
         args = []
-        messageHash += '::' + ','.join(symbols)
         for i in range(0, len(symbols)):
             marketId = self.market_id(symbols[i])
-            arg = {
+            arg: dict = {
                 'channel': channel,
                 'instId': marketId,
             }
             args.append(self.extend(arg, params))
-        request = {
+            messageHashes.append(channel + '::' + symbols[i])
+        request: dict = {
             'op': 'subscribe',
             'args': args,
         }
-        return await self.watch(url, messageHash, request, messageHash)
+        return await self.watch_multiple(url, messageHashes, request, messageHashes)
 
     async def subscribe(self, access, messageHash, channel, symbol, params={}):
         await self.load_markets()
         url = self.get_url(channel, access)
-        firstArgument = {
+        firstArgument: dict = {
             'channel': channel,
         }
         if symbol is not None:
             market = self.market(symbol)
             messageHash += ':' + market['id']
             firstArgument['instId'] = market['id']
-        request = {
+        request: dict = {
             'op': 'subscribe',
             'args': [
                 self.deep_extend(firstArgument, params),
@@ -173,7 +185,7 @@ class okx(ccxt.async_support.okx):
     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
@@ -191,12 +203,12 @@ class okx(ccxt.async_support.okx):
             symbol = symbols[i]
             messageHashes.append(channel + ':' + symbol)
             marketId = self.market_id(symbol)
-            topic = {
+            topic: dict = {
                 'channel': channel,
                 'instId': marketId,
             }
             topics.append(topic)
-        request = {
+        request: dict = {
             'op': 'subscribe',
             'args': topics,
         }
@@ -208,6 +220,43 @@ class okx(ccxt.async_support.okx):
             limit = trades.getLimit(tradeSymbol, limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
+    async def un_watch_trades_for_symbols(self, symbols: List[str], params={}) -> Any:
+        """
+        unWatches from the stream channel
+        :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)
+        channel = 'trades'
+        topics = []
+        messageHashes = []
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            messageHashes.append('unsubscribe:trades:' + symbol)
+            marketId = self.market_id(symbol)
+            topic: dict = {
+                'channel': channel,
+                'instId': marketId,
+            }
+            topics.append(topic)
+        request: dict = {
+            'op': 'unsubscribe',
+            'args': topics,
+        }
+        url = self.get_url(channel, 'public')
+        return await self.watch_multiple(url, messageHashes, request, messageHashes)
+
+    async def un_watch_trades(self, symbol: str, params={}) -> Any:
+        """
+        unWatches from the stream channel
+        :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)
+
     def handle_trades(self, client: Client, message):
         #
         #     {
@@ -240,9 +289,90 @@ class okx(ccxt.async_support.okx):
             stored.append(trade)
             client.resolve(stored, messageHash)
 
+    async def watch_funding_rate(self, symbol: str, params={}) -> FundingRate:
+        """
+        watch the current funding rate
+
+        https://www.okx.com/docs-v5/en/#public-data-websocket-funding-rate-channel
+
+        :param str symbol: unified market symbol
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `funding rate structure <https://docs.ccxt.com/#/?id=funding-rate-structure>`
+        """
+        symbol = self.symbol(symbol)
+        fr = await self.watch_funding_rates([symbol], params)
+        return fr[symbol]
+
+    async def watch_funding_rates(self, symbols: List[str], params={}) -> FundingRates:
+        """
+        watch the funding rate for multiple markets
+
+        https://www.okx.com/docs-v5/en/#public-data-websocket-funding-rate-channel
+
+        :param str[] symbols: list of unified market symbols
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a dictionary of `funding rates structures <https://docs.ccxt.com/#/?id=funding-rates-structure>`, indexe by market symbols
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols)
+        channel = 'funding-rate'
+        topics = []
+        messageHashes = []
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            messageHashes.append(channel + ':' + symbol)
+            marketId = self.market_id(symbol)
+            topic: dict = {
+                'channel': channel,
+                'instId': marketId,
+            }
+            topics.append(topic)
+        request: dict = {
+            'op': 'subscribe',
+            'args': topics,
+        }
+        url = self.get_url(channel, 'public')
+        fundingRate = await self.watch_multiple(url, messageHashes, request, messageHashes)
+        if self.newUpdates:
+            symbol = self.safe_string(fundingRate, 'symbol')
+            result: dict = {}
+            result[symbol] = fundingRate
+            return result
+        return self.filter_by_array(self.fundingRates, 'symbol', symbols)
+
+    def handle_funding_rate(self, client: Client, message):
+        #
+        # "data":[
+        #     {
+        #        "fundingRate":"0.0001875391284828",
+        #        "fundingTime":"1700726400000",
+        #        "instId":"BTC-USD-SWAP",
+        #        "instType":"SWAP",
+        #        "method": "next_period",
+        #        "maxFundingRate":"0.00375",
+        #        "minFundingRate":"-0.00375",
+        #        "nextFundingRate":"0.0002608059239328",
+        #        "nextFundingTime":"1700755200000",
+        #        "premium": "0.0001233824646391",
+        #        "settFundingRate":"0.0001699799259033",
+        #        "settState":"settled",
+        #        "ts":"1700724675402"
+        #     }
+        # ]
+        #
+        data = self.safe_list(message, 'data', [])
+        for i in range(0, len(data)):
+            rawfr = data[i]
+            fundingRate = self.parse_funding_rate(rawfr)
+            symbol = fundingRate['symbol']
+            self.fundingRates[symbol] = fundingRate
+            client.resolve(fundingRate, 'funding-rate' + ':' + fundingRate['symbol'])
+
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
-        :see: https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-tickers-channel
+
+        https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-tickers-channel
+
         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 exchange API endpoint
@@ -252,20 +382,37 @@ class okx(ccxt.async_support.okx):
         channel = None
         channel, params = self.handle_option_and_params(params, 'watchTicker', 'channel', 'tickers')
         params['channel'] = channel
+        market = self.market(symbol)
+        symbol = market['symbol']
         ticker = await self.watch_tickers([symbol], params)
         return self.safe_value(ticker, symbol)
 
+    async def un_watch_ticker(self, symbol: str, params={}) -> Any:
+        """
+
+        https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-tickers-channel
+
+        unWatches 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 exchange API endpoint
+        :param str [params.channel]: the channel to subscribe to, tickers by default. Can be tickers, sprd-tickers, index-tickers, block-tickers
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        return await self.un_watch_tickers([symbol], params)
+
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
-        :see: https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-tickers-channel
+
+        https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-tickers-channel
+
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
         :param str[] [symbols]: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.channel]: the channel to subscribe to, tickers by default. Can be tickers, sprd-tickers, index-tickers, block-tickers
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
-        if self.is_empty(symbols):
-            raise ArgumentsRequired(self.id + ' watchTickers requires a list of symbols')
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
         channel = None
         channel, params = self.handle_option_and_params(params, 'watchTickers', 'channel', 'tickers')
         newTickers = await self.subscribe_multiple('public', channel, symbols, params)
@@ -273,6 +420,78 @@ class okx(ccxt.async_support.okx):
             return newTickers
         return self.filter_by_array(self.tickers, 'symbol', symbols)
 
+    async def watch_mark_price(self, symbol: str, params={}) -> Ticker:
+        """
+
+        https://www.okx.com/docs-v5/en/#public-data-websocket-mark-price-channel
+
+        watches a mark price
+        :param str symbol: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.channel]: the channel to subscribe to, tickers by default. Can be tickers, sprd-tickers, index-tickers, block-tickers
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        channel = None
+        channel, params = self.handle_option_and_params(params, 'watchMarkPrice', 'channel', 'mark-price')
+        params['channel'] = channel
+        market = self.market(symbol)
+        symbol = market['symbol']
+        ticker = await self.watch_mark_prices([symbol], params)
+        return ticker[symbol]
+
+    async def watch_mark_prices(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+
+        https://www.okx.com/docs-v5/en/#public-data-websocket-mark-price-channel
+
+        watches mark prices
+        :param str[] [symbols]: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.channel]: the channel to subscribe to, tickers by default. Can be tickers, sprd-tickers, index-tickers, block-tickers
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        channel = None
+        channel, params = self.handle_option_and_params(params, 'watchMarkPrices', 'channel', 'mark-price')
+        newTickers = await self.subscribe_multiple('public', channel, symbols, params)
+        if self.newUpdates:
+            return newTickers
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
+
+    async def un_watch_tickers(self, symbols: Strings = None, params={}) -> Any:
+        """
+
+        https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-tickers-channel
+
+        unWatches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+        :param str[] [symbols]: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.channel]: the channel to subscribe to, tickers by default. Can be tickers, sprd-tickers, index-tickers, block-tickers
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        channel = None
+        channel, params = self.handle_option_and_params(params, 'watchTickers', 'channel', 'tickers')
+        topics = []
+        messageHashes = []
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            messageHashes.append('unsubscribe:ticker:' + symbol)
+            marketId = self.market_id(symbol)
+            topic: dict = {
+                'channel': channel,
+                'instId': marketId,
+            }
+            topics.append(topic)
+        request: dict = {
+            'op': 'unsubscribe',
+            'args': topics,
+        }
+        url = self.get_url(channel, 'public')
+        return await self.watch_multiple(url, messageHashes, request, messageHashes)
+
     def handle_ticker(self, client: Client, message):
         #
         #     {
@@ -299,27 +518,370 @@ class okx(ccxt.async_support.okx):
         #         ]
         #     }
         #
+        self.handle_bid_ask(client, message)
         arg = self.safe_value(message, 'arg', {})
+        marketId = self.safe_string(arg, 'instId')
+        market = self.safe_market(marketId, None, '-')
+        symbol = market['symbol']
         channel = self.safe_string(arg, 'channel')
         data = self.safe_value(message, 'data', [])
-        newTickers = []
+        newTickers: dict = {}
         for i in range(0, len(data)):
             ticker = self.parse_ticker(data[i])
-            symbol = ticker['symbol']
             self.tickers[symbol] = ticker
-            newTickers.append(ticker)
-        messageHashes = self.find_message_hashes(client, channel + '::')
-        for i in range(0, len(messageHashes)):
-            messageHash = messageHashes[i]
-            parts = messageHash.split('::')
-            symbolsString = parts[1]
-            symbols = symbolsString.split(',')
-            tickers = self.filter_by_array(newTickers, 'symbol', symbols)
-            tickersSymbols = list(tickers.keys())
-            numTickers = len(tickersSymbols)
-            if numTickers > 0:
-                client.resolve(tickers, messageHash)
-        return message
+            newTickers[symbol] = ticker
+        messageHash = channel + '::' + symbol
+        client.resolve(newTickers, messageHash)
+
+    async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+
+        https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-tickers-channel
+
+        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
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        channel = None
+        channel, params = self.handle_option_and_params(params, 'watchBidsAsks', 'channel', 'tickers')
+        url = self.get_url(channel, 'public')
+        messageHashes = []
+        args = []
+        for i in range(0, len(symbols)):
+            marketId = self.market_id(symbols[i])
+            arg: dict = {
+                'channel': channel,
+                'instId': marketId,
+            }
+            args.append(self.extend(arg, params))
+            messageHashes.append('bidask::' + symbols[i])
+        request: dict = {
+            'op': 'subscribe',
+            'args': args,
+        }
+        newTickers = await self.watch_multiple(url, messageHashes, request, messageHashes)
+        if self.newUpdates:
+            tickers: dict = {}
+            tickers[newTickers['symbol']] = newTickers
+            return tickers
+        return self.filter_by_array(self.bidsasks, 'symbol', symbols)
+
+    def handle_bid_ask(self, client: Client, message):
+        #
+        #     {
+        #         "arg": {channel: "tickers", instId: "BTC-USDT"},
+        #         "data": [
+        #             {
+        #                 "instType": "SPOT",
+        #                 "instId": "BTC-USDT",
+        #                 "last": "31500.1",
+        #                 "lastSz": "0.00001754",
+        #                 "askPx": "31500.1",
+        #                 "askSz": "0.00998144",
+        #                 "bidPx": "31500",
+        #                 "bidSz": "3.05652439",
+        #                 "open24h": "31697",
+        #                 "high24h": "32248",
+        #                 "low24h": "31165.6",
+        #                 "sodUtc0": "31385.5",
+        #                 "sodUtc8": "32134.9",
+        #                 "volCcy24h": "503403597.38138519",
+        #                 "vol24h": "15937.10781721",
+        #                 "ts": "1626526618762"
+        #             }
+        #         ]
+        #     }
+        #
+        data = self.safe_list(message, 'data', [])
+        ticker = self.safe_dict(data, 0, {})
+        parsedTicker = self.parse_ws_bid_ask(ticker)
+        symbol = parsedTicker['symbol']
+        self.bidsasks[symbol] = parsedTicker
+        messageHash = 'bidask::' + symbol
+        client.resolve(parsedTicker, messageHash)
+
+    def parse_ws_bid_ask(self, ticker, market=None):
+        marketId = self.safe_string(ticker, 'instId')
+        market = self.safe_market(marketId, market)
+        symbol = self.safe_string(market, 'symbol')
+        timestamp = self.safe_integer(ticker, 'ts')
+        return self.safe_ticker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'ask': self.safe_string(ticker, 'askPx'),
+            'askVolume': self.safe_string(ticker, 'askSz'),
+            'bid': self.safe_string(ticker, 'bidPx'),
+            'bidVolume': self.safe_string(ticker, 'bidSz'),
+            'info': ticker,
+        }, market)
+
+    async def watch_liquidations_for_symbols(self, symbols: List[str] = None, since: Int = None, limit: Int = None, params={}) -> List[Liquidation]:
+        """
+        watch the public liquidations of a trading pair
+
+        https://www.okx.com/docs-v5/en/#public-data-websocket-liquidation-orders-channel
+
+        :param str symbols:
+        :param int [since]: the earliest time in ms to fetch liquidations for
+        :param int [limit]: the maximum number of liquidation structures to retrieve
+        :param dict [params]: exchange specific parameters for the okx api endpoint
+        :returns dict: an array of `liquidation structures <https://github.com/ccxt/ccxt/wiki/Manual#liquidation-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, True, True)
+        messageHash = 'liquidations'
+        messageHashes = []
+        if symbols is not None:
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                messageHashes.append(messageHash + '::' + symbol)
+        else:
+            messageHashes.append(messageHash)
+        market = self.get_market_from_symbols(symbols)
+        type = None
+        type, params = self.handle_market_type_and_params('watchliquidationsForSymbols', market, params)
+        channel = 'liquidation-orders'
+        if type == 'spot':
+            type = 'SWAP'
+        elif type == 'future':
+            type = 'futures'
+        uppercaseType = type.upper()
+        request = {
+            'op': 'subscribe',
+            'args': [
+                {
+                    'channel': channel,
+                    'instType': uppercaseType,
+                },
+            ],
+        }
+        url = self.get_url(channel, 'public')
+        newLiquidations = await self.watch_multiple(url, messageHashes, request, messageHashes)
+        if self.newUpdates:
+            return newLiquidations
+        return self.filter_by_symbols_since_limit(self.liquidations, symbols, since, limit, True)
+
+    def handle_liquidation(self, client: Client, message):
+        #
+        #    {
+        #        "arg": {
+        #            "channel": "liquidation-orders",
+        #            "instType": "SWAP"
+        #        },
+        #        "data": [
+        #            {
+        #                "details": [
+        #                    {
+        #                        "bkLoss": "0",
+        #                        "bkPx": "0.007831",
+        #                        "ccy": "",
+        #                        "posSide": "short",
+        #                        "side": "buy",
+        #                        "sz": "13",
+        #                        "ts": "1692266434010"
+        #                    }
+        #                ],
+        #                "instFamily": "IOST-USDT",
+        #                "instId": "IOST-USDT-SWAP",
+        #                "instType": "SWAP",
+        #                "uly": "IOST-USDT"
+        #            }
+        #        ]
+        #    }
+        #
+        rawLiquidations = self.safe_list(message, 'data', [])
+        for i in range(0, len(rawLiquidations)):
+            rawLiquidation = rawLiquidations[i]
+            liquidation = self.parse_ws_liquidation(rawLiquidation)
+            symbol = self.safe_string(liquidation, 'symbol')
+            liquidations = self.safe_value(self.liquidations, symbol)
+            if liquidations is None:
+                limit = self.safe_integer(self.options, 'liquidationsLimit', 1000)
+                liquidations = ArrayCache(limit)
+            liquidations.append(liquidation)
+            self.liquidations[symbol] = liquidations
+            client.resolve([liquidation], 'liquidations')
+            client.resolve([liquidation], 'liquidations::' + symbol)
+
+    async def watch_my_liquidations_for_symbols(self, symbols: List[str] = None, since: Int = None, limit: Int = None, params={}) -> List[Liquidation]:
+        """
+        watch the private liquidations of a trading pair
+
+        https://www.okx.com/docs-v5/en/#trading-account-websocket-balance-and-position-channel
+
+        :param str[] symbols:
+        :param int [since]: the earliest time in ms to fetch liquidations for
+        :param int [limit]: the maximum number of liquidation structures to retrieve
+        :param dict [params]: exchange specific parameters for the okx api endpoint
+        :returns dict: an array of `liquidation structures <https://github.com/ccxt/ccxt/wiki/Manual#liquidation-structure>`
+        """
+        await self.load_markets()
+        isTrigger = self.safe_value_2(params, 'stop', 'trigger', False)
+        params = self.omit(params, ['stop', 'trigger'])
+        await self.authenticate({'access': 'business' if isTrigger else 'private'})
+        symbols = self.market_symbols(symbols, None, True, True)
+        messageHash = 'myLiquidations'
+        messageHashes = []
+        if symbols is not None:
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                messageHashes.append(messageHash + '::' + symbol)
+        else:
+            messageHashes.append(messageHash)
+        channel = 'balance_and_position'
+        request: dict = {
+            'op': 'subscribe',
+            'args': [
+                {
+                    'channel': channel,
+                },
+            ],
+        }
+        url = self.get_url(channel, 'private')
+        newLiquidations = await self.watch_multiple(url, messageHashes, self.deep_extend(request, params), messageHashes)
+        if self.newUpdates:
+            return newLiquidations
+        return self.filter_by_symbols_since_limit(self.liquidations, symbols, since, limit, True)
+
+    def handle_my_liquidation(self, client: Client, message):
+        #
+        #    {
+        #        "arg": {
+        #            "channel": "balance_and_position",
+        #            "uid": "77982378738415879"
+        #        },
+        #        "data": [{
+        #            "pTime": "1597026383085",
+        #            "eventType": "snapshot",
+        #            "balData": [{
+        #                "ccy": "BTC",
+        #                "cashBal": "1",
+        #                "uTime": "1597026383085"
+        #            }],
+        #            "posData": [{
+        #                "posId": "1111111111",
+        #                "tradeId": "2",
+        #                "instId": "BTC-USD-191018",
+        #                "instType": "FUTURES",
+        #                "mgnMode": "cross",
+        #                "posSide": "long",
+        #                "pos": "10",
+        #                "ccy": "BTC",
+        #                "posCcy": "",
+        #                "avgPx": "3320",
+        #                "uTIme": "1597026383085"
+        #            }],
+        #            "trades": [{
+        #                "instId": "BTC-USD-191018",
+        #                "tradeId": "2",
+        #            }]
+        #        }]
+        #    }
+        #
+        rawLiquidations = self.safe_list(message, 'data', [])
+        for i in range(0, len(rawLiquidations)):
+            rawLiquidation = rawLiquidations[i]
+            eventType = self.safe_string(rawLiquidation, 'eventType')
+            if eventType != 'liquidation':
+                return
+            liquidation = self.parse_ws_my_liquidation(rawLiquidation)
+            symbol = self.safe_string(liquidation, 'symbol')
+            liquidations = self.safe_value(self.liquidations, symbol)
+            if liquidations is None:
+                limit = self.safe_integer(self.options, 'myLiquidationsLimit', 1000)
+                liquidations = ArrayCache(limit)
+            liquidations.append(liquidation)
+            self.liquidations[symbol] = liquidations
+            client.resolve([liquidation], 'myLiquidations')
+            client.resolve([liquidation], 'myLiquidations::' + symbol)
+
+    def parse_ws_my_liquidation(self, liquidation, market=None):
+        #
+        #    {
+        #        "pTime": "1597026383085",
+        #        "eventType": "snapshot",
+        #        "balData": [{
+        #            "ccy": "BTC",
+        #            "cashBal": "1",
+        #            "uTime": "1597026383085"
+        #        }],
+        #        "posData": [{
+        #            "posId": "1111111111",
+        #            "tradeId": "2",
+        #            "instId": "BTC-USD-191018",
+        #            "instType": "FUTURES",
+        #            "mgnMode": "cross",
+        #            "posSide": "long",
+        #            "pos": "10",
+        #            "ccy": "BTC",
+        #            "posCcy": "",
+        #            "avgPx": "3320",
+        #            "uTIme": "1597026383085"
+        #        }],
+        #        "trades": [{
+        #            "instId": "BTC-USD-191018",
+        #            "tradeId": "2",
+        #        }]
+        #    }
+        #
+        posData = self.safe_list(liquidation, 'posData', [])
+        firstPosData = self.safe_dict(posData, 0, {})
+        marketId = self.safe_string(firstPosData, 'instId')
+        market = self.safe_market(marketId, market)
+        timestamp = self.safe_integer(firstPosData, 'uTIme')
+        return self.safe_liquidation({
+            'info': liquidation,
+            'symbol': self.safe_symbol(marketId, market),
+            'contracts': self.safe_number(firstPosData, 'pos'),
+            'contractSize': self.safe_number(market, 'contractSize'),
+            'price': self.safe_number(liquidation, 'avgPx'),
+            'baseValue': None,
+            'quoteValue': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+        })
+
+    def parse_ws_liquidation(self, liquidation, market=None):
+        #
+        # public liquidation
+        #    {
+        #        "details": [
+        #            {
+        #                "bkLoss": "0",
+        #                "bkPx": "0.007831",
+        #                "ccy": "",
+        #                "posSide": "short",
+        #                "side": "buy",
+        #                "sz": "13",
+        #                "ts": "1692266434010"
+        #            }
+        #        ],
+        #        "instFamily": "IOST-USDT",
+        #        "instId": "IOST-USDT-SWAP",
+        #        "instType": "SWAP",
+        #        "uly": "IOST-USDT"
+        #    }
+        #
+        details = self.safe_list(liquidation, 'details', [])
+        liquidationDetails = self.safe_dict(details, 0, {})
+        marketId = self.safe_string(liquidation, 'instId')
+        market = self.safe_market(marketId, market)
+        timestamp = self.safe_integer(liquidationDetails, 'ts')
+        return self.safe_liquidation({
+            'info': liquidation,
+            'symbol': self.safe_symbol(marketId, market),
+            'contracts': self.safe_number(liquidationDetails, 'sz'),
+            'contractSize': self.safe_number(market, 'contractSize'),
+            'price': self.safe_number(liquidationDetails, 'bkPx'),
+            'baseValue': None,
+            'quoteValue': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+        })
 
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
@@ -340,6 +902,17 @@ class okx(ccxt.async_support.okx):
             limit = ohlcv.getLimit(symbol, limit)
         return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
+    async def un_watch_ohlcv(self, symbol: str, timeframe='1m', params={}) -> Any:
+        """
+        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
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns int[][]: A list of candles ordered, open, high, low, close, volume
+        """
+        await self.load_markets()
+        return await self.un_watch_ohlcv_for_symbols([[symbol, timeframe]], params)
+
     async def watch_ohlcv_for_symbols(self, symbolsAndTimeframes: List[List[str]], since: Int = None, limit: Int = None, params={}):
         """
         watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
@@ -362,13 +935,13 @@ class okx(ccxt.async_support.okx):
             marketId = self.market_id(sym)
             interval = self.safe_string(self.timeframes, tf, tf)
             channel = 'candle' + interval
-            topic = {
+            topic: dict = {
                 'channel': channel,
                 'instId': marketId,
             }
             topics.append(topic)
             messageHashes.append('multi:' + channel + ':' + sym)
-        request = {
+        request: dict = {
             'op': 'subscribe',
             'args': topics,
         }
@@ -379,6 +952,39 @@ class okx(ccxt.async_support.okx):
         filtered = self.filter_by_since_limit(candles, since, limit, 0, True)
         return self.create_ohlcv_object(symbol, timeframe, filtered)
 
+    async def un_watch_ohlcv_for_symbols(self, symbolsAndTimeframes: List[List[str]], params={}) -> Any:
+        """
+        unWatches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        :param str[][] symbolsAndTimeframes: array of arrays containing unified symbols and timeframes to fetch OHLCV data for, example [['BTC/USDT', '1m'], ['LTC/USDT', '5m']]
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns int[][]: A list of candles ordered, open, high, low, close, volume
+        """
+        symbolsLength = len(symbolsAndTimeframes)
+        if symbolsLength == 0 or not isinstance(symbolsAndTimeframes[0], list):
+            raise ArgumentsRequired(self.id + " watchOHLCVForSymbols() requires a an array of symbols and timeframes, like  [['BTC/USDT', '1m'], ['LTC/USDT', '5m']]")
+        await self.load_markets()
+        topics = []
+        messageHashes = []
+        for i in range(0, len(symbolsAndTimeframes)):
+            symbolAndTimeframe = symbolsAndTimeframes[i]
+            sym = symbolAndTimeframe[0]
+            tf = symbolAndTimeframe[1]
+            marketId = self.market_id(sym)
+            interval = self.safe_string(self.timeframes, tf, tf)
+            channel = 'candle' + interval
+            topic: dict = {
+                'channel': channel,
+                'instId': marketId,
+            }
+            topics.append(topic)
+            messageHashes.append('unsubscribe:multi:' + channel + ':' + sym)
+        request: dict = {
+            'op': 'unsubscribe',
+            'args': topics,
+        }
+        url = self.get_url('candle', 'public')
+        return await self.watch_multiple(url, messageHashes, request, messageHashes)
+
     def handle_ohlcv(self, client: Client, message):
         #
         #     {
@@ -424,10 +1030,14 @@ class okx(ccxt.async_support.okx):
 
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
+
+        https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-order-book-channel
+
         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 [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.depth]: okx order book depth, can be books, books5, books-l2-tbt, books50-l2-tbt, bbo-tbt
         :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
         """
         #
@@ -457,17 +1067,32 @@ class okx(ccxt.async_support.okx):
 
     async def watch_order_book_for_symbols(self, symbols: List[str], limit: Int = None, params={}) -> OrderBook:
         """
+
+        https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-order-book-channel
+
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
         :param str[] symbols: unified array of symbols
-        :param int [limit]: the maximum amount of order book entries to return
+        :param int [limit]: 1,5, 400, 50(l2-tbt, vip4+) or 40000(vip5+) the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.depth]: okx order book depth, can be books, books5, books-l2-tbt, books50-l2-tbt, bbo-tbt
         :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)
-        options = self.safe_value(self.options, 'watchOrderBook', {})
-        depth = self.safe_string(options, 'depth', 'books')
+        depth = None
+        depth, params = self.handle_option_and_params(params, 'watchOrderBook', 'depth', 'books')
+        if limit is not None:
+            if limit == 1:
+                depth = 'bbo-tbt'
+            elif limit > 1 and limit <= 5:
+                depth = 'books5'
+            elif limit == 50:
+                depth = 'books50-l2-tbt'  # Make sure you have VIP4 and above
+            elif limit == 400:
+                depth = 'books'
         if (depth == 'books-l2-tbt') or (depth == 'books50-l2-tbt'):
+            if not self.check_required_credentials(False):
+                raise AuthenticationError(self.id + ' watchOrderBook/watchOrderBookForSymbols requires authentication for self depth. Add credentials or change the depth option to books or books5')
             await self.authenticate({'access': 'public'})
         topics = []
         messageHashes = []
@@ -475,12 +1100,12 @@ class okx(ccxt.async_support.okx):
             symbol = symbols[i]
             messageHashes.append(depth + ':' + symbol)
             marketId = self.market_id(symbol)
-            topic = {
+            topic: dict = {
                 'channel': depth,
                 'instId': marketId,
             }
             topics.append(topic)
-        request = {
+        request: dict = {
             'op': 'subscribe',
             'args': topics,
         }
@@ -488,6 +1113,66 @@ class okx(ccxt.async_support.okx):
         orderbook = await self.watch_multiple(url, messageHashes, request, messageHashes)
         return orderbook.limit()
 
+    async def un_watch_order_book_for_symbols(self, symbols: List[str], params={}) -> Any:
+        """
+
+        https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-order-book-channel
+
+        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
+        :param int [params.limit]: the maximum amount of order book entries to return
+        :param str [params.depth]: okx order book depth, can be books, books5, books-l2-tbt, books50-l2-tbt, bbo-tbt
+        :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, None, False)
+        depth = None
+        depth, params = self.handle_option_and_params(params, 'watchOrderBook', 'depth', 'books')
+        limit = self.safe_integer(params, 'limit')
+        if limit is not None:
+            if limit == 1:
+                depth = 'bbo-tbt'
+            elif limit > 1 and limit <= 5:
+                depth = 'books5'
+            elif limit == 50:
+                depth = 'books50-l2-tbt'  # Make sure you have VIP4 and above
+            elif limit == 400:
+                depth = 'books'
+        topics = []
+        subMessageHashes = []
+        messageHashes = []
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            subMessageHashes.append(depth + ':' + symbol)
+            messageHashes.append('unsubscribe:orderbook:' + symbol)
+            marketId = self.market_id(symbol)
+            topic: dict = {
+                'channel': depth,
+                'instId': marketId,
+            }
+            topics.append(topic)
+        request: dict = {
+            'op': 'unsubscribe',
+            'args': topics,
+        }
+        url = self.get_url(depth, 'public')
+        return await self.watch_multiple(url, messageHashes, request, messageHashes)
+
+    async def un_watch_order_book(self, symbol: str, params={}) -> Any:
+        """
+
+        https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-order-book-channel
+
+        unWatches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        :param str symbol: unified array of symbols
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param int [params.limit]: the maximum amount of order book entries to return
+        :param str [params.depth]: okx order book depth, can be books, books5, books-l2-tbt, books50-l2-tbt, bbo-tbt
+        :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)
+
     def handle_delta(self, bookside, delta):
         #
         #     [
@@ -505,7 +1190,7 @@ class okx(ccxt.async_support.okx):
         for i in range(0, len(deltas)):
             self.handle_delta(bookside, deltas[i])
 
-    def handle_order_book_message(self, client: Client, message, orderbook, messageHash):
+    def handle_order_book_message(self, client: Client, message, orderbook, messageHash, market=None):
         #
         #     {
         #         "asks": [
@@ -520,6 +1205,9 @@ class okx(ccxt.async_support.okx):
         #         ],
         #         "instId": "BTC-USDT",
         #         "ts": "1626537446491"
+        #         "checksum": -855196043,
+        #         "prevSeqId": 123456,
+        #         "seqId": 123457
         #     }
         #
         asks = self.safe_value(message, 'asks', [])
@@ -528,8 +1216,13 @@ class okx(ccxt.async_support.okx):
         storedBids = orderbook['bids']
         self.handle_deltas(storedAsks, asks)
         self.handle_deltas(storedBids, bids)
-        checksum = self.safe_bool(self.options, 'checksum', True)
+        marketId = self.safe_string(message, 'instId')
+        symbol = self.safe_symbol(marketId, market)
+        checksum = self.handle_option('watchOrderBook', 'checksum', True)
+        seqId = self.safe_integer(message, 'seqId')
         if checksum:
+            prevSeqId = self.safe_integer(message, 'prevSeqId')
+            nonce = orderbook['nonce']
             asksLength = len(storedAsks)
             bidsLength = len(storedBids)
             payloadArray = []
@@ -543,10 +1236,17 @@ class okx(ccxt.async_support.okx):
             payload = ':'.join(payloadArray)
             responseChecksum = self.safe_integer(message, 'checksum')
             localChecksum = self.crc32(payload, True)
+            error = None
+            if prevSeqId != -1 and nonce != prevSeqId:
+                error = InvalidNonce(self.id + ' watchOrderBook received invalid nonce')
             if responseChecksum != localChecksum:
-                error = InvalidNonce(self.id + ' invalid checksum')
+                error = ChecksumError(self.id + ' ' + self.orderbook_checksum_message(symbol))
+            if error is not None:
+                del client.subscriptions[messageHash]
+                del self.orderbooks[symbol]
                 client.reject(error, messageHash)
         timestamp = self.safe_integer(message, 'ts')
+        orderbook['nonce'] = seqId
         orderbook['timestamp'] = timestamp
         orderbook['datetime'] = self.iso8601(timestamp)
         return orderbook
@@ -637,14 +1337,14 @@ class okx(ccxt.async_support.okx):
         #         ]
         #     }
         #
-        arg = self.safe_value(message, 'arg', {})
+        arg = self.safe_dict(message, 'arg', {})
         channel = self.safe_string(arg, 'channel')
         action = self.safe_string(message, 'action')
-        data = self.safe_value(message, 'data', [])
+        data = self.safe_list(message, 'data', [])
         marketId = self.safe_string(arg, 'instId')
         market = self.safe_market(marketId)
         symbol = market['symbol']
-        depths = {
+        depths: dict = {
             'bbo-tbt': 1,
             'books': 400,
             'books5': 5,
@@ -666,13 +1366,12 @@ class okx(ccxt.async_support.okx):
                 orderbook = self.orderbooks[symbol]
                 for i in range(0, len(data)):
                     update = data[i]
-                    self.handle_order_book_message(client, update, orderbook, messageHash)
+                    self.handle_order_book_message(client, update, orderbook, messageHash, market)
                     client.resolve(orderbook, messageHash)
         elif (channel == 'books5') or (channel == 'bbo-tbt'):
-            orderbook = self.safe_value(self.orderbooks, symbol)
-            if orderbook is None:
-                orderbook = self.order_book({}, limit)
-            self.orderbooks[symbol] = orderbook
+            if not (symbol in self.orderbooks):
+                self.orderbooks[symbol] = self.order_book({}, limit)
+            orderbook = self.orderbooks[symbol]
             for i in range(0, len(data)):
                 update = data[i]
                 timestamp = self.safe_integer(update, 'ts')
@@ -697,7 +1396,7 @@ class okx(ccxt.async_support.okx):
             auth = timestamp + method + path
             signature = self.hmac(self.encode(auth), self.encode(self.secret), hashlib.sha256, 'base64')
             operation = 'login'
-            request = {
+            request: dict = {
                 'op': operation,
                 'args': [
                     {
@@ -708,8 +1407,10 @@ class okx(ccxt.async_support.okx):
                     },
                 ],
             }
-            message = self.extend(request, params)
-            self.watch(url, messageHash, message, messageHash)
+            # Only add params['access'] to prevent sending custom parameters, such.
+            if 'access' in params:
+                request['access'] = params['access']
+            self.watch(url, messageHash, request, messageHash)
         return await future
 
     async def watch_balance(self, params={}) -> Balances:
@@ -722,6 +1423,9 @@ class okx(ccxt.async_support.okx):
         await self.authenticate()
         return await self.subscribe('private', 'account', 'account', None, params)
 
+    def handle_balance_and_position(self, client: Client, message):
+        self.handle_my_liquidation(client, message)
+
     def handle_balance(self, client: Client, message):
         #
         #     {
@@ -802,24 +1506,26 @@ class okx(ccxt.async_support.okx):
     async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         watches information on multiple trades made by the user
-        :see: https://www.okx.com/docs-v5/en/#order-book-trading-trade-ws-order-channel
+
+        https://www.okx.com/docs-v5/en/#order-book-trading-trade-ws-order-channel
+
         :param str [symbol]: unified market symbol of the market trades were made in
         :param int [since]: the earliest time in ms to fetch trades for
         :param int [limit]: the maximum number of trade structures to retrieve
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :param bool [params.stop]: True if fetching trigger or conditional trades
+        :param bool [params.trigger]: True if fetching trigger or conditional trades
         :param str [params.type]: 'spot', 'swap', 'future', 'option', 'ANY', 'SPOT', 'MARGIN', 'SWAP', 'FUTURES' or 'OPTION'
         :param str [params.marginMode]: 'cross' or 'isolated', for automatically setting the type to spot margin
-        :returns dict[]: a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
         """
         # By default, receive order updates from any instrument type
         type = None
         type, params = self.handle_option_and_params(params, 'watchMyTrades', 'type', 'ANY')
-        isStop = self.safe_bool(params, 'stop', False)
-        params = self.omit(params, ['stop'])
+        isTrigger = self.safe_bool_2(params, 'trigger', 'stop', False)
+        params = self.omit(params, ['trigger', 'stop'])
         await self.load_markets()
-        await self.authenticate({'access': 'business' if isStop else 'private'})
-        channel = 'orders-algo' if isStop else 'orders'
+        await self.authenticate({'access': 'business' if isTrigger else 'private'})
+        channel = 'orders-algo' if isTrigger else 'orders'
         messageHash = channel + '::myTrades'
         market = None
         if symbol is not None:
@@ -835,7 +1541,7 @@ class okx(ccxt.async_support.okx):
         if uppercaseType == 'SPOT':
             if marginMode is not None:
                 uppercaseType = 'MARGIN'
-        request = {
+        request: dict = {
             'instType': uppercaseType,
         }
         orders = await self.subscribe('private', messageHash, channel, None, self.extend(request, params))
@@ -845,27 +1551,31 @@ class okx(ccxt.async_support.okx):
 
     async def watch_positions(self, symbols: Strings = None, since: Int = None, limit: Int = None, params={}) -> List[Position]:
         """
-        :see: https://www.okx.com/docs-v5/en/#trading-account-websocket-positions-channel
+
+        https://www.okx.com/docs-v5/en/#trading-account-websocket-positions-channel
+
         watch all open positions
         :param str[]|None symbols: list of unified market symbols
+ @param since
+ @param limit
         :param dict params: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
         """
         await self.load_markets()
         await self.authenticate(params)
         symbols = self.market_symbols(symbols)
-        request = {
+        request: dict = {
             'instType': 'ANY',
         }
         channel = 'positions'
         newPositions = None
         if symbols is None:
-            arg = {
+            arg: dict = {
                 'channel': 'positions',
                 'instType': 'ANY',
             }
-            args = [arg]
-            nonSymbolRequest = {
+            args = [self.extend(arg, params)]
+            nonSymbolRequest: dict = {
                 'op': 'subscribe',
                 'args': args,
             }
@@ -945,6 +1655,9 @@ class okx(ccxt.async_support.okx):
         #    }
         #
         arg = self.safe_value(message, 'arg', {})
+        marketId = self.safe_string(arg, 'instId')
+        market = self.safe_market(marketId, None, '-')
+        symbol = market['symbol']
         channel = self.safe_string(arg, 'channel', '')
         data = self.safe_value(message, 'data', [])
         if self.positions is None:
@@ -954,28 +1667,30 @@ class okx(ccxt.async_support.okx):
         for i in range(0, len(data)):
             rawPosition = data[i]
             position = self.parse_position(rawPosition)
+            if position['contracts'] == 0:
+                position['side'] = 'long'
+                shortPosition = self.clone(position)
+                shortPosition['side'] = 'short'
+                cache.append(shortPosition)
+                newPositions.append(shortPosition)
             newPositions.append(position)
             cache.append(position)
-        messageHashes = self.find_message_hashes(client, channel + '::')
-        for i in range(0, len(messageHashes)):
-            messageHash = messageHashes[i]
-            parts = messageHash.split('::')
-            symbolsString = parts[1]
-            symbols = symbolsString.split(',')
-            positions = self.filter_by_array(newPositions, 'symbol', symbols, False)
-            if not self.is_empty(positions):
-                client.resolve(positions, messageHash)
-        client.resolve(newPositions, channel)
+        messageHash = channel
+        if symbol is not None:
+            messageHash = channel + '::' + symbol
+        client.resolve(newPositions, messageHash)
 
     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://www.okx.com/docs-v5/en/#order-book-trading-trade-ws-order-channel
+
+        https://www.okx.com/docs-v5/en/#order-book-trading-trade-ws-order-channel
+
         :param str [symbol]: unified market symbol of the market the 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
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :param bool [params.stop]: True if fetching trigger or conditional orders
+        :param bool [params.trigger]: True if fetching trigger or conditional orders
         :param str [params.type]: 'spot', 'swap', 'future', 'option', 'ANY', 'SPOT', 'MARGIN', 'SWAP', 'FUTURES' or 'OPTION'
         :param str [params.marginMode]: 'cross' or 'isolated', for automatically setting the type to spot margin
         :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
@@ -983,10 +1698,10 @@ class okx(ccxt.async_support.okx):
         type = None
         # By default, receive order updates from any instrument type
         type, params = self.handle_option_and_params(params, 'watchOrders', 'type', 'ANY')
-        isStop = self.safe_value_2(params, 'stop', 'trigger', False)
+        isTrigger = self.safe_value_2(params, 'stop', 'trigger', False)
         params = self.omit(params, ['stop', 'trigger'])
         await self.load_markets()
-        await self.authenticate({'access': 'business' if isStop else 'private'})
+        await self.authenticate({'access': 'business' if isTrigger else 'private'})
         market = None
         if symbol is not None:
             market = self.market(symbol)
@@ -1000,10 +1715,10 @@ class okx(ccxt.async_support.okx):
         if uppercaseType == 'SPOT':
             if marginMode is not None:
                 uppercaseType = 'MARGIN'
-        request = {
+        request: dict = {
             'instType': uppercaseType,
         }
-        channel = 'orders-algo' if isStop else 'orders'
+        channel = 'orders-algo' if isTrigger else 'orders'
         orders = await self.subscribe('private', channel, channel, symbol, self.extend(request, params))
         if self.newUpdates:
             limit = orders.getLimit(symbol, limit)
@@ -1161,7 +1876,7 @@ class okx(ccxt.async_support.okx):
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
             self.myTrades = ArrayCacheBySymbolById(limit)
         myTrades = self.myTrades
-        symbols = {}
+        symbols: dict = {}
         for i in range(0, len(filteredOrders)):
             rawTrade = filteredOrders[i]
             trade = self.order_to_trade(rawTrade)
@@ -1173,17 +1888,25 @@ class okx(ccxt.async_support.okx):
         tradeSymbols = list(symbols.keys())
         for i in range(0, len(tradeSymbols)):
             symbolMessageHash = messageHash + '::' + tradeSymbols[i]
-            client.resolve(self.orders, symbolMessageHash)
+            client.resolve(self.myTrades, symbolMessageHash)
+
+    def request_id(self):
+        ts = str(self.milliseconds())
+        randomNumber = self.rand_number(4)
+        randomPart = str(randomNumber)
+        return ts + randomPart
 
     async def create_order_ws(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}) -> Order:
         """
-        :see: https://www.okx.com/docs-v5/en/#websocket-api-trade-place-order
+
+        https://www.okx.com/docs-v5/en/#websocket-api-trade-place-order
+
         create a trade order
         :param str symbol: unified symbol of the market to create an order in
         :param str type: 'market' or 'limit'
         :param str side: 'buy' or 'sell'
         :param float amount: how much of currency you want to trade in units of base currency
-        :param float|None [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param float|None [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param boolean params['test']: test order, default False
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
@@ -1191,7 +1914,7 @@ class okx(ccxt.async_support.okx):
         await self.load_markets()
         await self.authenticate()
         url = self.get_url('private', 'private')
-        messageHash = str(self.nonce())
+        messageHash = self.request_id()
         op = None
         op, params = self.handle_option_and_params(params, 'createOrderWs', 'op', 'batch-orders')
         args = self.create_order_request(symbol, type, side, amount, price, params)
@@ -1200,7 +1923,7 @@ class okx(ccxt.async_support.okx):
             raise BadRequest(self.id + ' createOrderWs() does not support algo trading. self.options["createOrderWs"]["op"] must be either order or batch-order')
         if (op != 'order') and (op != 'batch-orders'):
             raise BadRequest(self.id + ' createOrderWs() does not support algo trading. self.options["createOrderWs"]["op"] must be either order or privatePostTradeOrder or privatePostTradeOrderAlgo')
-        request = {
+        request: dict = {
             'id': messageHash,
             'op': op,
             'args': [args],
@@ -1234,32 +1957,35 @@ class okx(ccxt.async_support.okx):
         if self.is_empty(args):
             method = self.safe_string(message, 'op')
             stringMsg = self.json(message)
-            self.handle_errors(None, None, client.url, method, None, stringMsg, stringMsg, None, None)
+            self.handle_errors(None, None, client.url, method, None, stringMsg, message, None, None)
         orders = self.parse_orders(args, None, None, None)
-        client.resolve(orders, messageHash)
+        first = self.safe_dict(orders, 0, {})
+        client.resolve(first, messageHash)
 
-    async def edit_order_ws(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}) -> Order:
+    async def edit_order_ws(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: Num = None, price: Num = None, params={}) -> Order:
         """
         edit a trade order
-        :see: https://www.okx.com/docs-v5/en/#order-book-trading-trade-ws-amend-order
-        :see: https://www.okx.com/docs-v5/en/#order-book-trading-trade-ws-amend-multiple-orders
+
+        https://www.okx.com/docs-v5/en/#order-book-trading-trade-ws-amend-order
+        https://www.okx.com/docs-v5/en/#order-book-trading-trade-ws-amend-multiple-orders
+
         :param str id: order id
         :param str symbol: unified symbol of the market to create an order in
         :param str type: 'market' or 'limit'
         :param str side: 'buy' or 'sell'
         :param float amount: how much of the currency you want to trade in units of the base currency
-        :param float|None [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param float|None [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
         await self.authenticate()
         url = self.get_url('private', 'private')
-        messageHash = str(self.nonce())
+        messageHash = self.request_id()
         op = None
         op, params = self.handle_option_and_params(params, 'editOrderWs', 'op', 'amend-order')
         args = self.edit_order_request(id, symbol, type, side, amount, price, params)
-        request = {
+        request: dict = {
             'id': messageHash,
             'op': op,
             'args': [args],
@@ -1268,7 +1994,9 @@ class okx(ccxt.async_support.okx):
 
     async def cancel_order_ws(self, id: str, symbol: Str = None, params={}) -> Order:
         """
-        :see: https://okx-docs.github.io/apidocs/websocket_api/en/#cancel-order-trade
+
+        https://okx-docs.github.io/apidocs/websocket_api/en/#cancel-order-trade
+
         cancel multiple orders
         :param str id: order id
         :param str symbol: unified market symbol, default is None
@@ -1281,17 +2009,17 @@ class okx(ccxt.async_support.okx):
         await self.load_markets()
         await self.authenticate()
         url = self.get_url('private', 'private')
-        messageHash = str(self.nonce())
+        messageHash = self.request_id()
         clientOrderId = self.safe_string_2(params, 'clOrdId', 'clientOrderId')
         params = self.omit(params, ['clientOrderId', 'clOrdId'])
-        arg = {
+        arg: dict = {
             'instId': self.market_id(symbol),
         }
         if clientOrderId is not None:
             arg['clOrdId'] = clientOrderId
         else:
             arg['ordId'] = id
-        request = {
+        request: dict = {
             'id': messageHash,
             'op': 'cancel-order',
             'args': [self.extend(arg, params)],
@@ -1300,14 +2028,16 @@ class okx(ccxt.async_support.okx):
 
     async def cancel_orders_ws(self, ids: List[str], symbol: Str = None, params={}):
         """
-        :see: https://www.okx.com/docs-v5/en/#order-book-trading-trade-ws-mass-cancel-order
+
+        https://www.okx.com/docs-v5/en/#order-book-trading-trade-ws-mass-cancel-order
+
         cancel multiple orders
         :param str[] ids: order ids
         :param str symbol: unified market symbol, default is None
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
-        idsLength = len(ids)
+        idsLength: number = len(ids)
         if idsLength > 20:
             raise BadRequest(self.id + ' cancelOrdersWs() accepts up to 20 ids at a time')
         if symbol is None:
@@ -1315,15 +2045,15 @@ class okx(ccxt.async_support.okx):
         await self.load_markets()
         await self.authenticate()
         url = self.get_url('private', 'private')
-        messageHash = str(self.nonce())
+        messageHash = self.request_id()
         args = []
         for i in range(0, idsLength):
-            arg = {
+            arg: dict = {
                 'instId': self.market_id(symbol),
                 'ordId': ids[i],
             }
             args.append(arg)
-        request = {
+        request: dict = {
             'id': messageHash,
             'op': 'batch-cancel-orders',
             'args': args,
@@ -1332,7 +2062,9 @@ class okx(ccxt.async_support.okx):
 
     async def cancel_all_orders_ws(self, symbol: Str = None, params={}):
         """
-        :see: https://docs.okx.com/websockets/#message-cancelAll
+
+        https://docs.okx.com/websockets/#message-cancelAll
+
         cancel all open orders of a type. Only applicable to Option in Portfolio Margin mode, and MMP privilege is required.
         :param str symbol: unified market symbol, only orders in the market of self symbol are cancelled when symbol is not None
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -1346,8 +2078,8 @@ class okx(ccxt.async_support.okx):
         if market['type'] != 'option':
             raise BadRequest(self.id + 'cancelAllOrdersWs is only applicable to Option in Portfolio Margin mode, and MMP privilege is required.')
         url = self.get_url('private', 'private')
-        messageHash = str(self.nonce())
-        request = {
+        messageHash = self.request_id()
+        request: dict = {
             'id': messageHash,
             'op': 'mass-cancel',
             'args': [self.extend({
@@ -1390,9 +2122,9 @@ class okx(ccxt.async_support.okx):
         future = self.safe_value(client.futures, 'authenticated')
         future.resolve(True)
 
-    def ping(self, client):
-        # okex does not support built-in ws protocol-level ping-pong
-        # instead it requires custom text-based ping-pong
+    def ping(self, client: Client):
+        # OKX does not support the built-in WebSocket protocol-level ping-pong.
+        # Instead, it requires a custom text-based ping-pong mechanism.
         return 'ping'
 
     def handle_pong(self, client: Client, message):
@@ -1403,24 +2135,44 @@ class okx(ccxt.async_support.okx):
         #
         #     {event: 'error', msg: "Illegal request: {"op":"subscribe","args":["spot/ticker:BTC-USDT"]}", code: "60012"}
         #     {event: 'error", msg: "channel:ticker,instId:BTC-USDT doesn"t exist", code: "60018"}
+        #     {"event":"error","msg":"Illegal request: {\\"id\\":\\"17321173472466905\\",\\"op\\":\\"amend-order\\",\\"args\\":[{\\"instId\\":\\"ETH-USDC\\",\\"ordId\\":\\"2000345622407479296\\",\\"newSz\\":\\"0.050857\\",\\"newPx\\":\\"2949.4\\",\\"postOnly\\":true}],\\"postOnly\\":true}","code":"60012","connId":"0808af6c"}
         #
-        errorCode = self.safe_integer(message, 'code')
+        errorCode = self.safe_string(message, 'code')
         try:
-            if errorCode:
+            if errorCode and errorCode != '0':
                 feedback = self.id + ' ' + self.json(message)
-                self.throw_exactly_matched_exception(self.exceptions['exact'], errorCode, feedback)
+                if errorCode != '1':
+                    self.throw_exactly_matched_exception(self.exceptions['exact'], errorCode, feedback)
                 messageString = self.safe_value(message, 'msg')
                 if messageString is not None:
                     self.throw_broadly_matched_exception(self.exceptions['broad'], messageString, feedback)
+                else:
+                    data = self.safe_list(message, 'data', [])
+                    for i in range(0, len(data)):
+                        d = data[i]
+                        errorCode = self.safe_string(d, 'sCode')
+                        if errorCode is not None:
+                            self.throw_exactly_matched_exception(self.exceptions['exact'], errorCode, feedback)
+                        messageString = self.safe_value(message, 'sMsg')
+                        if messageString is not None:
+                            self.throw_broadly_matched_exception(self.exceptions['broad'], messageString, feedback)
+                raise ExchangeError(feedback)
         except Exception as e:
-            if isinstance(e, AuthenticationError):
-                messageHash = 'authenticated'
-                client.reject(e, messageHash)
-                if messageHash in client.subscriptions:
-                    del client.subscriptions[messageHash]
+            # if the message contains an id, it means it is a response to a request
+            # so we only reject that promise, instead of deleting all futures, destroying the authentication future
+            id = self.safe_string(message, 'id')
+            if id is None:
+                # try to parse it from the stringified json inside msg
+                msg = self.safe_string(message, 'msg')
+                if msg is not None and msg.startswith('Illegal request: {'):
+                    stringifiedJson = msg.replace('Illegal request: ', '')
+                    parsedJson = self.parse_json(stringifiedJson)
+                    id = self.safe_string(parsedJson, 'id')
+            if id is not None:
+                client.reject(e, id)
                 return False
-            else:
-                client.reject(e)
+            client.reject(e)
+            return False
         return message
 
     def handle_message(self, client: Client, message):
@@ -1472,11 +2224,12 @@ class okx(ccxt.async_support.okx):
         # if table is None:
         event = self.safe_string_2(message, 'event', 'op')
         if event is not None:
-            methods = {
+            methods: dict = {
                 # 'info': self.handleSystemStatus,
                 # 'book': 'handleOrderBook',
                 'login': self.handle_authenticate,
                 'subscribe': self.handle_subscription_status,
+                'unsubscribe': self.handle_unsubscription,
                 'order': self.handle_place_orders,
                 'batch-orders': self.handle_place_orders,
                 'amend-order': self.handle_place_orders,
@@ -1490,22 +2243,26 @@ class okx(ccxt.async_support.okx):
         else:
             arg = self.safe_value(message, 'arg', {})
             channel = self.safe_string(arg, 'channel')
-            methods = {
+            methods: dict = {
                 'bbo-tbt': self.handle_order_book,  # newly added channel that sends tick-by-tick Level 1 data, all API users can subscribe, public depth channel, verification not required
                 'books': self.handle_order_book,  # all API users can subscribe, public depth channel, verification not required
                 'books5': self.handle_order_book,  # all API users can subscribe, public depth channel, verification not required, data feeds will be delivered every 100ms(vs. every 200ms now)
                 'books50-l2-tbt': self.handle_order_book,  # only users who're VIP4 and above can subscribe, identity verification required before subscription
                 'books-l2-tbt': self.handle_order_book,  # only users who're VIP5 and above can subscribe, identity verification required before subscription
                 'tickers': self.handle_ticker,
+                'mark-price': self.handle_ticker,
                 'positions': self.handle_positions,
                 'index-tickers': self.handle_ticker,
                 'sprd-tickers': self.handle_ticker,
                 'block-tickers': self.handle_ticker,
                 'trades': self.handle_trades,
                 'account': self.handle_balance,
+                'funding-rate': self.handle_funding_rate,
                 # 'margin_account': self.handle_balance,
                 'orders': self.handle_orders,
                 'orders-algo': self.handle_orders,
+                'liquidation-orders': self.handle_liquidation,
+                'balance_and_position': self.handle_balance_and_position,
             }
             method = self.safe_value(methods, channel)
             if method is None:
@@ -1513,3 +2270,57 @@ class okx(ccxt.async_support.okx):
                     self.handle_ohlcv(client, message)
             else:
                 method(client, message)
+
+    def handle_un_subscription_trades(self, client: Client, symbol: str):
+        subMessageHash = 'trades:' + symbol
+        messageHash = 'unsubscribe:trades:' + symbol
+        self.clean_unsubscription(client, subMessageHash, messageHash)
+        if symbol in self.trades:
+            del self.trades[symbol]
+
+    def handle_unsubscription_order_book(self, client: Client, symbol: str, channel: str):
+        subMessageHash = channel + ':' + symbol
+        messageHash = 'unsubscribe:orderbook:' + symbol
+        self.clean_unsubscription(client, subMessageHash, messageHash)
+        if symbol in self.orderbooks:
+            del self.orderbooks[symbol]
+
+    def handle_unsubscription_ohlcv(self, client: Client, symbol: str, channel: str):
+        tf = channel.replace('candle', '')
+        timeframe = self.find_timeframe(tf)
+        subMessageHash = 'multi:' + channel + ':' + symbol
+        messageHash = 'unsubscribe:' + subMessageHash
+        self.clean_unsubscription(client, subMessageHash, messageHash)
+        if timeframe in self.ohlcvs[symbol]:
+            del self.ohlcvs[symbol][timeframe]
+
+    def handle_unsubscription_ticker(self, client: Client, symbol: str, channel):
+        subMessageHash = channel + '::' + symbol
+        messageHash = 'unsubscribe:ticker:' + symbol
+        self.clean_unsubscription(client, subMessageHash, messageHash)
+        if symbol in self.tickers:
+            del self.tickers[symbol]
+
+    def handle_unsubscription(self, client: Client, message):
+        #
+        # {
+        #     "event": "unsubscribe",
+        #     "arg": {
+        #       "channel": "tickers",
+        #       "instId": "LTC-USD-200327"
+        #     },
+        #     "connId": "a4d3ae55"
+        # }
+        # arg might be an array or list
+        arg = self.safe_dict(message, 'arg', {})
+        channel = self.safe_string(arg, 'channel', '')
+        marketId = self.safe_string(arg, 'instId')
+        symbol = self.safe_symbol(marketId)
+        if channel == 'trades':
+            self.handle_un_subscription_trades(client, symbol)
+        elif channel.startswith('bbo') or channel.startswith('book'):
+            self.handle_unsubscription_order_book(client, symbol, channel)
+        elif channel.find('tickers') > -1:
+            self.handle_unsubscription_ticker(client, symbol, channel)
+        elif channel.startswith('candle'):
+            self.handle_unsubscription_ohlcv(client, symbol, channel)