ccxt 4.1.84__py2.py3-none-any.whl → 4.1.86__py2.py3-none-any.whl

ccxt/pro/bitmart.py

@@ -4,11 +4,14 @@
 # https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
 
 import ccxt.async_support
-from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
+from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide, ArrayCacheByTimestamp
+from ccxt.async_support.base.ws.order_book_side import Asks, Bids
 import hashlib
-from ccxt.base.types import Int, Str
+from ccxt.base.types import Int, Market, Str, Strings
 from ccxt.async_support.base.ws.client import Client
+from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ArgumentsRequired
+from ccxt.base.errors import NotSupported
 from ccxt.base.errors import AuthenticationError
 
 
@@ -25,24 +28,38 @@ class bitmart(ccxt.async_support.bitmart):
                 'cancelOrdersWs': False,
                 'cancelAllOrdersWs': False,
                 'ws': True,
+                'watchBalance': True,
                 'watchTicker': True,
+                'watchTickers': True,
                 'watchOrderBook': True,
                 'watchOrders': True,
                 'watchTrades': True,
                 'watchOHLCV': True,
+                'watchPosition': 'emulated',
+                'watchPositions': True,
             },
             'urls': {
                 'api': {
                     'ws': {
-                        'public': 'wss://ws-manager-compress.{hostname}/api?protocol=1.1',
-                        'private': 'wss://ws-manager-compress.{hostname}/user?protocol=1.1',
+                        'spot': {
+                            'public': 'wss://ws-manager-compress.{hostname}/api?protocol=1.1',
+                            'private': 'wss://ws-manager-compress.{hostname}/user?protocol=1.1',
+                        },
+                        'swap': {
+                            'public': 'wss://openapi-ws.{hostname}/api?protocol=1.1',
+                            'private': 'wss://openapi-ws.{hostname}/user?protocol=1.1',
+                        },
                     },
                 },
             },
             'options': {
                 'defaultType': 'spot',
+                'watchBalance': {
+                    'fetchBalanceSnapshot': True,  # or False
+                    'awaitBalanceSnapshot': True,  # whether to wait for the balance snapshot before providing updates
+                },
                 'watchOrderBook': {
-                    'depth': 'depth5',  # depth5, depth20, depth50
+                    'depth': 'depth50',  # depth5, depth20, depth50
                 },
                 'ws': {
                     'inflate': True,
@@ -68,31 +85,147 @@ class bitmart(ccxt.async_support.bitmart):
             },
         })
 
-    async def subscribe(self, channel, symbol, params={}):
-        await self.load_markets()
+    async def subscribe(self, channel, symbol, type, params={}):
         market = self.market(symbol)
-        url = self.implode_hostname(self.urls['api']['ws']['public'])
-        messageHash = market['type'] + '/' + channel + ':' + market['id']
-        request = {
-            'op': 'subscribe',
-            'args': [messageHash],
-        }
+        url = self.implode_hostname(self.urls['api']['ws'][type]['public'])
+        request = {}
+        messageHash = None
+        if type == 'spot':
+            messageHash = 'spot/' + channel + ':' + market['id']
+            request = {
+                'op': 'subscribe',
+                'args': [messageHash],
+            }
+        else:
+            messageHash = 'futures/' + channel + ':' + market['id']
+            request = {
+                'action': 'subscribe',
+                'args': [messageHash],
+            }
         return await self.watch(url, messageHash, self.deep_extend(request, params), messageHash)
 
-    async def subscribe_private(self, channel, symbol, params={}):
+    async def watch_balance(self, params={}):
+        """
+        :see: https://developer-pro.bitmart.com/en/spot/#private-balance-change
+        :see: https://developer-pro.bitmart.com/en/futures/#private-assets-channel
+        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>`
+        """
         await self.load_markets()
-        market = self.market(symbol)
-        url = self.implode_hostname(self.urls['api']['ws']['private'])
-        messageHash = channel + ':' + market['id']
-        await self.authenticate()
-        request = {
-            'op': 'subscribe',
-            'args': [messageHash],
-        }
+        type = 'spot'
+        type, params = self.handle_market_type_and_params('watchBalance', None, params)
+        await self.authenticate(type, params)
+        request = {}
+        if type == 'spot':
+            request = {
+                'op': 'subscribe',
+                'args': ['spot/user/balance:BALANCE_UPDATE'],
+            }
+        else:
+            request = {
+                'action': 'subscribe',
+                'args': ['futures/asset:USDT', 'futures/asset:BTC', 'futures/asset:ETH'],
+            }
+        messageHash = 'balance:' + type
+        url = self.implode_hostname(self.urls['api']['ws'][type]['private'])
+        client = self.client(url)
+        self.set_balance_cache(client, type)
+        fetchBalanceSnapshot = self.handle_option_and_params(self.options, 'watchBalance', 'fetchBalanceSnapshot', True)
+        awaitBalanceSnapshot = self.handle_option_and_params(self.options, 'watchBalance', 'awaitBalanceSnapshot', False)
+        if fetchBalanceSnapshot and awaitBalanceSnapshot:
+            await client.future(type + ':fetchBalanceSnapshot')
         return await self.watch(url, messageHash, self.deep_extend(request, params), messageHash)
 
+    def set_balance_cache(self, client: Client, type):
+        if type in client.subscriptions:
+            return None
+        options = self.safe_value(self.options, 'watchBalance')
+        fetchBalanceSnapshot = self.handle_option_and_params(options, 'watchBalance', 'fetchBalanceSnapshot', True)
+        if fetchBalanceSnapshot:
+            messageHash = type + ':fetchBalanceSnapshot'
+            if not (messageHash in client.futures):
+                client.future(messageHash)
+                self.spawn(self.load_balance_snapshot, client, messageHash, type)
+        else:
+            self.balance[type] = {}
+
+    async def load_balance_snapshot(self, client, messageHash, type):
+        response = await self.fetch_balance({'type': type})
+        self.balance[type] = self.extend(response, self.safe_value(self.balance, type, {}))
+        # don't remove the future from the .futures cache
+        future = client.futures[messageHash]
+        future.resolve()
+        client.resolve(self.balance[type], 'balance:' + type)
+
+    def handle_balance(self, client: Client, message):
+        #
+        # spot
+        #    {
+        #        "data":[
+        #           {
+        #              "balance_details":[
+        #                 {
+        #                    "av_bal":"0.206000000000000000000000000000",
+        #                    "ccy":"LTC",
+        #                    "fz_bal":"0.100000000000000000000000000000"
+        #                 }
+        #              ],
+        #              "event_time":"1701632345415",
+        #              "event_type":"TRANSACTION_COMPLETED"
+        #           }
+        #        ],
+        #        "table":"spot/user/balance"
+        #    }
+        # swap
+        #    {
+        #        group: 'futures/asset:USDT',
+        #        data: {
+        #            currency: 'USDT',
+        #            available_balance: '37.19688649135',
+        #            position_deposit: '0.788687546',
+        #            frozen_balance: '0'
+        #        }
+        #    }
+        #
+        channel = self.safe_string_2(message, 'table', 'group')
+        data = self.safe_value(message, 'data')
+        if data is None:
+            return
+        isSpot = (channel.find('spot') >= 0)
+        type = 'spot' if isSpot else 'swap'
+        self.balance['info'] = message
+        if isSpot:
+            if not isinstance(data, list):
+                return
+            for i in range(0, len(data)):
+                timestamp = self.safe_integer(message, 'event_time')
+                self.balance['timestamp'] = timestamp
+                self.balance['datetime'] = self.iso8601(timestamp)
+                balanceDetails = self.safe_value(data[i], 'balance_details', [])
+                for ii in range(0, len(balanceDetails)):
+                    rawBalance = balanceDetails[i]
+                    account = self.account()
+                    currencyId = self.safe_string(rawBalance, 'ccy')
+                    code = self.safe_currency_code(currencyId)
+                    account['free'] = self.safe_string(rawBalance, 'av_bal')
+                    account['total'] = self.safe_string(rawBalance, 'fz_bal')
+                    self.balance[code] = account
+        else:
+            currencyId = self.safe_string(data, 'currency')
+            code = self.safe_currency_code(currencyId)
+            account = self.account()
+            account['free'] = self.safe_string(data, 'available_balance')
+            account['used'] = self.safe_string(data, 'frozen_balance')
+            self.balance[type][code] = account
+        self.balance[type] = self.safe_balance(self.balance[type])
+        messageHash = 'balance:' + type
+        client.resolve(self.balance[type], messageHash)
+
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}):
         """
+        :see: https://developer-pro.bitmart.com/en/spot/#public-trade-channel
+        :see: https://developer-pro.bitmart.com/en/futures/#public-trade-channel
         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
@@ -102,22 +235,65 @@ class bitmart(ccxt.async_support.bitmart):
         """
         await self.load_markets()
         symbol = self.symbol(symbol)
-        trades = await self.subscribe('trade', symbol, params)
+        market = self.market(symbol)
+        type = 'spot'
+        type, params = self.handle_market_type_and_params('watchTrades', market, params)
+        trades = await self.subscribe('trade', symbol, type, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     async def watch_ticker(self, symbol: str, params={}):
         """
+        :see: https://developer-pro.bitmart.com/en/spot/#public-ticker-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
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
-        return await self.subscribe('ticker', symbol, params)
+        await self.load_markets()
+        symbol = self.symbol(symbol)
+        market = self.market(symbol)
+        type = 'spot'
+        type, params = self.handle_market_type_and_params('watchTicker', market, params)
+        if type == 'swap':
+            raise NotSupported(self.id + ' watchTicker() does not support ' + type + ' markets. Use watchTickers() instead')
+        return await self.subscribe('ticker', symbol, type, params)
+
+    async def watch_tickers(self, symbols: Strings = None, params={}):
+        """
+        :see: https://developer-pro.bitmart.com/en/futures/#overview
+        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
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        market = self.get_market_from_symbols(symbols)
+        type = 'spot'
+        type, params = self.handle_market_type_and_params('watchTickers', market, params)
+        symbols = self.market_symbols(symbols)
+        if type == 'spot':
+            raise NotSupported(self.id + ' watchTickers() does not support ' + type + ' markets. Use watchTicker() instead')
+        url = self.implode_hostname(self.urls['api']['ws'][type]['public'])
+        if type == 'swap':
+            type = 'futures'
+        messageHash = 'tickers'
+        if symbols is not None:
+            messageHash += '::' + ','.join(symbols)
+        request = {
+            'action': 'subscribe',
+            'args': ['futures/ticker'],
+        }
+        newTickers = await self.watch(url, messageHash, self.deep_extend(request, params), messageHash)
+        if self.newUpdates:
+            return newTickers
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
 
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
+        :see: https://developer-pro.bitmart.com/en/spot/#private-order-channel
+        :see: https://developer-pro.bitmart.com/en/futures/#private-order-channel
         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
@@ -125,184 +301,593 @@ class bitmart(ccxt.async_support.bitmart):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
-        if symbol is None:
-            raise ArgumentsRequired(self.id + ' watchOrders() requires a symbol argument')
         await self.load_markets()
-        market = self.market(symbol)
-        symbol = market['symbol']
-        if market['type'] != 'spot':
-            raise ArgumentsRequired(self.id + ' watchOrders supports spot markets only')
-        channel = 'spot/user/order'
-        orders = await self.subscribe_private(channel, symbol, params)
+        market = None
+        messageHash = 'orders'
+        if symbol is not None:
+            symbol = self.symbol(symbol)
+            market = self.market(symbol)
+            messageHash = 'orders::' + symbol
+        type = 'spot'
+        type, params = self.handle_market_type_and_params('watchOrders', market, params)
+        await self.authenticate(type, params)
+        request = None
+        if type == 'spot':
+            if symbol is None:
+                raise ArgumentsRequired(self.id + ' watchOrders() requires a symbol argument for spot markets')
+            request = {
+                'op': 'subscribe',
+                'args': ['spot/user/order:' + market['id']],
+            }
+        else:
+            request = {
+                'action': 'subscribe',
+                'args': ['futures/order'],
+            }
+        url = self.implode_hostname(self.urls['api']['ws'][type]['private'])
+        newOrders = await self.watch(url, messageHash, self.deep_extend(request, params), messageHash)
         if self.newUpdates:
-            limit = orders.getLimit(symbol, limit)
-        return self.filter_by_symbol_since_limit(orders, symbol, since, limit, True)
+            return newOrders
+        return self.filter_by_symbol_since_limit(self.orders, symbol, since, limit, True)
 
     def handle_orders(self, client: Client, message):
         #
-        # {
-        #     "data":[
-        #         {
-        #             "symbol": "LTC_USDT",
-        #             "notional": '',
-        #             "side": "buy",
-        #             "last_fill_time": "0",
-        #             "ms_t": "1646216634000",
-        #             "type": "limit",
-        #             "filled_notional": "0.000000000000000000000000000000",
-        #             "last_fill_price": "0",
-        #             "size": "0.500000000000000000000000000000",
-        #             "price": "50.000000000000000000000000000000",
-        #             "last_fill_count": "0",
-        #             "filled_size": "0.000000000000000000000000000000",
-        #             "margin_trading": "0",
-        #             "state": "8",
-        #             "order_id": "24807076628",
-        #             "order_type": "0"
+        # spot
+        #    {
+        #        "data":[
+        #            {
+        #                "symbol": "LTC_USDT",
+        #                "notional": '',
+        #                "side": "buy",
+        #                "last_fill_time": "0",
+        #                "ms_t": "1646216634000",
+        #                "type": "limit",
+        #                "filled_notional": "0.000000000000000000000000000000",
+        #                "last_fill_price": "0",
+        #                "size": "0.500000000000000000000000000000",
+        #                "price": "50.000000000000000000000000000000",
+        #                "last_fill_count": "0",
+        #                "filled_size": "0.000000000000000000000000000000",
+        #                "margin_trading": "0",
+        #                "state": "8",
+        #                "order_id": "24807076628",
+        #                "order_type": "0"
+        #              }
+        #        ],
+        #        "table":"spot/user/order"
+        #    }
+        # swap
+        #    {
+        #        "group":"futures/order",
+        #        "data":[
+        #           {
+        #              "action":2,
+        #              "order":{
+        #                 "order_id":"2312045036986775",
+        #                 "client_order_id":"",
+        #                 "price":"71.61707928",
+        #                 "size":"1",
+        #                 "symbol":"LTCUSDT",
+        #                 "state":1,
+        #                 "side":4,
+        #                 "type":"market",
+        #                 "leverage":"1",
+        #                 "open_type":"cross",
+        #                 "deal_avg_price":"0",
+        #                 "deal_size":"0",
+        #                 "create_time":1701625324646,
+        #                 "update_time":1701625324640,
+        #                 "plan_order_id":"",
+        #                 "last_trade":null
+        #              }
         #           }
-        #     ],
-        #     "table":"spot/user/order"
-        # }
+        #        ]
+        #    }
         #
-        channel = self.safe_string(message, 'table')
-        orders = self.safe_value(message, 'data', [])
+        orders = self.safe_value(message, 'data')
+        if orders is None:
+            return
         ordersLength = len(orders)
+        newOrders = []
+        symbols = {}
         if ordersLength > 0:
             limit = self.safe_integer(self.options, 'ordersLimit', 1000)
             if self.orders is None:
                 self.orders = ArrayCacheBySymbolById(limit)
             stored = self.orders
-            marketIds = []
             for i in range(0, len(orders)):
                 order = self.parse_ws_order(orders[i])
                 stored.append(order)
+                newOrders.append(order)
                 symbol = order['symbol']
-                market = self.market(symbol)
-                marketIds.append(market['id'])
-            for i in range(0, len(marketIds)):
-                messageHash = channel + ':' + marketIds[i]
-                client.resolve(self.orders, messageHash)
-
-    def parse_ws_order(self, order, market=None):
-        #
-        # {
-        #     "symbol": "LTC_USDT",
-        #     "notional": '',
-        #     "side": "buy",
-        #     "last_fill_time": "0",
-        #     "ms_t": "1646216634000",
-        #     "type": "limit",
-        #     "filled_notional": "0.000000000000000000000000000000",
-        #     "last_fill_price": "0",
-        #     "size": "0.500000000000000000000000000000",
-        #     "price": "50.000000000000000000000000000000",
-        #     "last_fill_count": "0",
-        #     "filled_size": "0.000000000000000000000000000000",
-        #     "margin_trading": "0",
-        #     "state": "8",
-        #     "order_id": "24807076628",
-        #     "order_type": "0"
-        #   }
-        #
-        marketId = self.safe_string(order, 'symbol')
-        market = self.safe_market(marketId, market)
-        id = self.safe_string(order, 'order_id')
-        clientOrderId = self.safe_string(order, 'clientOid')
-        price = self.safe_string(order, 'price')
-        filled = self.safe_string(order, 'filled_size')
-        amount = self.safe_string(order, 'size')
-        type = self.safe_string(order, 'type')
-        rawState = self.safe_string(order, 'state')
-        status = self.parseOrderStatusByType(market['type'], rawState)
-        timestamp = self.safe_integer(order, 'ms_t')
+                symbols[symbol] = True
+        newOrderSymbols = list(symbols.keys())
+        for i in range(0, len(newOrderSymbols)):
+            symbol = newOrderSymbols[i]
+            self.resolve_promise_if_messagehash_matches(client, 'orders::', symbol, newOrders)
+        client.resolve(newOrders, 'orders')
+
+    def parse_ws_order(self, order, market: Market = None):
+        #
+        # spot
+        #    {
+        #        "symbol": "LTC_USDT",
+        #        "notional": '',
+        #        "side": "buy",
+        #        "last_fill_time": "0",
+        #        "ms_t": "1646216634000",
+        #        "type": "limit",
+        #        "filled_notional": "0.000000000000000000000000000000",
+        #        "last_fill_price": "0",
+        #        "size": "0.500000000000000000000000000000",
+        #        "price": "50.000000000000000000000000000000",
+        #        "last_fill_count": "0",
+        #        "filled_size": "0.000000000000000000000000000000",
+        #        "margin_trading": "0",
+        #        "state": "8",
+        #        "order_id": "24807076628",
+        #        "order_type": "0"
+        #    }
+        # swap
+        #    {
+        #       "action":2,
+        #       "order":{
+        #          "order_id":"2312045036986775",
+        #          "client_order_id":"",
+        #          "price":"71.61707928",
+        #          "size":"1",
+        #          "symbol":"LTCUSDT",
+        #          "state":1,
+        #          "side":4,
+        #          "type":"market",
+        #          "leverage":"1",
+        #          "open_type":"cross",
+        #          "deal_avg_price":"0",
+        #          "deal_size":"0",
+        #          "create_time":1701625324646,
+        #          "update_time":1701625324640,
+        #          "plan_order_id":"",
+        #          "last_trade":null
+        #       }
+        #    }
+        #
+        action = self.safe_number(order, 'action')
+        isSpot = (action is None)
+        if isSpot:
+            marketId = self.safe_string(order, 'symbol')
+            market = self.safe_market(marketId, market, '_', 'spot')
+            id = self.safe_string(order, 'order_id')
+            clientOrderId = self.safe_string(order, 'clientOid')
+            price = self.safe_string(order, 'price')
+            filled = self.safe_string(order, 'filled_size')
+            amount = self.safe_string(order, 'size')
+            type = self.safe_string(order, 'type')
+            rawState = self.safe_string(order, 'state')
+            status = self.parseOrderStatusByType(market['type'], rawState)
+            timestamp = self.safe_integer(order, 'ms_t')
+            symbol = market['symbol']
+            side = self.safe_string_lower(order, 'side')
+            return self.safe_order({
+                'info': order,
+                'symbol': symbol,
+                'id': id,
+                'clientOrderId': clientOrderId,
+                'timestamp': None,
+                'datetime': None,
+                'lastTradeTimestamp': timestamp,
+                'type': type,
+                'timeInForce': None,
+                'postOnly': None,
+                'side': side,
+                'price': price,
+                'stopPrice': None,
+                'triggerPrice': None,
+                'amount': amount,
+                'cost': None,
+                'average': None,
+                'filled': filled,
+                'remaining': None,
+                'status': status,
+                'fee': None,
+                'trades': None,
+            }, market)
+        else:
+            orderInfo = self.safe_value(order, 'order')
+            marketId = self.safe_string(orderInfo, 'symbol')
+            symbol = self.safe_symbol(marketId, market, '', 'swap')
+            orderId = self.safe_string(orderInfo, 'order_id')
+            timestamp = self.safe_integer(orderInfo, 'create_time')
+            updatedTimestamp = self.safe_integer(orderInfo, 'update_time')
+            lastTrade = self.safe_value(orderInfo, 'last_trade')
+            cachedOrders = self.orders
+            orders = self.safe_value(cachedOrders.hashmap, symbol, {})
+            cachedOrder = self.safe_value(orders, orderId)
+            trades = None
+            if cachedOrder is not None:
+                trades = self.safe_value(order, 'trades')
+            if lastTrade is not None:
+                if trades is None:
+                    trades = []
+                trades.append(lastTrade)
+            return self.safe_order({
+                'info': order,
+                'symbol': symbol,
+                'id': orderId,
+                'clientOrderId': self.safe_string(orderInfo, 'client_order_id'),
+                'timestamp': timestamp,
+                'datetime': self.iso8601(timestamp),
+                'lastTradeTimestamp': updatedTimestamp,
+                'type': self.safe_string(orderInfo, 'type'),
+                'timeInForce': None,
+                'postOnly': None,
+                'side': self.parse_ws_order_side(self.safe_string(orderInfo, 'side')),
+                'price': self.safe_string(orderInfo, 'price'),
+                'stopPrice': None,
+                'triggerPrice': None,
+                'amount': self.safe_string(orderInfo, 'size'),
+                'cost': None,
+                'average': self.safe_string(orderInfo, 'deal_avg_price'),
+                'filled': self.safe_string(orderInfo, 'deal_size'),
+                'remaining': None,
+                'status': self.parse_ws_order_status(self.safe_string(order, 'action')),
+                'fee': None,
+                'trades': trades,
+            }, market)
+
+    def parse_ws_order_status(self, statusId):
+        statuses = {
+            '1': 'closed',  # match deal
+            '2': 'open',  # submit order
+            '3': 'canceled',  # cancel order
+            '4': 'closed',  # liquidate cancel order
+            '5': 'canceled',  # adl cancel order
+            '6': 'open',  # part liquidate
+            '7': 'open',  # bankrupty order
+            '8': 'closed',  # passive adl match deal
+            '9': 'closed',  # active adl match deal
+        }
+        return self.safe_string(statuses, statusId, statusId)
+
+    def parse_ws_order_side(self, sideId):
+        sides = {
+            '1': 'buy',  # buy_open_long
+            '2': 'buy',  # buy_close_short
+            '3': 'sell',  # sell_close_long
+            '4': 'sell',  # sell_open_short
+        }
+        return self.safe_string(sides, sideId, sideId)
+
+    async def watch_positions(self, symbols: Strings = None, since: Int = None, limit: Int = None, params={}):
+        """
+        :see: https://developer-pro.bitmart.com/en/futures/#private-position-channel
+        watch all open positions
+        :param str[]|None symbols: list of unified market symbols
+        :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()
+        type = 'swap'
+        await self.authenticate(type, params)
+        symbols = self.market_symbols(symbols, 'swap', True, True, False)
+        messageHash = 'positions'
+        if symbols is not None:
+            messageHash += '::' + ','.join(symbols)
+        subscriptionHash = 'futures/position'
+        request = {
+            'action': 'subscribe',
+            'args': ['futures/position'],
+        }
+        url = self.implode_hostname(self.urls['api']['ws'][type]['private'])
+        newPositions = await self.watch(url, messageHash, self.deep_extend(request, params), subscriptionHash)
+        if self.newUpdates:
+            return newPositions
+        return self.filter_by_symbols_since_limit(self.positions, symbols, since, limit)
+
+    def handle_positions(self, client: Client, message):
+        #
+        #    {
+        #        "group":"futures/position",
+        #        "data":[
+        #           {
+        #              "symbol":"LTCUSDT",
+        #              "hold_volume":"5",
+        #              "position_type":2,
+        #              "open_type":2,
+        #              "frozen_volume":"0",
+        #              "close_volume":"0",
+        #              "hold_avg_price":"71.582",
+        #              "close_avg_price":"0",
+        #              "open_avg_price":"71.582",
+        #              "liquidate_price":"0",
+        #              "create_time":1701623327513,
+        #              "update_time":1701627620439
+        #           },
+        #           {
+        #              "symbol":"LTCUSDT",
+        #              "hold_volume":"6",
+        #              "position_type":1,
+        #              "open_type":2,
+        #              "frozen_volume":"0",
+        #              "close_volume":"0",
+        #              "hold_avg_price":"71.681666666666666667",
+        #              "close_avg_price":"0",
+        #              "open_avg_price":"71.681666666666666667",
+        #              "liquidate_price":"0",
+        #              "create_time":1701621167225,
+        #              "update_time":1701628152614
+        #           }
+        #        ]
+        #    }
+        #
+        data = self.safe_value(message, 'data', [])
+        cache = self.positions
+        if self.positions is None:
+            self.positions = ArrayCacheBySymbolBySide()
+        newPositions = []
+        for i in range(0, len(data)):
+            rawPosition = data[i]
+            position = self.parse_ws_position(rawPosition)
+            newPositions.append(position)
+            cache.append(position)
+        messageHashes = self.find_message_hashes(client, 'positions::')
+        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, 'positions')
+
+    def parse_ws_position(self, position, market: Market = None):
+        #
+        #    {
+        #       "symbol":"LTCUSDT",
+        #       "hold_volume":"6",
+        #       "position_type":1,
+        #       "open_type":2,
+        #       "frozen_volume":"0",
+        #       "close_volume":"0",
+        #       "hold_avg_price":"71.681666666666666667",
+        #       "close_avg_price":"0",
+        #       "open_avg_price":"71.681666666666666667",
+        #       "liquidate_price":"0",
+        #       "create_time":1701621167225,
+        #       "update_time":1701628152614
+        #    }
+        #
+        marketId = self.safe_string(position, 'symbol')
+        market = self.safe_market(marketId, market, '', 'swap')
         symbol = market['symbol']
-        side = self.safe_string_lower(order, 'side')
-        return self.safe_order({
-            'info': order,
+        openTimestamp = self.safe_integer(position, 'create_time')
+        timestamp = self.safe_integer(position, 'update_time')
+        side = self.safe_number(position, 'position_type')
+        marginModeId = self.safe_number(position, 'open_type')
+        return self.safe_position({
+            'info': position,
+            'id': None,
             'symbol': symbol,
-            'id': id,
-            'clientOrderId': clientOrderId,
-            'timestamp': None,
-            'datetime': None,
-            'lastTradeTimestamp': timestamp,
-            'type': type,
-            'timeInForce': None,
-            'postOnly': None,
-            'side': side,
-            'price': price,
-            'stopPrice': None,
-            'triggerPrice': None,
-            'amount': amount,
-            'cost': None,
-            'average': None,
-            'filled': filled,
-            'remaining': None,
-            'status': status,
-            'fee': None,
-            'trades': None,
-        }, market)
+            'timestamp': openTimestamp,
+            'datetime': self.iso8601(openTimestamp),
+            'lastUpdateTimestamp': timestamp,
+            'hedged': None,
+            'side': 'long' if (side == 1) else 'short',
+            'contracts': self.safe_number(position, 'hold_volume'),
+            'contractSize': self.safe_number(market, 'contractSize'),
+            'entryPrice': self.safe_number(position, 'open_avg_price'),
+            'markPrice': self.safe_number(position, 'hold_avg_price'),
+            'lastPrice': None,
+            'notional': None,
+            'leverage': None,
+            'collateral': None,
+            'initialMargin': None,
+            'initialMarginPercentage': None,
+            'maintenanceMargin': None,
+            'maintenanceMarginPercentage': None,
+            'unrealizedPnl': None,
+            'realizedPnl': None,
+            'liquidationPrice': self.safe_number(position, 'liquidate_price'),
+            'marginMode': 'isolated' if (marginModeId == 1) else 'cross',
+            'percentage': None,
+            'marginRatio': None,
+            'stopLossPrice': None,
+            'takeProfitPrice': None,
+        })
 
     def handle_trade(self, client: Client, message):
         #
-        #     {
-        #         "table": "spot/trade",
-        #         "data": [
-        #             {
-        #                 "price": "52700.50",
-        #                 "s_t": 1630982050,
-        #                 "side": "buy",
-        #                 "size": "0.00112",
-        #                 "symbol": "BTC_USDT"
-        #             },
-        #         ]
-        #     }
+        # spot
+        #    {
+        #        "table": "spot/trade",
+        #        "data": [
+        #            {
+        #                "price": "52700.50",
+        #                "s_t": 1630982050,
+        #                "side": "buy",
+        #                "size": "0.00112",
+        #                "symbol": "BTC_USDT"
+        #            },
+        #        ]
+        #    }
         #
-        table = self.safe_string(message, 'table')
-        data = self.safe_value(message, 'data', [])
-        tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000)
+        # swap
+        #    {
+        #        "group":"futures/trade:BTCUSDT",
+        #        "data":[
+        #           {
+        #              "trade_id":6798697637,
+        #              "contract_id":1,
+        #              "symbol":"BTCUSDT",
+        #              "deal_price":"39735.8",
+        #              "deal_vol":"2",
+        #              "type":0,
+        #              "way":1,
+        #              "create_time":1701618503,
+        #              "create_time_mill":1701618503517,
+        #              "created_at":"2023-12-03T15:48:23.517518538Z"
+        #           }
+        #        ]
+        #    }
+        #
+        channel = self.safe_string_2(message, 'table', 'group')
+        isSpot = (channel.find('spot') >= 0)
+        data = self.safe_value(message, 'data')
+        if data is None:
+            return
+        stored = None
         for i in range(0, len(data)):
-            trade = self.parse_trade(data[i])
+            trade = self.parse_ws_trade(data[i])
             symbol = trade['symbol']
-            marketId = self.safe_string(trade['info'], 'symbol')
-            messageHash = table + ':' + marketId
+            tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000)
             stored = self.safe_value(self.trades, symbol)
             if stored is None:
                 stored = ArrayCache(tradesLimit)
                 self.trades[symbol] = stored
             stored.append(trade)
-            client.resolve(stored, messageHash)
+        messageHash = channel
+        if isSpot:
+            messageHash += ':' + self.safe_string(data[0], 'symbol')
+        client.resolve(stored, messageHash)
         return message
 
+    def parse_ws_trade(self, trade, market: Market = None):
+        # spot
+        #    {
+        #        "price": "52700.50",
+        #        "s_t": 1630982050,
+        #        "side": "buy",
+        #        "size": "0.00112",
+        #        "symbol": "BTC_USDT"
+        #    }
+        # swap
+        #    {
+        #       "trade_id":6798697637,
+        #       "contract_id":1,
+        #       "symbol":"BTCUSDT",
+        #       "deal_price":"39735.8",
+        #       "deal_vol":"2",
+        #       "type":0,
+        #       "way":1,
+        #       "create_time":1701618503,
+        #       "create_time_mill":1701618503517,
+        #       "created_at":"2023-12-03T15:48:23.517518538Z"
+        #    }
+        #
+        contractId = self.safe_string(trade, 'contract_id')
+        marketType = 'spot' if (contractId is None) else 'swap'
+        marketDelimiter = '_' if (marketType == 'spot') else ''
+        timestamp = self.safe_integer(trade, 'create_time_mill', self.safe_timestamp(trade, 's_t'))
+        marketId = self.safe_string(trade, 'symbol')
+        return self.safe_trade({
+            'info': trade,
+            'id': self.safe_string(trade, 'trade_id'),
+            'order': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'symbol': self.safe_symbol(marketId, market, marketDelimiter, marketType),
+            'type': None,
+            'side': self.safe_string(trade, 'side'),
+            'price': self.safe_string_2(trade, 'price', 'deal_price'),
+            'amount': self.safe_string_2(trade, 'size', 'deal_vol'),
+            'cost': None,
+            'takerOrMaker': None,
+            'fee': None,
+        }, market)
+
     def handle_ticker(self, client: Client, message):
         #
-        #     {
-        #         "data": [
-        #             {
-        #                 "base_volume_24h": "78615593.81",
-        #                 "high_24h": "52756.97",
-        #                 "last_price": "52638.31",
-        #                 "low_24h": "50991.35",
-        #                 "open_24h": "51692.03",
-        #                 "s_t": 1630981727,
-        #                 "symbol": "BTC_USDT"
-        #             }
-        #         ],
-        #         "table": "spot/ticker"
-        #     }
+        #    {
+        #        "data": [
+        #            {
+        #                "base_volume_24h": "78615593.81",
+        #                "high_24h": "52756.97",
+        #                "last_price": "52638.31",
+        #                "low_24h": "50991.35",
+        #                "open_24h": "51692.03",
+        #                "s_t": 1630981727,
+        #                "symbol": "BTC_USDT"
+        #            }
+        #        ],
+        #        "table": "spot/ticker"
+        #    }
+        #    {
+        #        "group":"futures/ticker",
+        #        "data":{
+        #              "symbol":"BTCUSDT",
+        #              "volume_24":"117387.58",
+        #              "fair_price":"146.24",
+        #              "last_price":"146.24",
+        #              "range":"147.17",
+        #              "ask_price": "147.11",
+        #              "ask_vol": "1",
+        #              "bid_price": "142.11",
+        #              "bid_vol": "1"
+        #            }
+        #    }
         #
         table = self.safe_string(message, 'table')
-        data = self.safe_value(message, 'data', [])
-        for i in range(0, len(data)):
-            ticker = self.parse_ticker(data[i])
-            symbol = ticker['symbol']
-            marketId = self.safe_string(ticker['info'], 'symbol')
-            messageHash = table + ':' + marketId
+        isSpot = (table is not None)
+        data = self.safe_value(message, 'data')
+        if data is None:
+            return
+        if isSpot:
+            for i in range(0, len(data)):
+                ticker = self.parse_ticker(data[i])
+                symbol = ticker['symbol']
+                marketId = self.safe_string(ticker['info'], 'symbol')
+                messageHash = table + ':' + marketId
+                self.tickers[symbol] = ticker
+                client.resolve(ticker, messageHash)
+        else:
+            ticker = self.parse_ws_swap_ticker(data)
+            symbol = self.safe_string(ticker, 'symbol')
             self.tickers[symbol] = ticker
-            client.resolve(ticker, messageHash)
+            client.resolve(ticker, 'tickers')
+            self.resolve_promise_if_messagehash_matches(client, 'tickers::', symbol, ticker)
         return message
 
+    def parse_ws_swap_ticker(self, ticker, market: Market = None):
+        #
+        #    {
+        #        "symbol":"BTCUSDT",
+        #        "volume_24":"117387.58",
+        #        "fair_price":"146.24",
+        #        "last_price":"146.24",
+        #        "range":"147.17",
+        #        "ask_price": "147.11",
+        #        "ask_vol": "1",
+        #        "bid_price": "142.11",
+        #        "bid_vol": "1"
+        #    }
+        marketId = self.safe_string(ticker, 'symbol')
+        return self.safe_ticker({
+            'symbol': self.safe_symbol(marketId, market, '', 'swap'),
+            'timestamp': None,
+            'datetime': None,
+            'high': None,
+            'low': None,
+            'bid': self.safe_string(ticker, 'bid_price'),
+            'bidVolume': self.safe_string(ticker, 'bid_vol'),
+            'ask': self.safe_string(ticker, 'ask_price'),
+            'askVolume': self.safe_string(ticker, 'ask_vol'),
+            'vwap': None,
+            'open': None,
+            'close': None,
+            'last': self.safe_string(ticker, 'last_price'),
+            'previousClose': None,
+            'change': None,
+            'percentage': None,
+            'average': self.safe_string(ticker, 'fair_price'),
+            'baseVolume': None,
+            'quoteVolume': self.safe_string(ticker, 'volume_24'),
+            'info': ticker,
+        }, market)
+
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}):
         """
+        :see: https://developer-pro.bitmart.com/en/spot/#public-kline-channel
+        :see: https://developer-pro.bitmart.com/en/futures/#public-klinebin-channel
         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
@@ -313,71 +898,125 @@ class bitmart(ccxt.async_support.bitmart):
         """
         await self.load_markets()
         symbol = self.symbol(symbol)
+        market = self.market(symbol)
+        type = 'spot'
+        type, params = self.handle_market_type_and_params('watchOrderBook', market, params)
         timeframes = self.safe_value(self.options, 'timeframes', {})
         interval = self.safe_string(timeframes, timeframe)
-        name = 'kline' + interval
-        ohlcv = await self.subscribe(name, symbol, params)
+        name = None
+        if type == 'spot':
+            name = 'kline' + interval
+        else:
+            name = 'klineBin' + interval
+        ohlcv = await self.subscribe(name, symbol, type, params)
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
         return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
 
     def handle_ohlcv(self, client: Client, message):
         #
-        #     {
-        #         "data": [
-        #             {
-        #                 "candle": [
-        #                     1631056350,
-        #                     "46532.83",
-        #                     "46555.71",
-        #                     "46511.41",
-        #                     "46555.71",
-        #                     "0.25"
-        #                 ],
-        #                 "symbol": "BTC_USDT"
-        #             }
-        #         ],
-        #         "table": "spot/kline1m"
-        #     }
+        #    {
+        #        "data": [
+        #            {
+        #                "candle": [
+        #                    1631056350,
+        #                    "46532.83",
+        #                    "46555.71",
+        #                    "46511.41",
+        #                    "46555.71",
+        #                    "0.25"
+        #                ],
+        #                "symbol": "BTC_USDT"
+        #            }
+        #        ],
+        #        "table": "spot/kline1m"
+        #    }
+        # swap
+        #    {
+        #        "group":"futures/klineBin1m:BTCUSDT",
+        #        "data":{
+        #           "symbol":"BTCUSDT",
+        #           "items":[
+        #              {
+        #                 "o":"39635.8",
+        #                 "h":"39636",
+        #                 "l":"39614.4",
+        #                 "c":"39629.7",
+        #                 "v":"31852",
+        #                 "ts":1701617761
+        #              }
+        #           ]
+        #        }
+        #    }
         #
-        table = self.safe_string(message, 'table')
-        data = self.safe_value(message, 'data', [])
-        parts = table.split('/')
-        part1 = self.safe_string(parts, 1)
+        channel = self.safe_string_2(message, 'table', 'group')
+        isSpot = (channel.find('spot') >= 0)
+        data = self.safe_value(message, 'data')
+        if data is None:
+            return
+        parts = channel.split('/')
+        part1 = self.safe_string(parts, 1, '')
         interval = part1.replace('kline', '')
+        interval = interval.replace('Bin', '')
+        intervalParts = interval.split(':')
+        interval = self.safe_string(intervalParts, 0)
         # use a reverse lookup in a static map instead
         timeframes = self.safe_value(self.options, 'timeframes', {})
         timeframe = self.find_timeframe(interval, timeframes)
         duration = self.parse_timeframe(timeframe)
         durationInMs = duration * 1000
-        for i in range(0, len(data)):
-            marketId = self.safe_string(data[i], 'symbol')
-            candle = self.safe_value(data[i], 'candle')
-            market = self.safe_market(marketId)
+        if isSpot:
+            for i in range(0, len(data)):
+                marketId = self.safe_string(data[i], 'symbol')
+                market = self.safe_market(marketId)
+                symbol = market['symbol']
+                rawOHLCV = self.safe_value(data[i], 'candle')
+                parsed = self.parse_ohlcv(rawOHLCV, market)
+                parsed[0] = self.parse_to_int(parsed[0] / durationInMs) * durationInMs
+                self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {})
+                stored = self.safe_value(self.ohlcvs[symbol], timeframe)
+                if stored is None:
+                    limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
+                    stored = ArrayCacheByTimestamp(limit)
+                    self.ohlcvs[symbol][timeframe] = stored
+                stored.append(parsed)
+                messageHash = channel + ':' + marketId
+                client.resolve(stored, messageHash)
+        else:
+            marketId = self.safe_string(data, 'symbol')
+            market = self.safe_market(marketId, None, '', 'swap')
             symbol = market['symbol']
-            parsed = self.parse_ohlcv(candle, market)
-            parsed[0] = self.parse_to_int(parsed[0] / durationInMs) * durationInMs
+            items = self.safe_value(data, 'items', [])
             self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {})
             stored = self.safe_value(self.ohlcvs[symbol], timeframe)
             if stored is None:
                 limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
                 stored = ArrayCacheByTimestamp(limit)
                 self.ohlcvs[symbol][timeframe] = stored
-            stored.append(parsed)
-            messageHash = table + ':' + marketId
-            client.resolve(stored, messageHash)
+            for i in range(0, len(items)):
+                candle = items[i]
+                parsed = self.parse_ohlcv(candle, market)
+                stored.append(parsed)
+            client.resolve(stored, channel)
 
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}):
         """
+        :see: https://developer-pro.bitmart.com/en/spot/#public-depth-all-channel
+        :see: https://developer-pro.bitmart.com/en/futures/#public-depth-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
         :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
         """
+        await self.load_markets()
         options = self.safe_value(self.options, 'watchOrderBook', {})
         depth = self.safe_string(options, 'depth', 'depth50')
-        orderbook = await self.subscribe(depth, symbol, params)
+        symbol = self.symbol(symbol)
+        market = self.market(symbol)
+        type = 'spot'
+        type, params = self.handle_market_type_and_params('watchOrderBook', market, params)
+        orderbook = await self.subscribe(depth, symbol, type, params)
         return orderbook.limit()
 
     def handle_delta(self, bookside, delta):
@@ -424,22 +1063,19 @@ class bitmart(ccxt.async_support.bitmart):
 
     def handle_order_book(self, client: Client, message):
         #
+        # spot
         #     {
         #         "data": [
         #             {
         #                 "asks": [
         #                     ['46828.38', "0.21847"],
         #                     ['46830.68', "0.08232"],
-        #                     ['46832.08', "0.09285"],
-        #                     ['46837.82', "0.02028"],
-        #                     ['46839.43', "0.15068"]
+        #                     ...
         #                 ],
         #                 "bids": [
         #                     ['46820.78', "0.00444"],
         #                     ['46814.33', "0.00234"],
-        #                     ['46813.50', "0.05021"],
-        #                     ['46808.14', "0.00217"],
-        #                     ['46808.04', "0.00013"]
+        #                     ...
         #                 ],
         #                 "ms_t": 1631044962431,
         #                 "symbol": "BTC_USDT"
@@ -447,30 +1083,89 @@ class bitmart(ccxt.async_support.bitmart):
         #         ],
         #         "table": "spot/depth5"
         #     }
+        # swap
+        #     {
+        #         "group":"futures/depth50:BTCUSDT",
+        #         "data":{
+        #            "symbol":"BTCUSDT",
+        #            "way":1,
+        #            "depths":[
+        #               {
+        #                  "price":"39509.8",
+        #                  "vol":"2379"
+        #               },
+        #               {
+        #                  "price":"39509.6",
+        #                  "vol":"6815"
+        #               },
+        #               ...
+        #            ],
+        #            "ms_t":1701566021194
+        #         }
+        #     }
         #
-        data = self.safe_value(message, 'data', [])
-        table = self.safe_string(message, 'table')
+        data = self.safe_value(message, 'data')
+        if data is None:
+            return
+        depths = self.safe_value(data, 'depths')
+        isSpot = (depths is None)
+        table = self.safe_string_2(message, 'table', 'group')
         parts = table.split('/')
         lastPart = self.safe_string(parts, 1)
         limitString = lastPart.replace('depth', '')
-        limit = int(limitString)
-        for i in range(0, len(data)):
-            update = data[i]
-            marketId = self.safe_string(update, 'symbol')
+        dotsIndex = limitString.find(':')
+        limitString = limitString[0:dotsIndex]
+        limit = self.parse_to_int(limitString)
+        if isSpot:
+            for i in range(0, len(data)):
+                update = data[i]
+                marketId = self.safe_string(update, 'symbol')
+                symbol = self.safe_symbol(marketId)
+                orderbook = self.safe_value(self.orderbooks, symbol)
+                if orderbook is None:
+                    orderbook = self.order_book({}, limit)
+                    orderbook['symbol'] = symbol
+                    self.orderbooks[symbol] = orderbook
+                orderbook.reset({})
+                self.handle_order_book_message(client, update, orderbook)
+                timestamp = self.safe_integer(update, 'ms_t')
+                orderbook['timestamp'] = timestamp
+                orderbook['datetime'] = self.iso8601(timestamp)
+                messageHash = table + ':' + marketId
+                client.resolve(orderbook, messageHash)
+        else:
+            marketId = self.safe_string(data, 'symbol')
             symbol = self.safe_symbol(marketId)
             orderbook = self.safe_value(self.orderbooks, symbol)
             if orderbook is None:
                 orderbook = self.order_book({}, limit)
+                orderbook['symbol'] = symbol
                 self.orderbooks[symbol] = orderbook
-            orderbook.reset({})
-            self.handle_order_book_message(client, update, orderbook)
-            messageHash = table + ':' + marketId
+            way = self.safe_number(data, 'way')
+            side = 'bids' if (way == 1) else 'asks'
+            if way == 1:
+                orderbook[side] = Bids([], limit)
+            else:
+                orderbook[side] = Asks([], limit)
+            for i in range(0, len(depths)):
+                depth = depths[i]
+                price = self.safe_number(depth, 'price')
+                amount = self.safe_number(depth, 'vol')
+                orderbookSide = self.safe_value(orderbook, side)
+                orderbookSide.store(price, amount)
+            bidsLength = len(orderbook['bids'])
+            asksLength = len(orderbook['asks'])
+            if (bidsLength == 0) or (asksLength == 0):
+                return
+            timestamp = self.safe_integer(data, 'ms_t')
+            orderbook['timestamp'] = timestamp
+            orderbook['datetime'] = self.iso8601(timestamp)
+            messageHash = table
             client.resolve(orderbook, messageHash)
-        return message
 
-    async def authenticate(self, params={}):
+    async def authenticate(self, type, params={}):
         self.check_required_credentials()
-        url = self.implode_hostname(self.urls['api']['ws']['private'])
+        url = self.implode_hostname(self.urls['api']['ws'][type]['private'])
         messageHash = 'authenticated'
         client = self.client(url)
         future = client.future(messageHash)
@@ -481,28 +1176,42 @@ class bitmart(ccxt.async_support.bitmart):
             path = 'bitmart.WebSocket'
             auth = timestamp + '#' + memo + '#' + path
             signature = self.hmac(self.encode(auth), self.encode(self.secret), hashlib.sha256)
-            operation = 'login'
-            request = {
-                'op': operation,
-                'args': [
-                    self.apiKey,
-                    timestamp,
-                    signature,
-                ],
-            }
+            request = None
+            if type == 'spot':
+                request = {
+                    'op': 'login',
+                    'args': [
+                        self.apiKey,
+                        timestamp,
+                        signature,
+                    ],
+                }
+            else:
+                request = {
+                    'action': 'access',
+                    'args': [
+                        self.apiKey,
+                        timestamp,
+                        signature,
+                        'web',
+                    ],
+                }
             message = self.extend(request, params)
             self.watch(url, messageHash, message, messageHash)
         return future
 
     def handle_subscription_status(self, client: Client, message):
         #
-        #     {"event":"subscribe","channel":"spot/depth:BTC-USDT"}
+        #    {"event":"subscribe","channel":"spot/depth:BTC-USDT"}
         #
         return message
 
     def handle_authenticate(self, client: Client, message):
         #
-        #     {event: "login"}
+        # spot
+        #    {event: "login"}
+        # swap
+        #    {action: 'access', success: True}
         #
         messageHash = 'authenticated'
         future = self.safe_value(client.futures, messageHash)
@@ -510,24 +1219,36 @@ class bitmart(ccxt.async_support.bitmart):
 
     def handle_error_message(self, client: Client, message):
         #
-        #     {event: "error", message: "Invalid sign", errorCode: 30013}
-        #     {"event":"error","message":"Unrecognized request: {\"event\":\"subscribe\",\"channel\":\"spot/depth:BTC-USDT\"}","errorCode":30039}
+        #    {event: "error", message: "Invalid sign", errorCode: 30013}
+        #    {"event":"error","message":"Unrecognized request: {\"event\":\"subscribe\",\"channel\":\"spot/depth:BTC-USDT\"}","errorCode":30039}
+        #    {
+        #        action: '',
+        #        group: 'futures/trade:BTCUSDT',
+        #        success: False,
+        #        request: {action: '', args: ['futures/trade:BTCUSDT']},
+        #        error: 'Invalid action [] for group [futures/trade:BTCUSDT]'
+        #    }
         #
         errorCode = self.safe_string(message, 'errorCode')
+        error = self.safe_string(message, 'error')
         try:
-            if errorCode is not None:
+            if errorCode is not None or error is not None:
                 feedback = self.id + ' ' + self.json(message)
                 self.throw_exactly_matched_exception(self.exceptions['exact'], errorCode, feedback)
-                messageString = self.safe_value(message, 'message')
-                if messageString is not None:
-                    self.throw_broadly_matched_exception(self.exceptions['broad'], messageString, feedback)
+                messageString = self.safe_value(message, 'message', error)
+                self.throw_broadly_matched_exception(self.exceptions['broad'], messageString, feedback)
+                action = self.safe_string(message, 'action')
+                if action == 'access':
+                    raise AuthenticationError(feedback)
+                raise ExchangeError(feedback)
             return False
         except Exception as e:
-            if isinstance(e, AuthenticationError):
+            if (isinstance(e, AuthenticationError)):
                 messageHash = 'authenticated'
                 client.reject(e, messageHash)
                 if messageHash in client.subscriptions:
                     del client.subscriptions[messageHash]
+            client.reject(e)
             return True
 
     def handle_message(self, client: Client, message):
@@ -558,14 +1279,14 @@ class bitmart(ccxt.async_support.bitmart):
         #
         #     {data: '', table: "spot/user/order"}
         #
-        table = self.safe_string(message, 'table')
-        if table is None:
-            event = self.safe_string(message, 'event')
+        channel = self.safe_string_2(message, 'table', 'group')
+        if channel is None:
+            event = self.safe_string_2(message, 'event', 'action')
             if event is not None:
                 methods = {
                     # 'info': self.handleSystemStatus,
-                    # 'book': 'handleOrderBook',
                     'login': self.handle_authenticate,
+                    'access': self.handle_authenticate,
                     'subscribe': self.handle_subscription_status,
                 }
                 method = self.safe_value(methods, event)
@@ -574,24 +1295,21 @@ class bitmart(ccxt.async_support.bitmart):
                 else:
                     return method(client, message)
         else:
-            parts = table.split('/')
-            name = self.safe_string(parts, 1)
             methods = {
-                'depth': self.handle_order_book,
                 'depth5': self.handle_order_book,
                 'depth20': self.handle_order_book,
                 'depth50': self.handle_order_book,
                 'ticker': self.handle_ticker,
                 'trade': self.handle_trade,
-                # ...
+                'kline': self.handle_ohlcv,
+                'order': self.handle_orders,
+                'position': self.handle_positions,
+                'balance': self.handle_balance,
+                'asset': self.handle_balance,
             }
-            method = self.safe_value(methods, name)
-            if name.find('kline') >= 0:
-                method = self.handle_ohlcv
-            privateName = self.safe_string(parts, 2)
-            if privateName == 'order':
-                method = self.handle_orders
-            if method is None:
-                return message
-            else:
-                return method(client, message)
+            keys = list(methods.keys())
+            for i in range(0, len(keys)):
+                key = keys[i]
+                if channel.find(key) >= 0:
+                    method = self.safe_value(methods, key)
+                    return method(client, message)