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

ccxt/pro/bithumb.py

@@ -5,7 +5,7 @@
 
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache
-from ccxt.base.types import Int, OrderBook, Strings, Ticker, Tickers, Trade
+from ccxt.base.types import Any, Bool, Int, OrderBook, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -13,7 +13,7 @@ from ccxt.base.errors import ExchangeError
 
 class bithumb(ccxt.async_support.bithumb):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(bithumb, self).describe(), {
             'has': {
                 'ws': True,
@@ -37,6 +37,9 @@ class bithumb(ccxt.async_support.bithumb):
     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://apidocs.bithumb.com/v1.2.0/reference/%EB%B9%97%EC%8D%B8-%EA%B1%B0%EB%9E%98%EC%86%8C-%EC%A0%95%EB%B3%B4-%EC%88%98%EC%8B%A0
+
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.channel]: the channel to subscribe to, tickers by default. Can be tickers, sprd-tickers, index-tickers, block-tickers
@@ -56,6 +59,9 @@ class bithumb(ccxt.async_support.bithumb):
     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://apidocs.bithumb.com/v1.2.0/reference/%EB%B9%97%EC%8D%B8-%EA%B1%B0%EB%9E%98%EC%86%8C-%EC%A0%95%EB%B3%B4-%EC%88%98%EC%8B%A0
+
         :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>`
@@ -165,6 +171,9 @@ class bithumb(ccxt.async_support.bithumb):
 
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
+
+        https://apidocs.bithumb.com/v1.2.0/reference/%EB%B9%97%EC%8D%B8-%EA%B1%B0%EB%9E%98%EC%86%8C-%EC%A0%95%EB%B3%B4-%EC%88%98%EC%8B%A0
+
         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
@@ -248,6 +257,9 @@ class bithumb(ccxt.async_support.bithumb):
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
+
+        https://apidocs.bithumb.com/v1.2.0/reference/%EB%B9%97%EC%8D%B8-%EA%B1%B0%EB%9E%98%EC%86%8C-%EC%A0%95%EB%B3%B4-%EC%88%98%EC%8B%A0
+
         :param str symbol: unified symbol of the market to fetch trades for
         :param int [since]: timestamp in ms of the earliest trade to fetch
         :param int [limit]: the maximum amount of trades to fetch
@@ -311,18 +323,20 @@ class bithumb(ccxt.async_support.bithumb):
         #        "contPrice" : "10579000",
         #        "contQty" : "0.01",
         #        "contAmt" : "105790.00",
-        #        "contDtm" : "2020-01-29 12:24:18.830039",
+        #        "contDtm" : "2020-01-29 12:24:18.830038",
         #        "updn" : "dn"
         #    }
         #
         marketId = self.safe_string(trade, 'symbol')
         datetime = self.safe_string(trade, 'contDtm')
+        # that date is not UTC iso8601, but exchange's local time, -9hr difference
+        timestamp = self.parse8601(datetime) - 32400000
         sideId = self.safe_string(trade, 'buySellGb')
         return self.safe_trade({
             'id': None,
             'info': trade,
-            'timestamp': self.parse8601(datetime),
-            'datetime': datetime,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
             'symbol': self.safe_symbol(marketId, market, '_'),
             'order': None,
             'type': None,
@@ -334,7 +348,7 @@ class bithumb(ccxt.async_support.bithumb):
             'fee': None,
         }, market)
 
-    def handle_error_message(self, client: Client, message):
+    def handle_error_message(self, client: Client, message) -> Bool:
         #
         #    {
         #        "status" : "5100",

ccxt/pro/bitmart.py

@@ -7,7 +7,7 @@ import ccxt.async_support
 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 Balances, Int, Market, Order, OrderBook, Position, Str, Strings, Ticker, Tickers, Trade
+from ccxt.base.types import Any, Balances, Bool, Int, Market, Order, OrderBook, Position, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -17,7 +17,7 @@ from ccxt.base.errors import NotSupported
 
 class bitmart(ccxt.async_support.bitmart):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(bitmart, self).describe(), {
             'has': {
                 'createOrderWs': False,
@@ -31,6 +31,7 @@ class bitmart(ccxt.async_support.bitmart):
                 'watchBalance': True,
                 'watchTicker': True,
                 'watchTickers': True,
+                'watchBidsAsks': True,
                 'watchOrderBook': True,
                 'watchOrderBookForSymbols': True,
                 'watchOrders': True,
@@ -48,8 +49,8 @@ class bitmart(ccxt.async_support.bitmart):
                             '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',
+                            'public': 'wss://openapi-ws-v2.{hostname}/api?protocol=1.1',
+                            'private': 'wss://openapi-ws-v2.{hostname}/user?protocol=1.1',
                         },
                     },
                 },
@@ -70,6 +71,9 @@ class bitmart(ccxt.async_support.bitmart):
                 'watchOrderBookForSymbols': {
                     'depth': 'depth/increase100',
                 },
+                'watchTrades': {
+                    'ignoreDuplicates': True,
+                },
                 'ws': {
                     'inflate': True,
                 },
@@ -107,6 +111,10 @@ class bitmart(ccxt.async_support.bitmart):
             }
         else:
             messageHash = 'futures/' + channel + ':' + market['id']
+            speed = self.safe_string(params, 'speed')
+            if speed is not None:
+                params = self.omit(params, 'speed')
+                messageHash += ':' + speed
             request = {
                 'action': 'subscribe',
                 'args': [messageHash],
@@ -126,8 +134,10 @@ class bitmart(ccxt.async_support.bitmart):
             rawSubscriptions.append(message)
             messageHashes.append(channel + ':' + market['symbol'])
         # exclusion, futures "tickers" need one generic request for all symbols
-        if (type != 'spot') and (channel == 'ticker'):
-            rawSubscriptions = [channelType + '/' + channel]
+        # if (type != 'spot') and (channel == 'ticker'):
+        #     rawSubscriptions = [channelType + '/' + channel]
+        # }
+        # Exchange update from 2025-02-11 supports subscription by trading pair for swap
         request: dict = {
             'args': rawSubscriptions,
         }
@@ -136,8 +146,10 @@ class bitmart(ccxt.async_support.bitmart):
 
     async def watch_balance(self, params={}) -> Balances:
         """
-        :see: https://developer-pro.bitmart.com/en/spot/#private-balance-change
-        :see: https://developer-pro.bitmart.com/en/futures/#private-assets-channel
+
+        https://developer-pro.bitmart.com/en/spot/#private-balance-change
+        https://developer-pro.bitmart.com/en/futuresv2/#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>`
@@ -256,8 +268,10 @@ class bitmart(ccxt.async_support.bitmart):
 
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
-        :see: https://developer-pro.bitmart.com/en/spot/#public-trade-channel
-        :see: https://developer-pro.bitmart.com/en/futures/#public-trade-channel
+
+        https://developer-pro.bitmart.com/en/spot/#public-trade-channel
+        https://developer-pro.bitmart.com/en/futuresv2/#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
@@ -269,7 +283,9 @@ class bitmart(ccxt.async_support.bitmart):
 
     async def watch_trades_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
-        :see: https://developer-pro.bitmart.com/en/spot/#public-trade-channel
+
+        https://developer-pro.bitmart.com/en/spot/#public-trade-channel
+
         get the list of most recent trades for a list of symbols
         :param str[] symbols: unified symbol of the market to fetch trades for
         :param int [since]: timestamp in ms of the earliest trade to fetch
@@ -286,7 +302,12 @@ class bitmart(ccxt.async_support.bitmart):
             first = self.safe_dict(trades, 0)
             tradeSymbol = self.safe_string(first, 'symbol')
             limit = trades.getLimit(tradeSymbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
+        result = self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
+        if self.handle_option('watchTrades', 'ignoreDuplicates', True):
+            filtered = self.remove_repeated_trades_from_array(result)
+            filtered = self.sort_by(filtered, 'timestamp')
+            return filtered
+        return result
 
     def get_params_for_multiple_sub(self, methodName: str, symbols: List[str], limit: Int = None, params={}):
         symbols = self.market_symbols(symbols, None, False, True)
@@ -300,7 +321,10 @@ class bitmart(ccxt.async_support.bitmart):
 
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
-        :see: https://developer-pro.bitmart.com/en/spot/#public-ticker-channel
+
+        https://developer-pro.bitmart.com/en/spot/#public-ticker-channel
+        https://developer-pro.bitmart.com/en/futuresv2/#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
@@ -313,7 +337,10 @@ class bitmart(ccxt.async_support.bitmart):
 
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
-        :see: https://developer-pro.bitmart.com/en/futures/#overview
+
+        https://developer-pro.bitmart.com/en/spot/#public-ticker-channel
+        https://developer-pro.bitmart.com/en/futuresv2/#public-ticker-channel
+
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
         :param str[] symbols: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -330,11 +357,84 @@ class bitmart(ccxt.async_support.bitmart):
             return tickers
         return self.filter_by_array(self.tickers, 'symbol', symbols)
 
+    async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+
+        https://developer-pro.bitmart.com/en/spot/#public-ticker-channel
+        https://developer-pro.bitmart.com/en/futuresv2/#public-ticker-channel
+
+        watches best bid & ask for symbols
+        :param str[] symbols: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        firstMarket = self.get_market_from_symbols(symbols)
+        marketType = None
+        marketType, params = self.handle_market_type_and_params('watchBidsAsks', firstMarket, params)
+        url = self.implode_hostname(self.urls['api']['ws'][marketType]['public'])
+        channelType = 'spot' if (marketType == 'spot') else 'futures'
+        actionType = 'op' if (marketType == 'spot') else 'action'
+        rawSubscriptions = []
+        messageHashes = []
+        for i in range(0, len(symbols)):
+            market = self.market(symbols[i])
+            rawSubscriptions.append(channelType + '/ticker:' + market['id'])
+            messageHashes.append('bidask:' + symbols[i])
+        if marketType != 'spot':
+            rawSubscriptions = [channelType + '/ticker']
+        request: dict = {
+            'args': rawSubscriptions,
+        }
+        request[actionType] = 'subscribe'
+        newTickers = await self.watch_multiple(url, messageHashes, request, rawSubscriptions)
+        if self.newUpdates:
+            tickers: dict = {}
+            tickers[newTickers['symbol']] = newTickers
+            return tickers
+        return self.filter_by_array(self.bidsasks, 'symbol', symbols)
+
+    def handle_bid_ask(self, client: Client, message):
+        table = self.safe_string(message, 'table')
+        isSpot = (table is not None)
+        rawTickers = []
+        if isSpot:
+            rawTickers = self.safe_list(message, 'data', [])
+        else:
+            rawTickers = [self.safe_value(message, 'data', {})]
+        if not len(rawTickers):
+            return
+        for i in range(0, len(rawTickers)):
+            ticker = self.parse_ws_bid_ask(rawTickers[i])
+            symbol = ticker['symbol']
+            self.bidsasks[symbol] = ticker
+            messageHash = 'bidask:' + symbol
+            client.resolve(ticker, messageHash)
+
+    def parse_ws_bid_ask(self, ticker, market=None):
+        marketId = self.safe_string(ticker, 'symbol')
+        market = self.safe_market(marketId, market)
+        symbol = self.safe_string(market, 'symbol')
+        timestamp = self.safe_integer(ticker, 'ms_t')
+        return self.safe_ticker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'ask': self.safe_string_2(ticker, 'ask_px', 'ask_price'),
+            'askVolume': self.safe_string_2(ticker, 'ask_sz', 'ask_vol'),
+            'bid': self.safe_string_2(ticker, 'bid_px', 'bid_price'),
+            'bidVolume': self.safe_string_2(ticker, 'bid_sz', 'bid_vol'),
+            'info': ticker,
+        }, market)
+
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         watches information on multiple orders made by the user
-        :see: https://developer-pro.bitmart.com/en/spot/#private-order-progress
-        :see: https://developer-pro.bitmart.com/en/futures/#private-order-channel
+
+        https://developer-pro.bitmart.com/en/spot/#private-order-progress
+        https://developer-pro.bitmart.com/en/futuresv2/#private-order-channel
+
         :param str symbol: unified market symbol of the market orders were made in
         :param int [since]: the earliest time in ms to fetch orders for
         :param int [limit]: the maximum number of order structures to retrieve
@@ -452,7 +552,7 @@ class bitmart(ccxt.async_support.bitmart):
             client.resolve(newOrders, symbolSpecificMessageHash)
         client.resolve(newOrders, messageHash)
 
-    def parse_ws_order(self, order, market: Market = None):
+    def parse_ws_order(self, order: dict, market: Market = None):
         #
         # spot
         #    {
@@ -604,9 +704,13 @@ class bitmart(ccxt.async_support.bitmart):
 
     async def watch_positions(self, symbols: Strings = None, since: Int = None, limit: Int = None, params={}) -> List[Position]:
         """
-        :see: https://developer-pro.bitmart.com/en/futures/#private-position-channel
+
+        https://developer-pro.bitmart.com/en/futures/#private-position-channel
+
         watch all open positions
         :param str[]|None symbols: list of unified market symbols
+        :param int [since]: the earliest time in ms to fetch positions
+        :param int [limit]: the maximum number of positions to retrieve
         :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>`
         """
@@ -707,8 +811,8 @@ class bitmart(ccxt.async_support.bitmart):
         symbol = market['symbol']
         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')
+        side = self.safe_integer(position, 'position_type')
+        marginModeId = self.safe_integer(position, 'open_type')
         return self.safe_position({
             'info': position,
             'id': None,
@@ -762,15 +866,12 @@ class bitmart(ccxt.async_support.bitmart):
         #        "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"
+        #              "created_at":"2023-12-03T15:48:23.517518538Z",
+        #              "m": True,
         #           }
         #        ]
         #    }
@@ -802,47 +903,61 @@ class bitmart(ccxt.async_support.bitmart):
         stored.append(trade)
         return symbol
 
-    def parse_ws_trade(self, trade, market: Market = None):
+    def parse_ws_trade(self, trade: dict, market: Market = None):
+        #
         # spot
-        #    {
-        #        "price": "52700.50",
-        #        "s_t": 1630982050,
-        #        "side": "buy",
-        #        "size": "0.00112",
-        #        "symbol": "BTC_USDT"
-        #    }
+        #     {
+        #         "ms_t": 1740320841473,
+        #         "price": "2806.54",
+        #         "s_t": 1740320841,
+        #         "side": "sell",
+        #         "size": "0.77598",
+        #         "symbol": "ETH_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"
-        #    }
+        #     {
+        #         "trade_id": "3000000245258661",
+        #         "symbol": "ETHUSDT",
+        #         "deal_price": "2811.1",
+        #         "deal_vol": "1858",
+        #         "way": 2,
+        #         "m": True,
+        #         "created_at": "2025-02-23T13:59:59.646490751Z"
+        #     }
         #
-        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')
+        market = self.safe_market(marketId, market)
+        timestamp = self.safe_integer(trade, 'ms_t')
+        datetime: Str = None
+        if timestamp is None:
+            datetime = self.safe_string(trade, 'created_at')
+            timestamp = self.parse8601(datetime)
+        else:
+            datetime = self.iso8601(timestamp)
+        takerOrMaker = None  # True for public trades
+        side = self.safe_string(trade, 'side')
+        buyerMaker = self.safe_bool(trade, 'm')
+        if buyerMaker is not None:
+            if side is None:
+                if buyerMaker:
+                    side = 'sell'
+                else:
+                    side = 'buy'
+            takerOrMaker = 'taker'
         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),
+            'datetime': datetime,
+            'symbol': market['symbol'],
             'type': None,
-            'side': self.safe_string(trade, 'side'),
+            'side': side,
             'price': self.safe_string_2(trade, 'price', 'deal_price'),
             'amount': self.safe_string_2(trade, 'size', 'deal_vol'),
             'cost': None,
-            'takerOrMaker': None,
+            'takerOrMaker': takerOrMaker,
             'fee': None,
         }, market)
 
@@ -862,21 +977,24 @@ class bitmart(ccxt.async_support.bitmart):
         #        ],
         #        "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"
-        #            }
-        #    }
         #
+        #     {
+        #         "data": {
+        #             "symbol": "ETHUSDT",
+        #             "last_price": "2807.73",
+        #             "volume_24": "2227011952",
+        #             "range": "0.0273398194664491",
+        #             "mark_price": "2807.5",
+        #             "index_price": "2808.71047619",
+        #             "ask_price": "2808.04",
+        #             "ask_vol": "7371",
+        #             "bid_price": "2807.28",
+        #             "bid_vol": "3561"
+        #         },
+        #         "group": "futures/ticker:ETHUSDT@100ms"
+        #     }
+        #
+        self.handle_bid_ask(client, message)
         table = self.safe_string(message, 'table')
         isSpot = (table is not None)
         rawTickers = []
@@ -895,17 +1013,19 @@ class bitmart(ccxt.async_support.bitmart):
 
     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"
-        #    }
+        #     {
+        #         "symbol": "ETHUSDT",
+        #         "last_price": "2807.73",
+        #         "volume_24": "2227011952",
+        #         "range": "0.0273398194664491",
+        #         "mark_price": "2807.5",
+        #         "index_price": "2808.71047619",
+        #         "ask_price": "2808.04",
+        #         "ask_vol": "7371",
+        #         "bid_price": "2807.28",
+        #         "bid_vol": "3561"
+        #     }
+        #
         marketId = self.safe_string(ticker, 'symbol')
         return self.safe_ticker({
             'symbol': self.safe_symbol(marketId, market, '', 'swap'),
@@ -924,16 +1044,20 @@ class bitmart(ccxt.async_support.bitmart):
             'previousClose': None,
             'change': None,
             'percentage': None,
-            'average': self.safe_string(ticker, 'fair_price'),
+            'average': None,
             'baseVolume': None,
             'quoteVolume': self.safe_string(ticker, 'volume_24'),
             'info': ticker,
+            'markPrice': self.safe_string(ticker, 'mark_price'),
+            'indexPrice': self.safe_string(ticker, 'index_price'),
         }, market)
 
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
-        :see: https://developer-pro.bitmart.com/en/spot/#public-kline-channel
-        :see: https://developer-pro.bitmart.com/en/futures/#public-klinebin-channel
+
+        https://developer-pro.bitmart.com/en/spot/#public-kline-channel
+        https://developer-pro.bitmart.com/en/futuresv2/#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
@@ -1047,13 +1171,16 @@ class bitmart(ccxt.async_support.bitmart):
 
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
-        :see: https://developer-pro.bitmart.com/en/spot/#public-depth-all-channel
-        :see: https://developer-pro.bitmart.com/en/spot/#public-depth-increase-channel
-        :see: https://developer-pro.bitmart.com/en/futures/#public-depth-channel
+
+        https://developer-pro.bitmart.com/en/spot/#public-depth-all-channel
+        https://developer-pro.bitmart.com/en/spot/#public-depth-increase-channel
+        https://developer-pro.bitmart.com/en/futuresv2/#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
+        :param str [params.speed]: *futures only* '100ms' or '200ms'
         :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
         """
         await self.load_markets()
@@ -1234,7 +1361,7 @@ class bitmart(ccxt.async_support.bitmart):
                 ob['symbol'] = symbol
                 self.orderbooks[symbol] = ob
             orderbook = self.orderbooks[symbol]
-            way = self.safe_number(data, 'way')
+            way = self.safe_integer(data, 'way')
             side = 'bids' if (way == 1) else 'asks'
             if way == 1:
                 orderbook[side] = Bids([], limit)
@@ -1262,7 +1389,9 @@ class bitmart(ccxt.async_support.bitmart):
     async def watch_order_book_for_symbols(self, symbols: List[str], limit: Int = None, params={}) -> OrderBook:
         """
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
-        :see: https://developer-pro.bitmart.com/en/spot/#public-depth-increase-channel
+
+        https://developer-pro.bitmart.com/en/spot/#public-depth-increase-channel
+
         :param str[] symbols: unified array of symbols
         :param int [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -1333,7 +1462,7 @@ class bitmart(ccxt.async_support.bitmart):
         future = self.safe_value(client.futures, messageHash)
         future.resolve(True)
 
-    def handle_error_message(self, client: Client, message):
+    def handle_error_message(self, client: Client, message) -> Bool:
         #
         #    {event: "error", message: "Invalid sign", errorCode: 30013}
         #    {"event":"error","message":"Unrecognized request: {\"event\":\"subscribe\",\"channel\":\"spot/depth:BTC-USDT\"}","errorCode":30039}