ccxt-ir 4.3.46.0.3__py2.py3-none-any.whl → 4.5.1__py2.py3-none-any.whl

ccxt/pro/mexc.py

@@ -6,15 +6,17 @@
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
 import hashlib
-from ccxt.base.types import Balances, Int, Order, OrderBook, Str, Ticker, Trade
+from ccxt.base.types import Any, Balances, Int, Order, OrderBook, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import AuthenticationError
+from ccxt.base.errors import ArgumentsRequired
+from ccxt.base.errors import NotSupported
 
 
 class mexc(ccxt.async_support.mexc):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(mexc, self).describe(), {
             'has': {
                 'ws': True,
@@ -33,19 +35,28 @@ class mexc(ccxt.async_support.mexc):
                 'watchOrderBook': True,
                 'watchOrders': True,
                 'watchTicker': True,
-                'watchTickers': False,
+                'watchTickers': True,
+                'watchBidsAsks': True,
                 'watchTrades': True,
+                'watchTradesForSymbols': False,
+                'unWatchTicker': True,
+                'unWatchTickers': True,
+                'unWatchBidsAsks': True,
+                'unWatchOHLCV': True,
+                'unWatchOrderBook': True,
+                'unWatchTrades': True,
             },
             'urls': {
                 'api': {
                     'ws': {
-                        'spot': 'wss://wbs.mexc.com/ws',
+                        'spot': 'wss://wbs-api.mexc.com/ws',
                         'swap': 'wss://contract.mexc.com/edge',
                     },
                 },
             },
             'options': {
                 'listenKeyRefreshRate': 1200000,
+                'decompressBinary': False,
                 # TODO add reset connection after  #16754 is merged
                 'timeframes': {
                     '1m': 'Min1',
@@ -76,15 +87,21 @@ class mexc(ccxt.async_support.mexc):
     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
+
+        https://mexcdevelop.github.io/apidocs/spot_v3_en/#individual-symbol-book-ticker-streams
+        https://mexcdevelop.github.io/apidocs/contract_v1_en/#public-channels
+        https://mexcdevelop.github.io/apidocs/spot_v3_en/#miniticker
+
         :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 boolean [params.miniTicker]: set to True for using the miniTicker endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
         await self.load_markets()
         market = self.market(symbol)
         messageHash = 'ticker:' + market['symbol']
         if market['spot']:
-            channel = 'spot@public.bookTicker.v3.api@' + market['id']
+            channel = 'spot@public.aggre.bookTicker.v3.api.pb@100ms@' + market['id']
             return await self.watch_spot_public(channel, messageHash, params)
         else:
             channel = 'sub.ticker'
@@ -94,6 +111,38 @@ class mexc(ccxt.async_support.mexc):
             return await self.watch_swap_public(channel, messageHash, requestParams, params)
 
     def handle_ticker(self, client: Client, message):
+        #
+        # swap
+        #
+        #     {
+        #         "symbol": "BTC_USDT",
+        #         "data": {
+        #             "symbol": "BTC_USDT",
+        #             "lastPrice": 76376.2,
+        #             "riseFallRate": -0.0006,
+        #             "fairPrice": 76374.4,
+        #             "indexPrice": 76385.8,
+        #             "volume24": 962062810,
+        #             "amount24": 7344207079.96768,
+        #             "maxBidPrice": 84024.3,
+        #             "minAskPrice": 68747.2,
+        #             "lower24Price": 75620.2,
+        #             "high24Price": 77210,
+        #             "timestamp": 1731137509138,
+        #             "bid1": 76376.2,
+        #             "ask1": 76376.3,
+        #             "holdVol": 95479623,
+        #             "riseFallValue": -46.5,
+        #             "fundingRate": 0.0001,
+        #             "zone": "UTC+8",
+        #             "riseFallRates": [-0.0006, 0.1008, 0.2262, 0.2628, 0.2439, 1.0564],
+        #             "riseFallRatesOfTimezone": [0.0065, -0.0013, -0.0006]
+        #         },
+        #         "channel": "push.ticker",
+        #         "ts": 1731137509138
+        #     }
+        #
+        # spot
         #
         #    {
         #        "c": "spot@public.bookTicker.v3.api@BTCUSDT",
@@ -107,9 +156,32 @@ class mexc(ccxt.async_support.mexc):
         #        "t": 1678643605721
         #    }
         #
-        rawTicker = self.safe_value_2(message, 'd', 'data')
+        # spot miniTicker
+        #
+        #     {
+        #         "d": {
+        #             "s": "BTCUSDT",
+        #             "p": "76522",
+        #             "r": "0.0012",
+        #             "tr": "0.0012",
+        #             "h": "77196.3",
+        #             "l": "75630.77",
+        #             "v": "584664223.92",
+        #             "q": "7666.720258",
+        #             "lastRT": "-1",
+        #             "MT": "0",
+        #             "NV": "--",
+        #             "t": "1731135533126"
+        #         },
+        #         "c": "spot@public.miniTicker.v3.api@BTCUSDT@UTC+8",
+        #         "t": 1731135533126,
+        #         "s": "BTCUSDT"
+        #     }
+        #
+        self.handle_bid_ask(client, message)
+        rawTicker = self.safe_dict_n(message, ['d', 'data', 'publicAggreBookTicker'])
         marketId = self.safe_string_2(message, 's', 'symbol')
-        timestamp = self.safe_integer(message, 't')
+        timestamp = self.safe_integer_2(message, 't', 'sendtime')
         market = self.safe_market(marketId)
         symbol = market['symbol']
         ticker = None
@@ -123,45 +195,303 @@ class mexc(ccxt.async_support.mexc):
         messageHash = 'ticker:' + symbol
         client.resolve(ticker, messageHash)
 
-    def parse_ws_ticker(self, ticker, market=None):
+    async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+
+        https://mexcdevelop.github.io/apidocs/spot_v3_en/#individual-symbol-book-ticker-streams
+        https://mexcdevelop.github.io/apidocs/contract_v1_en/#public-channels
+        https://mexcdevelop.github.io/apidocs/spot_v3_en/#minitickers
+
+        :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 boolean [params.miniTicker]: set to True for using the miniTicker endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None)
+        messageHashes = []
+        firstSymbol = self.safe_string(symbols, 0)
+        market = None
+        if firstSymbol is not None:
+            market = self.market(firstSymbol)
+        type = None
+        type, params = self.handle_market_type_and_params('watchTickers', market, params)
+        isSpot = (type == 'spot')
+        url = self.urls['api']['ws']['spot'] if (isSpot) else self.urls['api']['ws']['swap']
+        request: dict = {}
+        if isSpot:
+            raise NotSupported(self.id + ' watchTickers does not support spot markets')
+            # miniTicker = False
+            # miniTicker, params = self.handle_option_and_params(params, 'watchTickers', 'miniTicker')
+            # topics = []
+            # if not miniTicker:
+            #     if symbols is None:
+            #         raise ArgumentsRequired(self.id + ' watchTickers required symbols argument for the bookTicker channel')
+            #     }
+            #     marketIds = self.market_ids(symbols)
+            #     for i in range(0, len(marketIds)):
+            #         marketId = marketIds[i]
+            #         messageHashes.append('ticker:' + symbols[i])
+            #         channel = 'spot@public.bookTicker.v3.api@' + marketId
+            #         topics.append(channel)
+            #     }
+            # else:
+            #     topics.append('spot@public.miniTickers.v3.api@UTC+8')
+            #     if symbols is None:
+            #         messageHashes.append('spot:ticker')
+            #     else:
+            #         for i in range(0, len(symbols)):
+            #             messageHashes.append('ticker:' + symbols[i])
+            #         }
+            #     }
+            # }
+            # request['method'] = 'SUBSCRIPTION'
+            # request['params'] = topics
+        else:
+            request['method'] = 'sub.tickers'
+            request['params'] = {}
+            messageHashes.append('ticker')
+        ticker = await self.watch_multiple(url, messageHashes, self.extend(request, params), messageHashes)
+        if isSpot and self.newUpdates:
+            result: dict = {}
+            result[ticker['symbol']] = ticker
+            return result
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
+
+    def handle_tickers(self, client: Client, message):
+        #
+        # swap
+        #
+        #     {
+        #       "channel": "push.tickers",
+        #       "data": [
+        #         {
+        #           "symbol": "ETH_USDT",
+        #           "lastPrice": 2324.5,
+        #           "riseFallRate": 0.0356,
+        #           "fairPrice": 2324.32,
+        #           "indexPrice": 2325.44,
+        #           "volume24": 25868309,
+        #           "amount24": 591752573.9792,
+        #           "maxBidPrice": 2557.98,
+        #           "minAskPrice": 2092.89,
+        #           "lower24Price": 2239.39,
+        #           "high24Price": 2332.59,
+        #           "timestamp": 1725872514111
+        #         }
+        #       ],
+        #       "ts": 1725872514111
+        #     }
         #
         # spot
+        #
         #    {
-        #        "A": "4.70432",
-        #        "B": "6.714863",
-        #        "a": "20744.54",
-        #        "b": "20744.17"
+        #        "c": "spot@public.bookTicker.v3.api@BTCUSDT",
+        #        "d": {
+        #            "A": "4.70432",
+        #            "B": "6.714863",
+        #            "a": "20744.54",
+        #            "b": "20744.17"
+        #        },
+        #        "s": "BTCUSDT",
+        #        "t": 1678643605721
         #    }
         #
+        # spot miniTicker
+        #
+        #     {
+        #         "d": {
+        #             "s": "BTCUSDT",
+        #             "p": "76522",
+        #             "r": "0.0012",
+        #             "tr": "0.0012",
+        #             "h": "77196.3",
+        #             "l": "75630.77",
+        #             "v": "584664223.92",
+        #             "q": "7666.720258",
+        #             "lastRT": "-1",
+        #             "MT": "0",
+        #             "NV": "--",
+        #             "t": "1731135533126"
+        #         },
+        #         "c": "spot@public.miniTicker.v3.api@BTCUSDT@UTC+8",
+        #         "t": 1731135533126,
+        #         "s": "BTCUSDT"
+        #     }
+        #
+        data = self.safe_list_2(message, 'data', 'd')
+        channel = self.safe_string(message, 'c', '')
+        marketId = self.safe_string(message, 's')
+        market = self.safe_market(marketId)
+        channelStartsWithSpot = channel.startswith('spot')
+        marketIdIsUndefined = marketId is None
+        isSpot = channelStartsWithSpot if marketIdIsUndefined else market['spot']
+        spotPrefix = 'spot:'
+        messageHashPrefix = spotPrefix if isSpot else ''
+        topic = messageHashPrefix + 'ticker'
+        result = []
+        for i in range(0, len(data)):
+            entry = data[i]
+            ticker = None
+            if isSpot:
+                ticker = self.parse_ws_ticker(entry, market)
+            else:
+                ticker = self.parse_ticker(entry)
+            symbol = ticker['symbol']
+            self.tickers[symbol] = ticker
+            result.append(ticker)
+            messageHash = 'ticker:' + symbol
+            client.resolve(ticker, messageHash)
+        client.resolve(result, topic)
+
+    def parse_ws_ticker(self, ticker, market=None):
+        # protobuf ticker
+        # "bidprice": "93387.28",  # Best bid price
+        # "bidquantity": "3.73485",  # Best bid quantity
+        # "askprice": "93387.29",  # Best ask price
+        # "askquantity": "7.669875"  # Best ask quantity
+        #
+        # spot
+        #
+        #     {
+        #         "A": "4.70432",
+        #         "B": "6.714863",
+        #         "a": "20744.54",
+        #         "b": "20744.17"
+        #     }
+        #
+        # spot miniTicker
+        #
+        #     {
+        #         "s": "BTCUSDT",
+        #         "p": "76521",
+        #         "r": "0.0012",
+        #         "tr": "0.0012",
+        #         "h": "77196.3",
+        #         "l": "75630.77",
+        #         "v": "584664223.92",
+        #         "q": "7666.720258",
+        #         "lastRT": "-1",
+        #         "MT": "0",
+        #         "NV": "--",
+        #         "t": "1731135533126"
+        #     }
+        #
+        marketId = self.safe_string(ticker, 's')
+        timestamp = self.safe_integer(ticker, 't')
+        price = self.safe_string(ticker, 'p')
         return self.safe_ticker({
-            'symbol': self.safe_symbol(None, market),
-            'timestamp': None,
-            'datetime': None,
+            'info': ticker,
+            'symbol': self.safe_symbol(marketId, market),
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
             'open': None,
-            'high': None,
-            'low': None,
-            'close': None,
-            'bid': self.safe_number(ticker, 'b'),
-            'bidVolume': self.safe_number(ticker, 'B'),
-            'ask': self.safe_number(ticker, 'a'),
-            'askVolume': self.safe_number(ticker, 'A'),
+            'high': self.safe_number(ticker, 'h'),
+            'low': self.safe_number(ticker, 'l'),
+            'close': price,
+            'last': price,
+            'bid': self.safe_number_2(ticker, 'b', 'bidPrice'),
+            'bidVolume': self.safe_number_2(ticker, 'B', 'bidQuantity'),
+            'ask': self.safe_number_2(ticker, 'a', 'askPrice'),
+            'askVolume': self.safe_number_2(ticker, 'A', 'askQuantity'),
             'vwap': None,
             'previousClose': None,
             'change': None,
-            'percentage': None,
+            'percentage': self.safe_number(ticker, 'tr'),
             'average': None,
-            'baseVolume': None,
-            'quoteVolume': None,
+            'baseVolume': self.safe_number(ticker, 'v'),
+            'quoteVolume': self.safe_number(ticker, 'q'),
+        }, market)
+
+    async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+
+        https://mexcdevelop.github.io/apidocs/spot_v3_en/#individual-symbol-book-ticker-streams
+
+        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, True, False, True)
+        marketType = None
+        if symbols is None:
+            raise ArgumentsRequired(self.id + ' watchBidsAsks required symbols argument')
+        markets = self.markets_for_symbols(symbols)
+        marketType, params = self.handle_market_type_and_params('watchBidsAsks', markets[0], params)
+        isSpot = marketType == 'spot'
+        if not isSpot:
+            raise NotSupported(self.id + ' watchBidsAsks only support spot market')
+        messageHashes = []
+        topics = []
+        for i in range(0, len(symbols)):
+            if isSpot:
+                market = self.market(symbols[i])
+                topics.append('spot@public.aggre.bookTicker.v3.api.pb@100ms@' + market['id'])
+            messageHashes.append('bidask:' + symbols[i])
+        url = self.urls['api']['ws']['spot']
+        request: dict = {
+            'method': 'SUBSCRIPTION',
+            'params': topics,
+        }
+        ticker = await self.watch_multiple(url, messageHashes, self.extend(request, params), messageHashes)
+        if self.newUpdates:
+            tickers: dict = {}
+            tickers[ticker['symbol']] = ticker
+            return tickers
+        return self.filter_by_array(self.bidsasks, 'symbol', symbols)
+
+    def handle_bid_ask(self, client: Client, message):
+        #
+        #    {
+        #        "c": "spot@public.bookTicker.v3.api@BTCUSDT",
+        #        "d": {
+        #            "A": "4.70432",
+        #            "B": "6.714863",
+        #            "a": "20744.54",
+        #            "b": "20744.17"
+        #        },
+        #        "s": "BTCUSDT",
+        #        "t": 1678643605721
+        #    }
+        #
+        parsedTicker = self.parse_ws_bid_ask(message)
+        symbol = self.safe_string(parsedTicker, 'symbol')
+        if symbol is None:
+            return
+        self.bidsasks[symbol] = parsedTicker
+        messageHash = 'bidask:' + symbol
+        client.resolve(parsedTicker, messageHash)
+
+    def parse_ws_bid_ask(self, ticker, market=None):
+        data = self.safe_dict(ticker, 'd')
+        marketId = self.safe_string(ticker, 's')
+        market = self.safe_market(marketId, market)
+        symbol = self.safe_string(market, 'symbol')
+        timestamp = self.safe_integer(ticker, 't')
+        return self.safe_ticker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'ask': self.safe_number(data, 'a'),
+            'askVolume': self.safe_number(data, 'A'),
+            'bid': self.safe_number(data, 'b'),
+            'bidVolume': self.safe_number(data, 'B'),
             'info': ticker,
         }, market)
 
     async def watch_spot_public(self, channel, messageHash, params={}):
+        unsubscribed = self.safe_bool(params, 'unsubscribed', False)
+        params = self.omit(params, ['unsubscribed'])
         url = self.urls['api']['ws']['spot']
+        method = 'UNSUBSCRIPTION' if (unsubscribed) else 'SUBSCRIPTION'
         request: dict = {
-            'method': 'SUBSCRIPTION',
+            'method': method,
             'params': [channel],
         }
-        return await self.watch(url, messageHash, self.extend(request, params), channel)
+        return await self.watch(url, messageHash, self.extend(request, params), messageHash)
 
     async def watch_spot_private(self, channel, messageHash, params={}):
         self.check_required_credentials()
@@ -202,7 +532,9 @@ class mexc(ccxt.async_support.mexc):
 
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
-        :see: https://mxcdevelop.github.io/apidocs/spot_v3_en/#kline-streams
+
+        https://www.mexc.com/api-docs/spot-v3/websocket-market-streams#trade-streams
+
         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
@@ -219,7 +551,7 @@ class mexc(ccxt.async_support.mexc):
         messageHash = 'candles:' + symbol + ':' + timeframe
         ohlcv = None
         if market['spot']:
-            channel = 'spot@public.kline.v3.api@' + market['id'] + '@' + timeframeId
+            channel = 'spot@public.kline.v3.api.pb@' + market['id'] + '@' + timeframeId
             ohlcv = await self.watch_spot_public(channel, messageHash, params)
         else:
             channel = 'sub.kline'
@@ -278,17 +610,45 @@ class mexc(ccxt.async_support.mexc):
         #       "symbol": "BTC_USDT",
         #       "ts": 1651230713067
         #   }
+        # protobuf
+        #  {
+        #    "channel":"spot@public.kline.v3.api.pb@BTCUSDT@Min1",
+        #    "symbol":"BTCUSDT",
+        #    "symbolId":"2fb942154ef44a4ab2ef98c8afb6a4a7",
+        #    "createTime":"1754737941062",
+        #    "publicSpotKline":{
+        #       "interval":"Min1",
+        #       "windowStart":"1754737920",
+        #       "openingPrice":"117317.31",
+        #       "closingPrice":"117325.26",
+        #       "highestPrice":"117341",
+        #       "lowestPrice":"117317.3",
+        #       "volume":"3.12599854",
+        #       "amount":"366804.43",
+        #       "windowEnd":"1754737980"
+        #    }
+        # }
         #
-        d = self.safe_value_2(message, 'd', 'data', {})
-        rawOhlcv = self.safe_value(d, 'k', d)
-        timeframeId = self.safe_string_2(rawOhlcv, 'i', 'interval')
-        timeframes = self.safe_value(self.options, 'timeframes', {})
-        timeframe = self.find_timeframe(timeframeId, timeframes)
-        marketId = self.safe_string_2(message, 's', 'symbol')
-        market = self.safe_market(marketId)
-        symbol = market['symbol']
+        parsed: dict = None
+        symbol: Str = None
+        timeframe: Str = None
+        if 'publicSpotKline' in message:
+            symbol = self.symbol(self.safe_string(message, 'symbol'))
+            data = self.safe_dict(message, 'publicSpotKline', {})
+            timeframeId = self.safe_string(data, 'interval')
+            timeframe = self.find_timeframe(timeframeId, self.options['timeframes'])
+            parsed = self.parse_ws_ohlcv(data, self.safe_market(symbol))
+        else:
+            d = self.safe_value_2(message, 'd', 'data', {})
+            rawOhlcv = self.safe_value(d, 'k', d)
+            timeframeId = self.safe_string_2(rawOhlcv, 'i', 'interval')
+            timeframes = self.safe_value(self.options, 'timeframes', {})
+            timeframe = self.find_timeframe(timeframeId, timeframes)
+            marketId = self.safe_string_2(message, 's', 'symbol')
+            market = self.safe_market(marketId)
+            symbol = market['symbol']
+            parsed = self.parse_ws_ohlcv(rawOhlcv, market)
         messageHash = 'candles:' + symbol + ':' + timeframe
-        parsed = self.parse_ws_ohlcv(rawOhlcv, market)
         self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {})
         stored = self.safe_value(self.ohlcvs[symbol], timeframe)
         if stored is None:
@@ -330,23 +690,38 @@ class mexc(ccxt.async_support.mexc):
         #       "rh": 27301.8,
         #       "rl": 27301.8
         #     }
+        # protobuf
+        #
+        #       "interval":"Min1",
+        #       "windowStart":"1754737920",
+        #       "openingPrice":"117317.31",
+        #       "closingPrice":"117325.26",
+        #       "highestPrice":"117341",
+        #       "lowestPrice":"117317.3",
+        #       "volume":"3.12599854",
+        #       "amount":"366804.43",
+        #       "windowEnd":"1754737980"
         #
         return [
-            self.safe_timestamp(ohlcv, 't'),
-            self.safe_number(ohlcv, 'o'),
-            self.safe_number(ohlcv, 'h'),
-            self.safe_number(ohlcv, 'l'),
-            self.safe_number(ohlcv, 'c'),
-            self.safe_number_2(ohlcv, 'v', 'q'),
+            self.safe_timestamp_2(ohlcv, 't', 'windowStart'),
+            self.safe_number_2(ohlcv, 'o', 'openingPrice'),
+            self.safe_number_2(ohlcv, 'h', 'highestPrice'),
+            self.safe_number_2(ohlcv, 'l', 'lowestPrice'),
+            self.safe_number_2(ohlcv, 'c', 'closingPrice'),
+            self.safe_number_2(ohlcv, 'v', 'volume'),
         ]
 
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
-        :see: https://mxcdevelop.github.io/apidocs/spot_v3_en/#diff-depth-stream
+
+        https://www.mexc.com/api-docs/spot-v3/websocket-market-streams#trade-streams
+        https://mexcdevelop.github.io/apidocs/contract_v1_en/#public-channels
+
         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.frequency]: the frequency of the order book updates, default is '10ms', can be '100ms' or '10ms
         :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
         """
         await self.load_markets()
@@ -355,7 +730,9 @@ class mexc(ccxt.async_support.mexc):
         messageHash = 'orderbook:' + symbol
         orderbook = None
         if market['spot']:
-            channel = 'spot@public.increase.depth.v3.api@' + market['id']
+            frequency = None
+            frequency, params = self.handle_option_and_params(params, 'watchOrderBook', 'frequency', '100ms')
+            channel = 'spot@public.aggre.depth.v3.api.pb@' + frequency + '@' + market['id']
             orderbook = await self.watch_spot_public(channel, messageHash, params)
         else:
             channel = 'sub.depth'
@@ -379,12 +756,12 @@ class mexc(ccxt.async_support.mexc):
         # return the first index of the cache that can be applied to the orderbook or -1 if not possible
         nonce = self.safe_integer(orderbook, 'nonce')
         firstDelta = self.safe_value(cache, 0)
-        firstDeltaNonce = self.safe_integer_2(firstDelta, 'r', 'version')
+        firstDeltaNonce = self.safe_integer_n(firstDelta, ['r', 'version', 'fromVersion'])
         if nonce < firstDeltaNonce - 1:
             return -1
         for i in range(0, len(cache)):
             delta = cache[i]
-            deltaNonce = self.safe_integer_2(delta, 'r', 'version')
+            deltaNonce = self.safe_integer_n(delta, ['r', 'version', 'fromVersion'])
             if deltaNonce >= nonce:
                 return i
         return len(cache)
@@ -432,18 +809,38 @@ class mexc(ccxt.async_support.mexc):
         #      "symbol":"BTC_USDT",
         #      "ts":1651239652372
         #  }
+        # protofbuf
+        # {
+        #      "channel":"spot@public.aggre.depth.v3.api.pb@100ms@BTCUSDT",
+        #      "symbol":"BTCUSDT",
+        #      "sendTime":"1754741322152",
+        #      "publicAggreDepths":{
+        #          "asks":[
+        #              {
+        #                  "price":"117145.49",
+        #                  "quantity":"0"
+        #              }
+        #          ],
+        #          "bids":[
+        #              {
+        #                  "price":"117053.41",
+        #                  "quantity":"1.86837271"
+        #              }
+        #          ],
+        #          "eventType":"spot@public.aggre.depth.v3.api.pb@100ms",
+        #          "fromVersion":"43296363236",
+        #          "toVersion":"43296363255"
+        #      }
+        # }
         #
-        data = self.safe_value_2(message, 'd', 'data')
+        data = self.safe_dict_n(message, ['d', 'data', 'publicAggreDepths'])
         marketId = self.safe_string_2(message, 's', 'symbol')
         symbol = self.safe_symbol(marketId)
         messageHash = 'orderbook:' + symbol
         subscription = self.safe_value(client.subscriptions, messageHash)
         limit = self.safe_integer(subscription, 'limit')
-        if subscription is True:
-            # we set client.subscriptions[messageHash] to 1
-            # once we have received the first delta and initialized the orderbook
-            client.subscriptions[messageHash] = 1
-            self.orderbooks[symbol] = self.counted_order_book({})
+        if not (symbol in self.orderbooks):
+            self.orderbooks[symbol] = self.order_book()
         storedOrderBook = self.orderbooks[symbol]
         nonce = self.safe_integer(storedOrderBook, 'nonce')
         if nonce is None:
@@ -455,7 +852,7 @@ class mexc(ccxt.async_support.mexc):
             return
         try:
             self.handle_delta(storedOrderBook, data)
-            timestamp = self.safe_integer_2(message, 't', 'ts')
+            timestamp = self.safe_integer_n(message, ['t', 'ts', 'sendTime'])
             storedOrderBook['timestamp'] = timestamp
             storedOrderBook['datetime'] = self.iso8601(timestamp)
         except Exception as e:
@@ -475,13 +872,13 @@ class mexc(ccxt.async_support.mexc):
             if isinstance(bidask, list):
                 bookside.storeArray(bidask)
             else:
-                price = self.safe_float(bidask, 'p')
-                amount = self.safe_float(bidask, 'v')
+                price = self.safe_float_2(bidask, 'p', 'price')
+                amount = self.safe_float_2(bidask, 'v', 'quantity')
                 bookside.store(price, amount)
 
     def handle_delta(self, orderbook, delta):
         existingNonce = self.safe_integer(orderbook, 'nonce')
-        deltaNonce = self.safe_integer_2(delta, 'r', 'version')
+        deltaNonce = self.safe_integer_n(delta, ['r', 'version', 'fromVersion'])
         if deltaNonce < existingNonce:
             # even when doing < comparison, self happens: https://app.travis-ci.com/github/ccxt/ccxt/builds/269234741#L1809
             # so, we just skip old updates
@@ -496,7 +893,10 @@ class mexc(ccxt.async_support.mexc):
 
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
-        :see: https://mxcdevelop.github.io/apidocs/spot_v3_en/#trade-streams
+
+        https://www.mexc.com/api-docs/spot-v3/websocket-market-streams#trade-streams
+        https://mexcdevelop.github.io/apidocs/contract_v1_en/#public-channels
+
         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
@@ -510,7 +910,7 @@ class mexc(ccxt.async_support.mexc):
         messageHash = 'trades:' + symbol
         trades = None
         if market['spot']:
-            channel = 'spot@public.deals.v3.api@' + market['id']
+            channel = 'spot@public.aggre.deals.v3.api.pb@100ms@' + market['id']
             trades = await self.watch_spot_public(channel, messageHash, params)
         else:
             channel = 'sub.deal'
@@ -523,6 +923,23 @@ class mexc(ccxt.async_support.mexc):
         return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trades(self, client: Client, message):
+        # protobuf
+        # {
+        # "channel": "spot@public.aggre.deals.v3.api.pb@100ms@BTCUSDT",
+        # "publicdeals": {
+        #     "dealsList": [
+        #     {
+        #         "price": "93220.00",  # Trade price
+        #         "quantity": "0.04438243",  # Trade quantity
+        #         "tradetype": 2,  # Trade type(1: Buy, 2: Sell)
+        #         "time": 1736409765051  # Trade time
+        #     }
+        #     ],
+        #     "eventtype": "spot@public.aggre.deals.v3.api.pb@100ms"  # Event type
+        # },
+        # "symbol": "BTCUSDT",  # Trading pair
+        # "sendtime": 1736409765052  # Event time
+        # }
         #
         #    {
         #        "c": "spot@public.deals.v3.api@BTCUSDT",
@@ -563,8 +980,8 @@ class mexc(ccxt.async_support.mexc):
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
             stored = ArrayCache(limit)
             self.trades[symbol] = stored
-        d = self.safe_value_2(message, 'd', 'data')
-        trades = self.safe_value(d, 'deals', [d])
+        d = self.safe_dict_n(message, ['d', 'data', 'publicAggreDeals'])
+        trades = self.safe_list_2(d, 'deals', 'dealsList', [d])
         for j in range(0, len(trades)):
             parsedTrade = None
             if market['spot']:
@@ -576,13 +993,16 @@ class mexc(ccxt.async_support.mexc):
 
     async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
-        :see: https://mxcdevelop.github.io/apidocs/spot_v3_en/#spot-account-deals
+
+        https://www.mexc.com/api-docs/spot-v3/websocket-user-data-streams#spot-account-deals
+        https://mexcdevelop.github.io/apidocs/contract_v1_en/#private-channels
+
         watches information on multiple trades made by the user
         :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
-        :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>`
         """
         await self.load_markets()
         messageHash = 'myTrades'
@@ -595,7 +1015,7 @@ class mexc(ccxt.async_support.mexc):
         type, params = self.handle_market_type_and_params('watchMyTrades', market, params)
         trades = None
         if type == 'spot':
-            channel = 'spot@private.deals.v3.api'
+            channel = 'spot@private.deals.v3.api.pb'
             trades = await self.watch_spot_private(channel, messageHash, params)
         else:
             trades = await self.watch_swap_private(messageHash, params)
@@ -621,11 +1041,27 @@ class mexc(ccxt.async_support.mexc):
         #        "s": "BTCUSDT",
         #        "t": 1678670940700
         #    }
+        #    {
+        #      channel: "spot@private.deals.v3.api.pb",
+        #      symbol: "MXUSDT",
+        #      sendTime: 1736417034332,
+        #      privateDeals {
+        #        price: "3.6962",
+        #        quantity: "1",
+        #        amount: "3.6962",
+        #        tradeType: 2,
+        #        tradeId: "505979017439002624X1",
+        #        orderId: "C02__505979017439002624115",
+        #        feeAmount: "0.0003998377369698171",
+        #        feeCurrency: "MX",
+        #        time: 1736417034280
+        #      }
+        # }
         #
         messageHash = 'myTrades'
-        data = self.safe_value_2(message, 'd', 'data')
+        data = self.safe_dict_n(message, ['d', 'data', 'privateDeals'])
         futuresMarketId = self.safe_string(data, 'symbol')
-        marketId = self.safe_string(message, 's', futuresMarketId)
+        marketId = self.safe_string_2(message, 's', 'symbol', futuresMarketId)
         market = self.safe_market(marketId)
         symbol = market['symbol']
         trade = None
@@ -645,7 +1081,7 @@ class mexc(ccxt.async_support.mexc):
 
     def parse_ws_trade(self, trade, market=None):
         #
-        # public trade
+        # public trade(protobuf)
         #    {
         #        "p": "20382.70",
         #        "v": "0.043800",
@@ -665,7 +1101,6 @@ class mexc(ccxt.async_support.mexc):
         #        "v": "5"
         #    }
         #
-        #
         #   d: {
         #       p: '1.0005',
         #       v: '5.71',
@@ -680,22 +1115,36 @@ class mexc(ccxt.async_support.mexc):
         #       n: '0.005712855',
         #       N: 'USDT'
         #   }
-        timestamp = self.safe_integer(trade, 'T')
-        tradeId = self.safe_string(trade, 't')
+        # protobuf
+        #
+        #     {
+        #        price: "3.6962",
+        #        quantity: "1",
+        #        amount: "3.6962",
+        #        tradeType: 2,
+        #        tradeId: "505979017439002624X1",
+        #        orderId: "C02__505979017439002624115",
+        #        feeAmount: "0.0003998377369698171",
+        #        feeCurrency: "MX",
+        #        time: 1736417034280
+        #      }
+        #
+        timestamp = self.safe_integer_2(trade, 'T', 'time')
+        tradeId = self.safe_string_2(trade, 't', 'tradeId')
         if timestamp is None:
             timestamp = self.safe_integer(trade, 't')
             tradeId = None
-        priceString = self.safe_string(trade, 'p')
-        amountString = self.safe_string(trade, 'v')
-        rawSide = self.safe_string(trade, 'S')
+        priceString = self.safe_string_2(trade, 'p', 'price')
+        amountString = self.safe_string_2(trade, 'v', 'quantity')
+        rawSide = self.safe_string_2(trade, 'S', 'tradeType')
         side = 'buy' if (rawSide == '1') else 'sell'
         isMaker = self.safe_integer(trade, 'm')
-        feeAmount = self.safe_number(trade, 'n')
-        feeCurrencyId = self.safe_string(trade, 'N')
+        feeAmount = self.safe_string_2(trade, 'n', 'feeAmount')
+        feeCurrencyId = self.safe_string_2(trade, 'N', 'feeCurrency')
         return self.safe_trade({
             'info': trade,
             'id': tradeId,
-            'order': self.safe_string(trade, 'i'),
+            'order': self.safe_string_2(trade, 'i', 'orderId'),
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'symbol': self.safe_symbol(None, market),
@@ -704,7 +1153,7 @@ class mexc(ccxt.async_support.mexc):
             'takerOrMaker': 'maker' if (isMaker) else 'taker',
             'price': priceString,
             'amount': amountString,
-            'cost': None,
+            'cost': self.safe_string(trade, 'amount'),
             'fee': {
                 'cost': feeAmount,
                 'currency': self.safe_currency_code(feeCurrencyId),
@@ -713,8 +1162,10 @@ class mexc(ccxt.async_support.mexc):
 
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
-        :see: https://mxcdevelop.github.io/apidocs/spot_v3_en/#spot-account-orders
-        :see: https://mxcdevelop.github.io/apidocs/spot_v3_en/#margin-account-orders
+
+        https://www.mexc.com/api-docs/spot-v3/websocket-user-data-streams#spot-account-orders
+        https://mexcdevelop.github.io/apidocs/spot_v3_en/#margin-account-orders
+
         watches information on multiple orders made by the user
         :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
@@ -724,7 +1175,6 @@ class mexc(ccxt.async_support.mexc):
         :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
-        params = self.omit(params, 'type')
         messageHash = 'orders'
         market = None
         if symbol is not None:
@@ -735,7 +1185,7 @@ class mexc(ccxt.async_support.mexc):
         type, params = self.handle_market_type_and_params('watchOrders', market, params)
         orders = None
         if type == 'spot':
-            channel = type + '@private.orders.v3.api'
+            channel = 'spot@private.orders.v3.api.pb'
             orders = await self.watch_spot_private(channel, messageHash, params)
         else:
             orders = await self.watch_swap_private(messageHash, params)
@@ -808,11 +1258,18 @@ class mexc(ccxt.async_support.mexc):
         #        "s": "MXUSDT",
         #        "t":1661938138193
         #    }
+        # protobuf
+        #   {
+        #      channel: "spot@private.orders.v3.api.pb",
+        #      symbol: "MXUSDT",
+        #      sendTime: 1736417034281,
+        #      privateOrders {}
+        #   }
         #
         messageHash = 'orders'
-        data = self.safe_value_2(message, 'd', 'data')
+        data = self.safe_dict_n(message, ['d', 'data', 'privateOrders'])
         futuresMarketId = self.safe_string(data, 'symbol')
-        marketId = self.safe_string(message, 's', futuresMarketId)
+        marketId = self.safe_string_2(message, 's', 'symbol', futuresMarketId)
         market = self.safe_market(marketId)
         symbol = market['symbol']
         parsed = None
@@ -880,11 +1337,28 @@ class mexc(ccxt.async_support.mexc):
         #        "s":1,
         #        "i":"e03a5c7441e44ed899466a7140b71391",
         #    }
+        # protofbuf spot order
+        # {
+        #     "id":"C02__583905164440776704043",
+        #     "price":"0.001053",
+        #     "quantity":"2000",
+        #     "amount":"0",
+        #     "avgPrice":"0.001007",
+        #     "orderType":5,
+        #     "tradeType":1,
+        #     "remainAmount":"0.092",
+        #     "remainQuantity":"0",
+        #     "lastDealQuantity":"2000",
+        #     "cumulativeQuantity":"2000",
+        #     "cumulativeAmount":"2.014",
+        #     "status":2,
+        #     "createTime":"1754996075502"
+        # }
         #
-        timestamp = self.safe_integer(order, 'O')
-        side = self.safe_string(order, 'S')
-        status = self.safe_string(order, 's')
-        type = self.safe_string(order, 'o')
+        timestamp = self.safe_integer(order, 'createTime')
+        side = self.safe_string(order, 'tradeType')
+        status = self.safe_string(order, 'status')
+        type = self.safe_string(order, 'orderType')
         fee = None
         feeCurrency = self.safe_string(order, 'N')
         if feeCurrency is not None:
@@ -893,8 +1367,8 @@ class mexc(ccxt.async_support.mexc):
                 'cost': None,
             }
         return self.safe_order({
-            'id': self.safe_string(order, 'i'),
-            'clientOrderId': self.safe_string(order, 'c'),
+            'id': self.safe_string(order, 'id'),
+            'clientOrderId': self.safe_string(order, 'clientId'),
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'lastTradeTimestamp': None,
@@ -903,14 +1377,14 @@ class mexc(ccxt.async_support.mexc):
             'type': self.parse_ws_order_type(type),
             'timeInForce': self.parse_ws_time_in_force(type),
             'side': 'buy' if (side == '1') else 'sell',
-            'price': self.safe_string(order, 'p'),
+            'price': self.safe_string(order, 'price'),
             'stopPrice': None,
-            'triggerPrice': self.safe_number(order, 'P'),
-            'average': self.safe_string(order, 'ap'),
-            'amount': self.safe_string(order, 'v'),
-            'cost': self.safe_string(order, 'a'),
-            'filled': self.safe_string(order, 'cv'),
-            'remaining': self.safe_string(order, 'V'),
+            'triggerPrice': None,
+            'average': self.safe_string(order, 'avgPrice'),
+            'amount': self.safe_string(order, 'quantity'),
+            'cost': self.safe_string(order, 'amount'),
+            'filled': self.safe_string(order, 'cumulativeQuantity'),
+            'remaining': self.safe_string(order, 'remainQuantity'),
             'fee': fee,
             'trades': None,
             'info': order,
@@ -922,8 +1396,7 @@ class mexc(ccxt.async_support.mexc):
             '2': 'closed',   # filled
             '3': 'open',     # partially filled
             '4': 'canceled',  # canceled
-            '5': 'open',     # order partially filled
-            '6': 'closed',   # partially filled then canceled
+            '5': 'closed',   # partially filled then canceled
             'NEW': 'open',
             'CANCELED': 'canceled',
             'EXECUTED': 'closed',
@@ -934,7 +1407,7 @@ class mexc(ccxt.async_support.mexc):
     def parse_ws_order_type(self, type):
         types: dict = {
             '1': 'limit',   # LIMIT_ORDER
-            '2': None,  # POST_ONLY
+            '2': 'limit',  # POST_ONLY
             '3': None,  # IMMEDIATE_OR_CANCEL
             '4': None,  # FILL_OR_KILL
             '5': 'market',  # MARKET_ORDER
@@ -955,7 +1428,9 @@ class mexc(ccxt.async_support.mexc):
 
     async def watch_balance(self, params={}) -> Balances:
         """
-        :see: https://mxcdevelop.github.io/apidocs/spot_v3_en/#spot-account-upadte
+
+        https://www.mexc.com/api-docs/spot-v3/websocket-user-data-streams#spot-account-update
+
         watch balance and get the amount of funds available for trading or funds locked in orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
@@ -965,7 +1440,7 @@ class mexc(ccxt.async_support.mexc):
         type, params = self.handle_market_type_and_params('watchBalance', None, params)
         messageHash = 'balance:' + type
         if type == 'spot':
-            channel = 'spot@private.account.v3.api'
+            channel = 'spot@private.account.v3.api.pb'
             return await self.watch_spot_private(channel, messageHash, params)
         else:
             return await self.watch_swap_private(messageHash, params)
@@ -1002,26 +1477,271 @@ class mexc(ccxt.async_support.mexc):
         #         "ts": 1680059188190
         #     }
         #
-        c = self.safe_string(message, 'c')
+        c = self.safe_string_2(message, 'c', 'channel')
         type = 'swap' if (c is None) else 'spot'
         messageHash = 'balance:' + type
-        data = self.safe_value_2(message, 'd', 'data')
+        data = self.safe_dict_n(message, ['d', 'data', 'privateAccount'])
         futuresTimestamp = self.safe_integer(message, 'ts')
-        timestamp = self.safe_integer(data, 'c', futuresTimestamp)
+        timestamp = self.safe_integer_2(data, 'c', 'time', futuresTimestamp)
         if not (type in self.balance):
             self.balance[type] = {}
         self.balance[type]['info'] = data
         self.balance[type]['timestamp'] = timestamp
         self.balance[type]['datetime'] = self.iso8601(timestamp)
-        currencyId = self.safe_string_2(data, 'a', 'currency')
+        currencyId = self.safe_string_n(data, ['a', 'currency', 'vcoinName'])
         code = self.safe_currency_code(currencyId)
         account = self.account()
-        account['free'] = self.safe_string_2(data, 'f', 'availableBalance')
-        account['used'] = self.safe_string_2(data, 'l', 'frozenBalance')
+        account['total'] = self.safe_string_n(data, ['f', 'availableBalance', 'balanceAmount'])
+        account['used'] = self.safe_string_n(data, ['l', 'frozenBalance', 'frozenAmount'])
         self.balance[type][code] = account
         self.balance[type] = self.safe_balance(self.balance[type])
         client.resolve(self.balance[type], messageHash)
 
+    async def un_watch_ticker(self, symbol: str, params={}) -> Any:
+        """
+        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 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>`
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        messageHash = 'unsubscribe:ticker:' + market['symbol']
+        url = None
+        channel = None
+        if market['spot']:
+            channel = 'spot@public.aggre.bookTicker.v3.api.pb@100ms@' + market['id']
+            url = self.urls['api']['ws']['spot']
+            params['unsubscribed'] = True
+            self.watch_spot_public(channel, messageHash, params)
+        else:
+            channel = 'unsub.ticker'
+            requestParams: dict = {
+                'symbol': market['id'],
+            }
+            url = self.urls['api']['ws']['swap']
+            self.watch_swap_public(channel, messageHash, requestParams, params)
+        client = self.client(url)
+        self.handle_unsubscriptions(client, [messageHash])
+        return None
+
+    async def un_watch_tickers(self, symbols: Strings = None, params={}) -> Any:
+        """
+        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
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None)
+        messageHashes = []
+        firstSymbol = self.safe_string(symbols, 0)
+        market = None
+        if firstSymbol is not None:
+            market = self.market(firstSymbol)
+        type = None
+        type, params = self.handle_market_type_and_params('watchTickers', market, params)
+        isSpot = (type == 'spot')
+        url = self.urls['api']['ws']['spot'] if (isSpot) else self.urls['api']['ws']['swap']
+        request: dict = {}
+        if isSpot:
+            raise NotSupported(self.id + ' watchTickers does not support spot markets')
+            # miniTicker = False
+            # miniTicker, params = self.handle_option_and_params(params, 'watchTickers', 'miniTicker')
+            # topics = []
+            # if not miniTicker:
+            #     if symbols is None:
+            #         raise ArgumentsRequired(self.id + ' watchTickers required symbols argument for the bookTicker channel')
+            #     }
+            #     marketIds = self.market_ids(symbols)
+            #     for i in range(0, len(marketIds)):
+            #         marketId = marketIds[i]
+            #         messageHashes.append('unsubscribe:ticker:' + symbols[i])
+            #         channel = 'spot@public.bookTicker.v3.api@' + marketId
+            #         topics.append(channel)
+            #     }
+            # else:
+            #     topics.append('spot@public.miniTickers.v3.api@UTC+8')
+            #     if symbols is None:
+            #         messageHashes.append('unsubscribe:spot:ticker')
+            #     else:
+            #         for i in range(0, len(symbols)):
+            #             messageHashes.append('unsubscribe:ticker:' + symbols[i])
+            #         }
+            #     }
+            # }
+            # request['method'] = 'UNSUBSCRIPTION'
+            # request['params'] = topics
+        else:
+            request['method'] = 'unsub.tickers'
+            request['params'] = {}
+            messageHashes.append('unsubscribe:ticker')
+        client = self.client(url)
+        self.watch_multiple(url, messageHashes, self.extend(request, params), messageHashes)
+        self.handle_unsubscriptions(client, messageHashes)
+        return None
+
+    async def un_watch_bids_asks(self, symbols: Strings = None, params={}) -> Any:
+        """
+        unWatches 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, True, False, True)
+        marketType = None
+        if symbols is None:
+            raise ArgumentsRequired(self.id + ' watchBidsAsks required symbols argument')
+        markets = self.markets_for_symbols(symbols)
+        marketType, params = self.handle_market_type_and_params('watchBidsAsks', markets[0], params)
+        isSpot = marketType == 'spot'
+        if not isSpot:
+            raise NotSupported(self.id + ' watchBidsAsks only support spot market')
+        messageHashes = []
+        topics = []
+        for i in range(0, len(symbols)):
+            if isSpot:
+                market = self.market(symbols[i])
+                topics.append('spot@public.aggre.bookTicker.v3.api.pb@100ms@' + market['id'])
+            messageHashes.append('unsubscribe:bidask:' + symbols[i])
+        url = self.urls['api']['ws']['spot']
+        request: dict = {
+            'method': 'UNSUBSCRIPTION',
+            'params': topics,
+        }
+        client = self.client(url)
+        self.watch_multiple(url, messageHashes, self.extend(request, params), messageHashes)
+        self.handle_unsubscriptions(client, messageHashes)
+        return None
+
+    async def un_watch_ohlcv(self, symbol: str, timeframe='1m', params={}) -> Any:
+        """
+        unWatches 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
+        :param dict [params.timezone]: if provided, kline intervals are interpreted in that timezone instead of UTC, example '+08:00'
+        :returns int[][]: A list of candles ordered, open, high, low, close, volume
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        symbol = market['symbol']
+        timeframes = self.safe_value(self.options, 'timeframes', {})
+        timeframeId = self.safe_string(timeframes, timeframe)
+        messageHash = 'unsubscribe:candles:' + symbol + ':' + timeframe
+        url = None
+        if market['spot']:
+            url = self.urls['api']['ws']['spot']
+            channel = 'spot@public.kline.v3.api.pb@' + market['id'] + '@' + timeframeId
+            params['unsubscribed'] = True
+            self.watch_spot_public(channel, messageHash, params)
+        else:
+            url = self.urls['api']['ws']['swap']
+            channel = 'unsub.kline'
+            requestParams: dict = {
+                'symbol': market['id'],
+                'interval': timeframeId,
+            }
+            self.watch_swap_public(channel, messageHash, requestParams, params)
+        client = self.client(url)
+        self.handle_unsubscriptions(client, [messageHash])
+        return None
+
+    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
+        :param str symbol: unified array of symbols
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.frequency]: the frequency of the order book updates, default is '10ms', can be '100ms' or '10ms
+        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        symbol = market['symbol']
+        messageHash = 'unsubscribe:orderbook:' + symbol
+        url = None
+        if market['spot']:
+            url = self.urls['api']['ws']['spot']
+            frequency = None
+            frequency, params = self.handle_option_and_params(params, 'watchOrderBook', 'frequency', '100ms')
+            channel = 'spot@public.aggre.depth.v3.api.pb@' + frequency + '@' + market['id']
+            params['unsubscribed'] = True
+            self.watch_spot_public(channel, messageHash, params)
+        else:
+            url = self.urls['api']['ws']['swap']
+            channel = 'unsub.depth'
+            requestParams: dict = {
+                'symbol': market['id'],
+            }
+            self.watch_swap_public(channel, messageHash, requestParams, params)
+        client = self.client(url)
+        self.handle_unsubscriptions(client, [messageHash])
+        return None
+
+    async def un_watch_trades(self, symbol: str, params={}) -> Any:
+        """
+        unsubscribes from the trades channel
+        :param str symbol: unified symbol of the market to fetch trades for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.name]: the name of the method to call, 'trade' or 'aggTrade', default is 'trade'
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        symbol = market['symbol']
+        messageHash = 'unsubscribe:trades:' + symbol
+        url = None
+        if market['spot']:
+            url = self.urls['api']['ws']['spot']
+            channel = 'spot@public.aggre.deals.v3.api.pb@100ms@' + market['id']
+            params['unsubscribed'] = True
+            self.watch_spot_public(channel, messageHash, params)
+        else:
+            url = self.urls['api']['ws']['swap']
+            channel = 'unsub.deal'
+            requestParams: dict = {
+                'symbol': market['id'],
+            }
+            self.watch_swap_public(channel, messageHash, requestParams, params)
+        client = self.client(url)
+        self.handle_unsubscriptions(client, [messageHash])
+        return None
+
+    def handle_unsubscriptions(self, client: Client, messageHashes: List[str]):
+        for i in range(0, len(messageHashes)):
+            messageHash = messageHashes[i]
+            subMessageHash = messageHash.replace('unsubscribe:', '')
+            self.clean_unsubscription(client, subMessageHash, messageHash)
+            if messageHash.find('ticker') >= 0:
+                symbol = messageHash.replace('unsubscribe:ticker:', '')
+                if symbol.find('unsubscribe') >= 0:
+                    # unWatchTickers
+                    symbols = list(self.tickers.keys())
+                    for j in range(0, len(symbols)):
+                        del self.tickers[symbols[j]]
+                elif symbol in self.tickers:
+                    del self.tickers[symbol]
+            elif messageHash.find('bidask') >= 0:
+                symbol = messageHash.replace('unsubscribe:bidask:', '')
+                if symbol in self.bidsasks:
+                    del self.bidsasks[symbol]
+            elif messageHash.find('candles') >= 0:
+                splitHashes = messageHash.split(':')
+                symbol = self.safe_string(splitHashes, 2)
+                if len(splitHashes) > 4:
+                    symbol += ':' + self.safe_string(splitHashes, 3)
+                if symbol in self.ohlcvs:
+                    del self.ohlcvs[symbol]
+            elif messageHash.find('orderbook') >= 0:
+                symbol = messageHash.replace('unsubscribe:orderbook:', '')
+                if symbol in self.orderbooks:
+                    del self.orderbooks[symbol]
+            elif messageHash.find('trades') >= 0:
+                symbol = messageHash.replace('unsubscribe:trades:', '')
+                if symbol in self.trades:
+                    del self.trades[symbol]
+
     async def authenticate(self, subscriptionHash, params={}):
         # we only need one listenKey since ccxt shares connections
         listenKey = self.safe_string(self.options, 'listenKey')
@@ -1067,8 +1787,8 @@ class mexc(ccxt.async_support.mexc):
         #        "code": 0,
         #        "msg": "spot@public.increase.depth.v3.api@BTCUSDT"
         #    }
-        #
-        msg = self.safe_string(message, 'msg')
+        # Set the default to an empty string if the message is empty during the test.
+        msg = self.safe_string(message, 'msg', '')
         if msg == 'PONG':
             self.handle_pong(client, message)
         elif msg.find('@') > -1:
@@ -1076,16 +1796,59 @@ class mexc(ccxt.async_support.mexc):
             channel = self.safe_string(parts, 1)
             methods: dict = {
                 'public.increase.depth.v3.api': self.handle_order_book_subscription,
+                'public.aggre.depth.v3.api.pb': self.handle_order_book_subscription,
             }
             method = self.safe_value(methods, channel)
             if method is not None:
                 method(client, message)
 
+    def handle_protobuf_message(self, client: Client, message):
+        # protobuf message decoded
+        #  {
+        #    "channel":"spot@public.kline.v3.api.pb@BTCUSDT@Min1",
+        #    "symbol":"BTCUSDT",
+        #    "symbolId":"2fb942154ef44a4ab2ef98c8afb6a4a7",
+        #    "createTime":"1754737941062",
+        #    "publicSpotKline":{
+        #       "interval":"Min1",
+        #       "windowStart":"1754737920",
+        #       "openingPrice":"117317.31",
+        #       "closingPrice":"117325.26",
+        #       "highestPrice":"117341",
+        #       "lowestPrice":"117317.3",
+        #       "volume":"3.12599854",
+        #       "amount":"366804.43",
+        #       "windowEnd":"1754737980"
+        #    }
+        # }
+        channel = self.safe_string(message, 'channel')
+        channelParts = channel.split('@')
+        channelId = self.safe_string(channelParts, 1)
+        if channelId == 'public.kline.v3.api.pb':
+            self.handle_ohlcv(client, message)
+        elif channelId == 'public.aggre.deals.v3.api.pb':
+            self.handle_trades(client, message)
+        elif channelId == 'public.aggre.bookTicker.v3.api.pb':
+            self.handle_ticker(client, message)
+        elif channelId == 'public.aggre.depth.v3.api.pb':
+            self.handle_order_book(client, message)
+        elif channelId == 'private.account.v3.api.pb':
+            self.handle_balance(client, message)
+        elif channelId == 'private.deals.v3.api.pb':
+            self.handle_my_trade(client, message)
+        elif channelId == 'private.orders.v3.api.pb':
+            self.handle_order(client, message)
+        return True
+
     def handle_message(self, client: Client, message):
         if isinstance(message, str):
             if message == 'Invalid listen key':
                 error = AuthenticationError(self.id + ' invalid listen key')
                 client.reject(error)
+                return
+        if self.is_binary_message(message):
+            message = self.decode_proto_msg(message)
+            self.handle_protobuf_message(client, message)
             return
         if 'msg' in message:
             self.handle_subscription_status(client, message)
@@ -1103,7 +1866,10 @@ class mexc(ccxt.async_support.mexc):
             'public.kline.v3.api': self.handle_ohlcv,
             'push.kline': self.handle_ohlcv,
             'public.bookTicker.v3.api': self.handle_ticker,
+            'public.miniTicker.v3.api': self.handle_ticker,
+            'public.miniTickers.v3.api': self.handle_tickers,
             'push.ticker': self.handle_ticker,
+            'push.tickers': self.handle_tickers,
             'public.increase.depth.v3.api': self.handle_order_book,
             'push.depth': self.handle_order_book,
             'private.orders.v3.api': self.handle_order,
@@ -1118,5 +1884,5 @@ class mexc(ccxt.async_support.mexc):
             method = methods[channel]
             method(client, message)
 
-    def ping(self, client):
+    def ping(self, client: Client):
         return {'method': 'ping'}