ccxt 4.5.27 → 4.5.29

package/dist/cjs/src/pro/bitmart.js

@@ -8,7 +8,7 @@ var Cache = require('../base/ws/Cache.js');
 var sha256 = require('../static_dependencies/noble-hashes/sha256.js');
 var OrderBookSide = require('../base/ws/OrderBookSide.js');
 
-//  ---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 //  ---------------------------------------------------------------------------
 class bitmart extends bitmart$1["default"] {
     describe() {
@@ -34,6 +34,16 @@ class bitmart extends bitmart$1["default"] {
                 'watchOHLCV': true,
                 'watchPosition': 'emulated',
                 'watchPositions': true,
+                'unWatchBidsAsks': false,
+                'unWatchOHLCV': true,
+                'unWatchOrderBook': true,
+                'unWatchOrderBookForSymbols': true,
+                'unWatchOrders': true,
+                'unWatchPositions': true,
+                'unWatchTicker': true,
+                'unWatchTickers': true,
+                'unWatchTrades': true,
+                'unWatchTradesForSymbols': true,
             },
             'urls': {
                 'api': {
@@ -97,10 +107,18 @@ class bitmart extends bitmart$1["default"] {
         const url = this.implodeHostname(this.urls['api']['ws'][type]['public']);
         let request = {};
         let messageHash = undefined;
+        const unsubscribe = this.safeBool(params, 'unsubscribe', false);
+        let prefix = '';
+        let requestOp = 'subscribe';
+        if (unsubscribe) {
+            params = this.omit(params, 'unsubscribe');
+            prefix = 'unsubscribe::';
+            requestOp = 'unsubscribe';
+        }
         if (type === 'spot') {
             messageHash = 'spot/' + channel + ':' + market['id'];
             request = {
-                'op': 'subscribe',
+                'op': requestOp,
                 'args': [messageHash],
             };
         }
@@ -112,10 +130,11 @@ class bitmart extends bitmart$1["default"] {
                 messageHash += ':' + speed;
             }
             request = {
-                'action': 'subscribe',
+                'action': requestOp,
                 'args': [messageHash],
             };
         }
+        messageHash = prefix + messageHash;
         return await this.watch(url, messageHash, this.deepExtend(request, params), messageHash);
     }
     async subscribeMultiple(channel, type, symbols = undefined, params = {}) {
@@ -125,11 +144,23 @@ class bitmart extends bitmart$1["default"] {
         const actionType = (type === 'spot') ? 'op' : 'action';
         const rawSubscriptions = [];
         const messageHashes = [];
+        const subHashes = [];
+        const unsubscribe = this.safeBool(params, 'unsubscribe', false);
+        let prefix = '';
+        let requestOp = 'subscribe';
+        if (unsubscribe) {
+            params = this.omit(params, 'unsubscribe');
+            prefix = 'unsubscribe::';
+            requestOp = 'unsubscribe';
+        }
         for (let i = 0; i < symbols.length; i++) {
             const market = this.market(symbols[i]);
             const message = channelType + '/' + channel + ':' + market['id'];
+            const subHash = prefix + message;
+            const messageHash = prefix + channel + ':' + market['symbol'];
             rawSubscriptions.push(message);
-            messageHashes.push(channel + ':' + market['symbol']);
+            subHashes.push(subHash);
+            messageHashes.push(messageHash);
         }
         // as an exclusion, futures "tickers" need one generic request for all symbols
         // if ((type !== 'spot') && (channel === 'ticker')) {
@@ -139,8 +170,8 @@ class bitmart extends bitmart$1["default"] {
         const request = {
             'args': rawSubscriptions,
         };
-        request[actionType] = 'subscribe';
-        return await this.watchMultiple(url, messageHashes, this.deepExtend(request, params), rawSubscriptions);
+        request[actionType] = requestOp;
+        return await this.watchMultiple(url, messageHashes, this.deepExtend(request, params), subHashes);
     }
     /**
      * @method
@@ -149,7 +180,7 @@ class bitmart extends bitmart$1["default"] {
      * @see https://developer-pro.bitmart.com/en/futuresv2/#private-assets-channel
      * @description watch balance and get the amount of funds available for trading or funds locked in orders
      * @param {object} [params] extra parameters specific to the exchange API endpoint
-     * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
+     * @returns {object} a [balance structure]{@link https://docs.ccxt.com/?id=balance-structure}
      */
     async watchBalance(params = {}) {
         await this.loadMarkets();
@@ -175,8 +206,8 @@ class bitmart extends bitmart$1["default"] {
         this.setBalanceCache(client, type, messageHash);
         let fetchBalanceSnapshot = undefined;
         let awaitBalanceSnapshot = undefined;
-        [fetchBalanceSnapshot, params] = this.handleOptionAndParams(this.options, 'watchBalance', 'fetchBalanceSnapshot', true);
-        [awaitBalanceSnapshot, params] = this.handleOptionAndParams(this.options, 'watchBalance', 'awaitBalanceSnapshot', false);
+        [fetchBalanceSnapshot, params] = this.handleOptionAndParams(params, 'watchBalance', 'fetchBalanceSnapshot', true);
+        [awaitBalanceSnapshot, params] = this.handleOptionAndParams(params, 'watchBalance', 'awaitBalanceSnapshot', false);
         if (fetchBalanceSnapshot && awaitBalanceSnapshot) {
             await client.future(type + ':fetchBalanceSnapshot');
         }
@@ -186,7 +217,7 @@ class bitmart extends bitmart$1["default"] {
         if (subscribeHash in client.subscriptions) {
             return;
         }
-        const options = this.safeValue(this.options, 'watchBalance');
+        const options = this.safeDict(this.options, 'watchBalance');
         const snapshot = this.safeBool(options, 'fetchBalanceSnapshot', true);
         if (snapshot) {
             const messageHash = type + ':' + 'fetchBalanceSnapshot';
@@ -252,7 +283,7 @@ class bitmart extends bitmart$1["default"] {
                 const timestamp = this.safeInteger(message, 'event_time');
                 this.balance[type]['timestamp'] = timestamp;
                 this.balance[type]['datetime'] = this.iso8601(timestamp);
-                const balanceDetails = this.safeValue(data[i], 'balance_details', []);
+                const balanceDetails = this.safeList(data[i], 'balance_details', []);
                 for (let ii = 0; ii < balanceDetails.length; ii++) {
                     const rawBalance = balanceDetails[i];
                     const account = this.account();
@@ -286,7 +317,7 @@ class bitmart extends bitmart$1["default"] {
      * @param {int} [since] timestamp in ms of the earliest trade to fetch
      * @param {int} [limit] the maximum amount of trades to fetch
      * @param {object} [params] extra parameters specific to the exchange API endpoint
-     * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
+     * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=public-trades}
      */
     async watchTrades(symbol, since = undefined, limit = undefined, params = {}) {
         return await this.watchTradesForSymbols([symbol], since, limit, params);
@@ -295,12 +326,13 @@ class bitmart extends bitmart$1["default"] {
      * @method
      * @name bitmart#watchTradesForSymbols
      * @see https://developer-pro.bitmart.com/en/spot/#public-trade-channel
+     * @see https://developer-pro.bitmart.com/en/futuresv2/#public-trade-channel
      * @description get the list of most recent trades for a list of symbols
      * @param {string[]} symbols 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
      * @param {object} [params] extra parameters specific to the exchange API endpoint
-     * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
+     * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=public-trades}
      */
     async watchTradesForSymbols(symbols, since = undefined, limit = undefined, params = {}) {
         await this.loadMarkets();
@@ -321,6 +353,37 @@ class bitmart extends bitmart$1["default"] {
         }
         return result;
     }
+    /**
+     * @method
+     * @name bitmart#unWatchTrades
+     * @description unWatches from the stream channel
+     * @see https://developer-pro.bitmart.com/en/spot/#public-trade-channel
+     * @see https://developer-pro.bitmart.com/en/futuresv2/#public-trade-channel
+     * @param {string} symbol unified symbol of the market to fetch trades for
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
+     */
+    async unWatchTrades(symbol, params = {}) {
+        return await this.unWatchTradesForSymbols([symbol], params);
+    }
+    /**
+     * @method
+     * @name bitmart#unWatchTradesForSymbols
+     * @description unsubscribes from the trades channel
+     * @see https://developer-pro.bitmart.com/en/spot/#public-trade-channel
+     * @see https://developer-pro.bitmart.com/en/futuresv2/#public-trade-channel
+     * @param {string[]} symbols unified symbol of the market to fetch trades for
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
+     */
+    async unWatchTradesForSymbols(symbols, params = {}) {
+        await this.loadMarkets();
+        let marketType = undefined;
+        [symbols, marketType, params] = this.getParamsForMultipleSub('unWatchTradesForSymbols', symbols, undefined, params);
+        const channelName = 'trade';
+        params = this.extend(params, { 'unsubscribe': true });
+        return await this.subscribeMultiple(channelName, marketType, symbols, params);
+    }
     getParamsForMultipleSub(methodName, symbols, limit = undefined, params = {}) {
         symbols = this.marketSymbols(symbols, undefined, false, true);
         const length = symbols.length;
@@ -340,7 +403,7 @@ class bitmart extends bitmart$1["default"] {
      * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
      * @param {string} symbol unified symbol of the market to fetch the ticker for
      * @param {object} [params] extra parameters specific to the exchange API endpoint
-     * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+     * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/?id=ticker-structure}
      */
     async watchTicker(symbol, params = {}) {
         await this.loadMarkets();
@@ -356,7 +419,7 @@ class bitmart extends bitmart$1["default"] {
      * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
      * @param {string[]} symbols unified symbol of the market to fetch the ticker for
      * @param {object} [params] extra parameters specific to the exchange API endpoint
-     * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+     * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/?id=ticker-structure}
      */
     async watchTickers(symbols = undefined, params = {}) {
         await this.loadMarkets();
@@ -371,6 +434,37 @@ class bitmart extends bitmart$1["default"] {
         }
         return this.filterByArray(this.tickers, 'symbol', symbols);
     }
+    /**
+     * @method
+     * @name bitmart#unWatchTicker
+     * @description unWatches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+     * @see https://developer-pro.bitmart.com/en/spot/#public-ticker-channel
+     * @see https://developer-pro.bitmart.com/en/futuresv2/#public-ticker-channel
+     * @param {string} symbol unified symbol of the market to fetch the ticker for
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+     */
+    async unWatchTicker(symbol, params = {}) {
+        return await this.unWatchTickers([symbol], params);
+    }
+    /**
+     * @method
+     * @name bitmart#unWatchTickers
+     * @description unWatches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+     * @see https://developer-pro.bitmart.com/en/spot/#public-ticker-channel
+     * @see https://developer-pro.bitmart.com/en/futuresv2/#public-ticker-channel
+     * @param {string[]} symbols unified symbol of the market to fetch the ticker for
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+     */
+    async unWatchTickers(symbols = undefined, params = {}) {
+        await this.loadMarkets();
+        const market = this.getMarketFromSymbols(symbols);
+        let marketType = undefined;
+        [marketType, params] = this.handleMarketTypeAndParams('watchTickers', market, params);
+        params = this.extend(params, { 'unsubscribe': true });
+        return await this.subscribeMultiple('ticker', marketType, symbols, params);
+    }
     /**
      * @method
      * @name bitmart#watchBidsAsks
@@ -379,7 +473,7 @@ class bitmart extends bitmart$1["default"] {
      * @description watches best bid & ask for symbols
      * @param {string[]} symbols unified symbol of the market to fetch the ticker for
      * @param {object} [params] extra parameters specific to the exchange API endpoint
-     * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+     * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/?id=ticker-structure}
      */
     async watchBidsAsks(symbols = undefined, params = {}) {
         await this.loadMarkets();
@@ -420,7 +514,7 @@ class bitmart extends bitmart$1["default"] {
             rawTickers = this.safeList(message, 'data', []);
         }
         else {
-            rawTickers = [this.safeValue(message, 'data', {})];
+            rawTickers = [this.safeDict(message, 'data', {})];
         }
         if (!rawTickers.length) {
             return;
@@ -459,7 +553,7 @@ class bitmart extends bitmart$1["default"] {
      * @param {int} [since] the earliest time in ms to fetch orders for
      * @param {int} [limit] the maximum number of order structures to retrieve
      * @param {object} [params] extra parameters specific to the exchange API endpoint
-     * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+     * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/?id=order-structure}
      */
     async watchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         await this.loadMarkets();
@@ -500,6 +594,54 @@ class bitmart extends bitmart$1["default"] {
         }
         return this.filterBySymbolSinceLimit(this.orders, symbol, since, limit, true);
     }
+    /**
+     * @method
+     * @name bitmart#unWatchOrders
+     * @description unWatches 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/futuresv2/#private-order-channel
+     * @param {string} symbol unified market symbol of the market orders were made in
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+     */
+    async unWatchOrders(symbol = undefined, params = {}) {
+        await this.loadMarkets();
+        let market = undefined;
+        let messageHash = 'unsubscribe::orders';
+        if (symbol !== undefined) {
+            symbol = this.symbol(symbol);
+            market = this.market(symbol);
+            if (market['swap']) {
+                throw new errors.NotSupported(this.id + ' unWatchOrders() does not support a symbol for swap markets, unWatch from all markets only');
+            }
+            messageHash += '::' + symbol;
+        }
+        let type = 'spot';
+        [type, params] = this.handleMarketTypeAndParams('watchOrders', market, params);
+        await this.authenticate(type, params);
+        let request = undefined;
+        if (type === 'spot') {
+            let argsRequest = 'spot/user/order:';
+            if (symbol !== undefined) {
+                argsRequest += market['id'];
+            }
+            else {
+                argsRequest = 'spot/user/orders:ALL_SYMBOLS';
+            }
+            request = {
+                'op': 'unsubscribe',
+                'args': [argsRequest],
+            };
+        }
+        else {
+            request = {
+                'action': 'unsubscribe',
+                'args': ['futures/order'],
+            };
+        }
+        const url = this.implodeHostname(this.urls['api']['ws'][type]['private']);
+        return await this.watch(url, messageHash, this.deepExtend(request, params), messageHash);
+    }
     handleOrders(client, message) {
         //
         // spot
@@ -554,7 +696,7 @@ class bitmart extends bitmart$1["default"] {
         //        ]
         //    }
         //
-        const orders = this.safeValue(message, 'data');
+        const orders = this.safeList(message, 'data');
         if (orders === undefined) {
             return;
         }
@@ -670,13 +812,13 @@ class bitmart extends bitmart$1["default"] {
             }, market);
         }
         else {
-            const orderInfo = this.safeValue(order, 'order');
+            const orderInfo = this.safeDict(order, 'order');
             const marketId = this.safeString(orderInfo, 'symbol');
             const symbol = this.safeSymbol(marketId, market, '', 'swap');
             const orderId = this.safeString(orderInfo, 'order_id');
             const timestamp = this.safeInteger(orderInfo, 'create_time');
             const updatedTimestamp = this.safeInteger(orderInfo, 'update_time');
-            const lastTrade = this.safeValue(orderInfo, 'last_trade');
+            const lastTrade = this.safeDict(orderInfo, 'last_trade');
             const cachedOrders = this.orders;
             const orders = this.safeValue(cachedOrders.hashmap, symbol, {});
             const cachedOrder = this.safeValue(orders, orderId);
@@ -771,6 +913,31 @@ class bitmart extends bitmart$1["default"] {
         }
         return this.filterBySymbolsSinceLimit(this.positions, symbols, since, limit);
     }
+    /**
+     * @method
+     * @name bitmart#unWatchPositions
+     * @description unWatches all open positions
+     * @see https://developer-pro.bitmart.com/en/futures/#private-position-channel
+     * @param {string[]} [symbols] list of unified market symbols
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {object} status of the unwatch request
+     */
+    async unWatchPositions(symbols = undefined, params = {}) {
+        if (symbols !== undefined) {
+            const length = symbols.length;
+            if (length > 0) {
+                throw new errors.NotSupported(this.id + ' unWatchPositions() does not support a list of symbols, unWatch from all markets only');
+            }
+        }
+        await this.loadMarkets();
+        const request = {
+            'action': 'unsubscribe',
+            'args': ['futures/position'],
+        };
+        const messageHash = 'unsubscribe::positions';
+        const url = this.implodeHostname(this.urls['api']['ws']['swap']['private']);
+        return await this.watch(url, messageHash, this.deepExtend(request, params), messageHash);
+    }
     handlePositions(client, message) {
         //
         //    {
@@ -807,7 +974,7 @@ class bitmart extends bitmart$1["default"] {
         //        ]
         //    }
         //
-        const data = this.safeValue(message, 'data', []);
+        const data = this.safeList(message, 'data', []);
         if (this.positions === undefined) {
             this.positions = new Cache.ArrayCacheBySymbolBySide();
         }
@@ -919,7 +1086,7 @@ class bitmart extends bitmart$1["default"] {
         //        ]
         //    }
         //
-        const data = this.safeValue(message, 'data');
+        const data = this.safeList(message, 'data');
         if (data === undefined) {
             return;
         }
@@ -1057,7 +1224,7 @@ class bitmart extends bitmart$1["default"] {
             rawTickers = this.safeList(message, 'data', []);
         }
         else {
-            rawTickers = [this.safeValue(message, 'data', {})];
+            rawTickers = [this.safeDict(message, 'data', {})];
         }
         if (!rawTickers.length) {
             return;
@@ -1129,8 +1296,8 @@ class bitmart extends bitmart$1["default"] {
         symbol = this.symbol(symbol);
         const market = this.market(symbol);
         let type = 'spot';
-        [type, params] = this.handleMarketTypeAndParams('watchOrderBook', market, params);
-        const timeframes = this.safeValue(this.options, 'timeframes', {});
+        [type, params] = this.handleMarketTypeAndParams('watchOHLCV', market, params);
+        const timeframes = this.safeDict(this.options, 'timeframes', {});
         const interval = this.safeString(timeframes, timeframe);
         let name = undefined;
         if (type === 'spot') {
@@ -1145,6 +1312,35 @@ class bitmart extends bitmart$1["default"] {
         }
         return this.filterBySinceLimit(ohlcv, since, limit, 0, true);
     }
+    /**
+     * @method
+     * @name bitmart#unWatchOHLCV
+     * @description unWatches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+     * @see https://developer-pro.bitmart.com/en/spot/#public-kline-channel
+     * @see https://developer-pro.bitmart.com/en/futuresv2/#public-klinebin-channel
+     * @param {string} symbol unified symbol of the market to fetch OHLCV data for
+     * @param {string} timeframe the length of time each candle represents
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
+     */
+    async unWatchOHLCV(symbol, timeframe = '1m', params = {}) {
+        await this.loadMarkets();
+        symbol = this.symbol(symbol);
+        const market = this.market(symbol);
+        let type = 'spot';
+        [type, params] = this.handleMarketTypeAndParams('unWatchOHLCV', market, params);
+        const timeframes = this.safeDict(this.options, 'timeframes', {});
+        const interval = this.safeString(timeframes, timeframe);
+        let name = undefined;
+        if (type === 'spot') {
+            name = 'kline' + interval;
+        }
+        else {
+            name = 'klineBin' + interval;
+        }
+        params = this.extend(params, { 'unsubscribe': true });
+        return await this.subscribe(name, symbol, type, params);
+    }
     handleOHLCV(client, message) {
         //
         //    {
@@ -1194,7 +1390,7 @@ class bitmart extends bitmart$1["default"] {
         const intervalParts = interval.split(':');
         interval = this.safeString(intervalParts, 0);
         // use a reverse lookup in a static map instead
-        const timeframes = this.safeValue(this.options, 'timeframes', {});
+        const timeframes = this.safeDict(this.options, 'timeframes', {});
         const timeframe = this.findTimeframe(interval, timeframes);
         const duration = this.parseTimeframe(timeframe);
         const durationInMs = duration * 1000;
@@ -1203,7 +1399,7 @@ class bitmart extends bitmart$1["default"] {
                 const marketId = this.safeString(data[i], 'symbol');
                 const market = this.safeMarket(marketId);
                 const symbol = market['symbol'];
-                const rawOHLCV = this.safeValue(data[i], 'candle');
+                const rawOHLCV = this.safeList(data[i], 'candle');
                 const parsed = this.parseOHLCV(rawOHLCV, market);
                 parsed[0] = this.parseToInt(parsed[0] / durationInMs) * durationInMs;
                 this.ohlcvs[symbol] = this.safeValue(this.ohlcvs, symbol, {});
@@ -1222,7 +1418,7 @@ class bitmart extends bitmart$1["default"] {
             const marketId = this.safeString(data, 'symbol');
             const market = this.safeMarket(marketId, undefined, undefined, 'swap');
             const symbol = market['symbol'];
-            const items = this.safeValue(data, 'items', []);
+            const items = this.safeList(data, 'items', []);
             this.ohlcvs[symbol] = this.safeValue(this.ohlcvs, symbol, {});
             let stored = this.safeValue(this.ohlcvs[symbol], timeframe);
             if (stored === undefined) {
@@ -1249,11 +1445,11 @@ class bitmart extends bitmart$1["default"] {
      * @param {int} [limit] the maximum amount of order book entries to return
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @param {string} [params.speed] *futures only* '100ms' or '200ms'
-     * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
+     * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/?id=order-book-structure} indexed by market symbols
      */
     async watchOrderBook(symbol, limit = undefined, params = {}) {
         await this.loadMarkets();
-        const options = this.safeValue(this.options, 'watchOrderBook', {});
+        const options = this.safeDict(this.options, 'watchOrderBook', {});
         let depth = this.safeString(options, 'depth', 'depth/increase100');
         symbol = this.symbol(symbol);
         const market = this.market(symbol);
@@ -1265,6 +1461,31 @@ class bitmart extends bitmart$1["default"] {
         const orderbook = await this.subscribe(depth, symbol, type, params);
         return orderbook.limit();
     }
+    /**
+     * @method
+     * @name bitmart#unWatchOrderBook
+     * @description unWatches 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-all-channel
+     * @see https://developer-pro.bitmart.com/en/spot/#public-depth-increase-channel
+     * @see https://developer-pro.bitmart.com/en/futuresv2/#public-depth-channel
+     * @param {string} symbol unified array of symbols
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
+     */
+    async unWatchOrderBook(symbol, params = {}) {
+        await this.loadMarkets();
+        const options = this.safeDict(this.options, 'watchOrderBook', {});
+        let depth = this.safeString(options, 'depth', 'depth/increase100');
+        symbol = this.symbol(symbol);
+        const market = this.market(symbol);
+        let type = 'spot';
+        [type, params] = this.handleMarketTypeAndParams('unWatchOrderBook', market, params);
+        if (type === 'swap' && depth === 'depth/increase100') {
+            depth = 'depth50';
+        }
+        params = this.extend(params, { 'unsubscribe': true });
+        return await this.subscribe(depth, symbol, type, params);
+    }
     handleDelta(bookside, delta) {
         const price = this.safeFloat(delta, 0);
         const amount = this.safeFloat(delta, 1);
@@ -1483,7 +1704,7 @@ class bitmart extends bitmart$1["default"] {
      * @param {int} [limit] the maximum amount of order book entries to return
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @param {string} [params.depth] the type of order book to subscribe to, default is 'depth/increase100', also accepts 'depth5' or 'depth20' or depth50
-     * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
+     * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/?id=order-book-structure} indexed by market symbols
      */
     async watchOrderBookForSymbols(symbols, limit = undefined, params = {}) {
         await this.loadMarkets();
@@ -1497,6 +1718,28 @@ class bitmart extends bitmart$1["default"] {
         const orderbook = await this.subscribeMultiple(channel, type, symbols, params);
         return orderbook.limit();
     }
+    /**
+     * @method
+     * @name bitmart#unWatchOrderBookForSymbols
+     * @description unWatches 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
+     * @param {string[]} symbols unified array of symbols
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {string} [params.depth] the type of order book to subscribe to, default is 'depth/increase100', also accepts 'depth5' or 'depth20' or depth50
+     * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
+     */
+    async unWatchOrderBookForSymbols(symbols, params = {}) {
+        await this.loadMarkets();
+        let type = undefined;
+        [symbols, type, params] = this.getParamsForMultipleSub('unWatchOrderBookForSymbols', symbols, undefined, params);
+        let channel = undefined;
+        [channel, params] = this.handleOptionAndParams(params, 'unWatchOrderBookForSymbols', 'depth', 'depth/increase100');
+        if (type === 'swap' && channel === 'depth/increase100') {
+            channel = 'depth50';
+        }
+        params = this.extend(params, { 'unsubscribe': true });
+        return await this.subscribeMultiple(channel, type, symbols, params);
+    }
     async authenticate(type, params = {}) {
         this.checkRequiredCredentials();
         const url = this.implodeHostname(this.urls['api']['ws'][type]['private']);
@@ -1594,6 +1837,119 @@ class bitmart extends bitmart$1["default"] {
             return true;
         }
     }
+    handleUnSubscription(client, message) {
+        //
+        // spot
+        //     {
+        //         "topic": "spot/ticker:ETH_USDT",
+        //         "event": "unsubscribe"
+        //     }
+        //
+        // swap
+        //     {
+        //         "action": "unsubscribe",
+        //         "group": "futures/ticker:ETHUSDT",
+        //         "success": true,
+        //         "request": {
+        //             "action": "unsubscribe",
+        //             "args": [
+        //                 "futures/ticker:ETHUSDT"
+        //             ]
+        //         }
+        //     }
+        //
+        const messageTopic = this.safeString2(message, 'topic', 'group');
+        const unSubMessageTopic = 'unsubscribe::' + messageTopic;
+        // one message includes info about one unsubscription only even if we requested multiple
+        // so we can not just create subscription object in unWatch method and use it here
+        // we need to reconstruct subscription params from the messageTopic
+        const subscription = this.getUnSubParams(messageTopic);
+        const subHash = this.safeString(subscription, 'subHash');
+        const unsubHash = 'unsubscribe::' + subHash;
+        const subHashIsPrefix = this.safeBool(subscription, 'subHashIsPrefix', false);
+        // clean up both ways of storing subscription and unsubscription
+        this.cleanUnsubscription(client, subHash, unsubHash, subHashIsPrefix);
+        this.cleanUnsubscription(client, messageTopic, unSubMessageTopic, subHashIsPrefix);
+        this.cleanCache(subscription);
+    }
+    getUnSubParams(messageTopic) {
+        const parts = messageTopic.split(':');
+        const channel = this.safeString(parts, 0);
+        const marketTypeAndTopic = channel.split('/');
+        const rawMarketType = this.safeStringLower(marketTypeAndTopic, 0);
+        const marketType = this.parseMarketType(rawMarketType);
+        let topic = this.safeString(marketTypeAndTopic, 1);
+        const thirdPart = this.safeString(marketTypeAndTopic, 2);
+        if (thirdPart !== undefined) {
+            topic += '/' + thirdPart;
+        }
+        const marketId = this.safeString(parts, 1);
+        const symbols = [];
+        let symbol = undefined;
+        let subHash = topic;
+        let hashDelimiter = ':';
+        let subHashIsPrefix = false;
+        const parsedTopic = this.parseTopic(topic);
+        if ((parsedTopic === 'orders') || (parsedTopic === 'positions')) {
+            subHash = parsedTopic;
+            hashDelimiter = '::';
+        }
+        if ((marketId !== undefined) && (marketId !== 'ALL_SYMBOLS')) {
+            // if marketId is defined, we have a single symbol subscription
+            const delimiter = (marketType === 'spot') ? '_' : '';
+            const market = this.safeMarket(marketId, undefined, delimiter, marketType);
+            symbol = market['symbol'];
+            subHash += hashDelimiter + symbol;
+            symbols.push(symbol);
+        }
+        else {
+            subHashIsPrefix = true; // need to clean all subHashes with this prefix
+        }
+        const symbolsAndTimeframes = [];
+        if (topic.startsWith('kline')) {
+            let interval = topic.replace('kline', '');
+            if (interval.startsWith('Bin')) {
+                // swap market
+                interval = interval.replace('Bin', '');
+            }
+            const timeframes = this.safeDict(this.options, 'timeframes', {});
+            const timeframe = this.findTimeframe(interval, timeframes);
+            const symbolAndTimeframe = [symbol, timeframe];
+            symbolsAndTimeframes.push(symbolAndTimeframe);
+        }
+        const result = {
+            'topic': parsedTopic,
+            'symbols': symbols,
+            'subHash': subHash,
+            'symbolsAndTimeframes': symbolsAndTimeframes,
+            'subHashIsPrefix': subHashIsPrefix,
+        };
+        return result;
+    }
+    parseTopic(topic) {
+        if (topic.startsWith('depth')) {
+            return 'orderbook';
+        }
+        if (topic.startsWith('kline')) {
+            return 'ohlcv';
+        }
+        const topics = {
+            'ticker': 'ticker',
+            'trade': 'trades',
+            'user/order': 'orders',
+            'user/orders': 'orders',
+            'order': 'orders',
+            'position': 'positions',
+        };
+        return this.safeString(topics, topic, topic);
+    }
+    parseMarketType(marketType) {
+        const types = {
+            'spot': 'spot',
+            'futures': 'swap',
+        };
+        return this.safeString(types, marketType, marketType);
+    }
     handleMessage(client, message) {
         if (this.handleErrorMessage(client, message)) {
             return;
@@ -1653,6 +2009,7 @@ class bitmart extends bitmart$1["default"] {
                     'login': this.handleAuthenticate,
                     'access': this.handleAuthenticate,
                     'subscribe': this.handleSubscriptionStatus,
+                    'unsubscribe': this.handleUnSubscription,
                 };
                 const method = this.safeValue(methods, event);
                 if (method !== undefined) {