ccxt 4.4.82 → 4.4.85

package/js/src/pro/kraken.js

@@ -6,7 +6,7 @@
 
 //  ---------------------------------------------------------------------------
 import krakenRest from '../kraken.js';
-import { ExchangeError, BadSymbol, PermissionDenied, AccountSuspended, BadRequest, InsufficientFunds, InvalidOrder, OrderNotFound, NotSupported, RateLimitExceeded, ExchangeNotAvailable, ChecksumError, AuthenticationError } from '../base/errors.js';
+import { ExchangeError, BadSymbol, PermissionDenied, AccountSuspended, BadRequest, InsufficientFunds, InvalidOrder, OrderNotFound, NotSupported, RateLimitExceeded, ExchangeNotAvailable, ChecksumError, AuthenticationError, ArgumentsRequired } from '../base/errors.js';
 import { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById } from '../base/ws/Cache.js';
 import { Precise } from '../base/Precise.js';
 //  ---------------------------------------------------------------------------
@@ -112,11 +112,172 @@ export default class kraken extends krakenRest {
             },
         });
     }
+    orderRequestWs(method, symbol, type, request, amount, price = undefined, params = {}) {
+        const isLimitOrder = type.endsWith('limit'); // supporting limit, stop-loss-limit, take-profit-limit, etc
+        if (isLimitOrder) {
+            if (price === undefined) {
+                throw new ArgumentsRequired(this.id + ' limit orders require a price argument');
+            }
+            request['params']['limit_price'] = this.parseToNumeric(this.priceToPrecision(symbol, price));
+        }
+        const isMarket = (type === 'market');
+        let postOnly = undefined;
+        [postOnly, params] = this.handlePostOnly(isMarket, false, params);
+        if (postOnly) {
+            request['params']['post_only'] = true;
+        }
+        const clientOrderId = this.safeString(params, 'clientOrderId');
+        if (clientOrderId !== undefined) {
+            request['params']['cl_ord_id'] = clientOrderId;
+        }
+        const cost = this.safeString(params, 'cost');
+        if (cost !== undefined) {
+            request['params']['order_qty'] = this.parseToNumeric(this.costToPrecision(symbol, cost));
+        }
+        const stopLoss = this.safeDict(params, 'stopLoss', {});
+        const takeProfit = this.safeDict(params, 'takeProfit', {});
+        const presetStopLoss = this.safeString(stopLoss, 'triggerPrice');
+        const presetTakeProfit = this.safeString(takeProfit, 'triggerPrice');
+        const presetStopLossLimit = this.safeString(stopLoss, 'price');
+        const presetTakeProfitLimit = this.safeString(takeProfit, 'price');
+        const isPresetStopLoss = presetStopLoss !== undefined;
+        const isPresetTakeProfit = presetTakeProfit !== undefined;
+        const stopLossPrice = this.safeString(params, 'stopLossPrice');
+        const takeProfitPrice = this.safeString(params, 'takeProfitPrice');
+        const isStopLossPriceOrder = stopLossPrice !== undefined;
+        const isTakeProfitPriceOrder = takeProfitPrice !== undefined;
+        const trailingAmount = this.safeString(params, 'trailingAmount');
+        const trailingPercent = this.safeString(params, 'trailingPercent');
+        const trailingLimitAmount = this.safeString(params, 'trailingLimitAmount');
+        const trailingLimitPercent = this.safeString(params, 'trailingLimitPercent');
+        const isTrailingAmountOrder = trailingAmount !== undefined;
+        const isTrailingPercentOrder = trailingPercent !== undefined;
+        const isTrailingLimitAmountOrder = trailingLimitAmount !== undefined;
+        const isTrailingLimitPercentOrder = trailingLimitPercent !== undefined;
+        const offset = this.safeString(params, 'offset', ''); // can set this to - for minus
+        const trailingAmountString = (trailingAmount !== undefined) ? offset + this.numberToString(trailingAmount) : undefined;
+        const trailingPercentString = (trailingPercent !== undefined) ? offset + this.numberToString(trailingPercent) : undefined;
+        const trailingLimitAmountString = (trailingLimitAmount !== undefined) ? offset + this.numberToString(trailingLimitAmount) : undefined;
+        const trailingLimitPercentString = (trailingLimitPercent !== undefined) ? offset + this.numberToString(trailingLimitPercent) : undefined;
+        const priceType = (isTrailingPercentOrder || isTrailingLimitPercentOrder) ? 'pct' : 'quote';
+        if (method === 'createOrderWs') {
+            const reduceOnly = this.safeBool(params, 'reduceOnly');
+            if (reduceOnly) {
+                request['params']['reduce_only'] = true;
+            }
+            const timeInForce = this.safeStringLower(params, 'timeInForce');
+            if (timeInForce !== undefined) {
+                request['params']['time_in_force'] = timeInForce;
+            }
+            params = this.omit(params, ['reduceOnly', 'timeInForce']);
+            if (isStopLossPriceOrder || isTakeProfitPriceOrder || isTrailingAmountOrder || isTrailingPercentOrder || isTrailingLimitAmountOrder || isTrailingLimitPercentOrder) {
+                request['params']['triggers'] = {};
+            }
+            if (isPresetStopLoss || isPresetTakeProfit) {
+                request['params']['conditional'] = {};
+                if (isPresetStopLoss) {
+                    request['params']['conditional']['order_type'] = 'stop-loss';
+                    request['params']['conditional']['trigger_price'] = this.parseToNumeric(this.priceToPrecision(symbol, presetStopLoss));
+                }
+                else if (isPresetTakeProfit) {
+                    request['params']['conditional']['order_type'] = 'take-profit';
+                    request['params']['conditional']['trigger_price'] = this.parseToNumeric(this.priceToPrecision(symbol, presetTakeProfit));
+                }
+                if (presetStopLossLimit !== undefined) {
+                    request['params']['conditional']['order_type'] = 'stop-loss-limit';
+                    request['params']['conditional']['limit_price'] = this.parseToNumeric(this.priceToPrecision(symbol, presetStopLossLimit));
+                }
+                else if (presetTakeProfitLimit !== undefined) {
+                    request['params']['conditional']['order_type'] = 'take-profit-limit';
+                    request['params']['conditional']['limit_price'] = this.parseToNumeric(this.priceToPrecision(symbol, presetTakeProfitLimit));
+                }
+                params = this.omit(params, ['stopLoss', 'takeProfit']);
+            }
+            else if (isStopLossPriceOrder || isTakeProfitPriceOrder) {
+                if (isStopLossPriceOrder) {
+                    request['params']['triggers']['price'] = this.parseToNumeric(this.priceToPrecision(symbol, stopLossPrice));
+                    if (isLimitOrder) {
+                        request['params']['order_type'] = 'stop-loss-limit';
+                    }
+                    else {
+                        request['params']['order_type'] = 'stop-loss';
+                    }
+                }
+                else {
+                    request['params']['triggers']['price'] = this.parseToNumeric(this.priceToPrecision(symbol, takeProfitPrice));
+                    if (isLimitOrder) {
+                        request['params']['order_type'] = 'take-profit-limit';
+                    }
+                    else {
+                        request['params']['order_type'] = 'take-profit';
+                    }
+                }
+            }
+            else if (isTrailingAmountOrder || isTrailingPercentOrder || isTrailingLimitAmountOrder || isTrailingLimitPercentOrder) {
+                request['params']['triggers']['price_type'] = priceType;
+                if (!isLimitOrder && (isTrailingAmountOrder || isTrailingPercentOrder)) {
+                    request['params']['order_type'] = 'trailing-stop';
+                    if (isTrailingAmountOrder) {
+                        request['params']['triggers']['price'] = this.parseToNumeric(trailingAmountString);
+                    }
+                    else {
+                        request['params']['triggers']['price'] = this.parseToNumeric(trailingPercentString);
+                    }
+                }
+                else {
+                    // trailing limit orders are not conventionally supported because the static limit_price_type param is not available for trailing-stop-limit orders
+                    request['params']['limit_price_type'] = priceType;
+                    request['params']['order_type'] = 'trailing-stop-limit';
+                    if (isTrailingLimitAmountOrder) {
+                        request['params']['triggers']['price'] = this.parseToNumeric(trailingLimitAmountString);
+                    }
+                    else {
+                        request['params']['triggers']['price'] = this.parseToNumeric(trailingLimitPercentString);
+                    }
+                }
+            }
+        }
+        else if (method === 'editOrderWs') {
+            if (isPresetStopLoss || isPresetTakeProfit) {
+                throw new NotSupported(this.id + ' editing the stopLoss and takeProfit on existing orders is currently not supported');
+            }
+            if (isStopLossPriceOrder || isTakeProfitPriceOrder) {
+                if (isStopLossPriceOrder) {
+                    request['params']['trigger_price'] = this.parseToNumeric(this.priceToPrecision(symbol, stopLossPrice));
+                }
+                else {
+                    request['params']['trigger_price'] = this.parseToNumeric(this.priceToPrecision(symbol, takeProfitPrice));
+                }
+            }
+            else if (isTrailingAmountOrder || isTrailingPercentOrder || isTrailingLimitAmountOrder || isTrailingLimitPercentOrder) {
+                request['params']['trigger_price_type'] = priceType;
+                if (!isLimitOrder && (isTrailingAmountOrder || isTrailingPercentOrder)) {
+                    if (isTrailingAmountOrder) {
+                        request['params']['trigger_price'] = this.parseToNumeric(trailingAmountString);
+                    }
+                    else {
+                        request['params']['trigger_price'] = this.parseToNumeric(trailingPercentString);
+                    }
+                }
+                else {
+                    request['params']['limit_price_type'] = priceType;
+                    if (isTrailingLimitAmountOrder) {
+                        request['params']['trigger_price'] = this.parseToNumeric(trailingLimitAmountString);
+                    }
+                    else {
+                        request['params']['trigger_price'] = this.parseToNumeric(trailingLimitPercentString);
+                    }
+                }
+            }
+        }
+        params = this.omit(params, ['clientOrderId', 'cost', 'offset', 'stopLossPrice', 'takeProfitPrice', 'trailingAmount', 'trailingPercent', 'trailingLimitAmount', 'trailingLimitPercent']);
+        return [request, params];
+    }
     /**
      * @method
      * @name kraken#createOrderWs
-     * @see https://docs.kraken.com/api/docs/websocket-v1/addorder
      * @description create a trade order
+     * @see https://docs.kraken.com/api/docs/websocket-v2/add_order
      * @param {string} symbol unified symbol of the market to create an order in
      * @param {string} type 'market' or 'limit'
      * @param {string} side 'buy' or 'sell'
@@ -129,50 +290,60 @@ export default class kraken extends krakenRest {
         await this.loadMarkets();
         const token = await this.authenticate();
         const market = this.market(symbol);
-        const url = this.urls['api']['ws']['private'];
+        const url = this.urls['api']['ws']['privateV2'];
         const requestId = this.requestId();
         const messageHash = requestId;
         let request = {
-            'event': 'addOrder',
-            'token': token,
-            'reqid': requestId,
-            'ordertype': type,
-            'type': side,
-            'pair': market['wsId'],
-            'volume': this.amountToPrecision(symbol, amount),
+            'method': 'add_order',
+            'params': {
+                'order_type': type,
+                'side': side,
+                'order_qty': this.parseToNumeric(this.amountToPrecision(symbol, amount)),
+                'symbol': market['symbol'],
+                'token': token,
+            },
+            'req_id': requestId,
         };
-        [request, params] = this.orderRequest('createOrderWs', symbol, type, request, amount, price, params);
+        [request, params] = this.orderRequestWs('createOrderWs', symbol, type, request, amount, price, params);
         return await this.watch(url, messageHash, this.extend(request, params), messageHash);
     }
     handleCreateEditOrder(client, message) {
         //
         //  createOrder
-        //    {
-        //        "descr": "sell 0.00010000 XBTUSDT @ market",
-        //        "event": "addOrderStatus",
-        //        "reqid": 1,
-        //        "status": "ok",
-        //        "txid": "OAVXZH-XIE54-JCYYDG"
-        //    }
+        //     {
+        //         "method": "add_order",
+        //         "req_id": 1,
+        //         "result": {
+        //             "order_id": "OXM2QD-EALR2-YBAVEU"
+        //         },
+        //         "success": true,
+        //         "time_in": "2025-05-13T10:12:13.876173Z",
+        //         "time_out": "2025-05-13T10:12:13.890137Z"
+        //     }
+        //
         //  editOrder
-        //    {
-        //        "descr": "order edited price = 9000.00000000",
-        //        "event": "editOrderStatus",
-        //        "originaltxid": "O65KZW-J4AW3-VFS74A",
-        //        "reqid": 3,
-        //        "status": "ok",
-        //        "txid": "OTI672-HJFAO-XOIPPK"
-        //    }
+        //     {
+        //         "method": "amend_order",
+        //         "req_id": 1,
+        //         "result": {
+        //             "amend_id": "TYDLSQ-OYNYU-3MNRER",
+        //             "order_id": "OGL7HR-SWFO4-NRQTHO"
+        //         },
+        //         "success": true,
+        //         "time_in": "2025-05-14T13:54:10.840342Z",
+        //         "time_out": "2025-05-14T13:54:10.855046Z"
+        //     }
         //
-        const order = this.parseOrder(message);
-        const messageHash = this.safeValue(message, 'reqid');
+        const result = this.safeDict(message, 'result', {});
+        const order = this.parseOrder(result);
+        const messageHash = this.safeValue2(message, 'reqid', 'req_id');
         client.resolve(order, messageHash);
     }
     /**
      * @method
      * @name kraken#editOrderWs
      * @description edit a trade order
-     * @see https://docs.kraken.com/api/docs/websocket-v1/editorder
+     * @see https://docs.kraken.com/api/docs/websocket-v2/amend_order
      * @param {string} id order id
      * @param {string} symbol unified symbol of the market to create an order in
      * @param {string} type 'market' or 'limit'
@@ -185,21 +356,19 @@ export default class kraken extends krakenRest {
     async editOrderWs(id, symbol, type, side, amount = undefined, price = undefined, params = {}) {
         await this.loadMarkets();
         const token = await this.authenticate();
-        const market = this.market(symbol);
-        const url = this.urls['api']['ws']['private'];
+        const url = this.urls['api']['ws']['privateV2'];
         const requestId = this.requestId();
         const messageHash = requestId;
         let request = {
-            'event': 'editOrder',
-            'token': token,
-            'reqid': requestId,
-            'orderid': id,
-            'pair': market['wsId'],
+            'method': 'amend_order',
+            'params': {
+                'order_id': id,
+                'order_qty': this.parseToNumeric(this.amountToPrecision(symbol, amount)),
+                'token': token,
+            },
+            'req_id': requestId,
         };
-        if (amount !== undefined) {
-            request['volume'] = this.amountToPrecision(symbol, amount);
-        }
-        [request, params] = this.orderRequest('editOrderWs', symbol, type, request, amount, price, params);
+        [request, params] = this.orderRequestWs('editOrderWs', symbol, type, request, amount, price, params);
         return await this.watch(url, messageHash, this.extend(request, params), messageHash);
     }
     /**
@@ -208,21 +377,26 @@ export default class kraken extends krakenRest {
      * @see https://docs.kraken.com/api/docs/websocket-v1/cancelorder
      * @description cancel multiple orders
      * @param {string[]} ids order ids
-     * @param {string} symbol unified market symbol, default is undefined
+     * @param {string} [symbol] unified market symbol, default is undefined
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object} an list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
      */
     async cancelOrdersWs(ids, symbol = undefined, params = {}) {
+        if (symbol !== undefined) {
+            throw new NotSupported(this.id + ' cancelOrdersWs () does not support cancelling orders for a specific symbol.');
+        }
         await this.loadMarkets();
         const token = await this.authenticate();
-        const url = this.urls['api']['ws']['private'];
+        const url = this.urls['api']['ws']['privateV2'];
         const requestId = this.requestId();
         const messageHash = requestId;
         const request = {
-            'event': 'cancelOrder',
-            'token': token,
-            'reqid': requestId,
-            'txid': ids,
+            'method': 'cancel_order',
+            'params': {
+                'order_id': ids,
+                'token': token,
+            },
+            'req_id': requestId,
         };
         return await this.watch(url, messageHash, this.extend(request, params), messageHash);
     }
@@ -232,36 +406,43 @@ export default class kraken extends krakenRest {
      * @see https://docs.kraken.com/api/docs/websocket-v1/cancelorder
      * @description cancels an open order
      * @param {string} id order id
-     * @param {string} symbol unified symbol of the market the order was made in
+     * @param {string} [symbol] unified symbol of the market the order was made in
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
      */
     async cancelOrderWs(id, symbol = undefined, params = {}) {
+        if (symbol !== undefined) {
+            throw new NotSupported(this.id + ' cancelOrderWs () does not support cancelling orders for a specific symbol.');
+        }
         await this.loadMarkets();
         const token = await this.authenticate();
-        const url = this.urls['api']['ws']['private'];
+        const url = this.urls['api']['ws']['privateV2'];
         const requestId = this.requestId();
         const messageHash = requestId;
-        const clientOrderId = this.safeValue2(params, 'userref', 'clientOrderId', id);
-        params = this.omit(params, ['userref', 'clientOrderId']);
         const request = {
-            'event': 'cancelOrder',
-            'token': token,
-            'reqid': requestId,
-            'txid': [clientOrderId],
+            'method': 'cancel_order',
+            'params': {
+                'order_id': [id],
+                'token': token,
+            },
+            'req_id': requestId,
         };
         return await this.watch(url, messageHash, this.extend(request, params), messageHash);
     }
     handleCancelOrder(client, message) {
         //
-        //  success
-        //    {
-        //        "event": "cancelOrderStatus",
-        //        "status": "ok"
-        //        "reqid": 1,
-        //    }
+        //     {
+        //         "method": "cancel_order",
+        //         "req_id": 123456789,
+        //         "result": {
+        //             "order_id": "OKAGJC-YHIWK-WIOZWG"
+        //         },
+        //         "success": true,
+        //         "time_in": "2023-09-21T14:36:57.428972Z",
+        //         "time_out": "2023-09-21T14:36:57.437952Z"
+        //     }
         //
-        const reqId = this.safeValue(message, 'reqid');
+        const reqId = this.safeValue(message, 'req_id');
         client.resolve(message, reqId);
     }
     /**
@@ -269,7 +450,7 @@ export default class kraken extends krakenRest {
      * @name kraken#cancelAllOrdersWs
      * @see https://docs.kraken.com/api/docs/websocket-v1/cancelall
      * @description cancel all open orders
-     * @param {string} symbol unified market symbol, only orders in the market of this symbol are cancelled when symbol is not undefined
+     * @param {string} [symbol] unified market symbol, only orders in the market of this symbol are cancelled when symbol is not undefined
      * @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}
      */
@@ -279,26 +460,32 @@ export default class kraken extends krakenRest {
         }
         await this.loadMarkets();
         const token = await this.authenticate();
-        const url = this.urls['api']['ws']['private'];
+        const url = this.urls['api']['ws']['privateV2'];
         const requestId = this.requestId();
         const messageHash = requestId;
         const request = {
-            'event': 'cancelAll',
-            'token': token,
-            'reqid': requestId,
+            'method': 'cancel_all',
+            'params': {
+                'token': token,
+            },
+            'req_id': requestId,
         };
         return await this.watch(url, messageHash, this.extend(request, params), messageHash);
     }
     handleCancelAllOrders(client, message) {
         //
-        //    {
-        //        "count": 2,
-        //        "event": "cancelAllStatus",
-        //        "status": "ok",
-        //        "reqId": 1
-        //    }
+        //     {
+        //         "method": "cancel_all",
+        //         "req_id": 123456789,
+        //         "result": {
+        //             "count": 1
+        //         },
+        //         "success": true,
+        //         "time_in": "2023-09-21T14:36:57.428972Z",
+        //         "time_out": "2023-09-21T14:36:57.437952Z"
+        //     }
         //
-        const reqId = this.safeValue(message, 'reqid');
+        const reqId = this.safeValue(message, 'req_id');
         client.resolve(message, reqId);
     }
     handleTicker(client, message, subscription) {
@@ -891,6 +1078,20 @@ export default class kraken extends krakenRest {
         //         "version": "0.2.0"
         //     }
         //
+        // v2
+        //     {
+        //         channel: 'status',
+        //         type: 'update',
+        //         data: [
+        //             {
+        //                 version: '2.0.10',
+        //                 system: 'online',
+        //                 api_version: 'v2',
+        //                 connection_id: 6447481662169813000
+        //             }
+        //         ]
+        //     }
+        //
         return message;
     }
     async authenticate(params = {}) {
@@ -1520,9 +1721,18 @@ export default class kraken extends krakenRest {
         //         "subscription": { name: "ticker" }
         //     }
         //
-        const errorMessage = this.safeString(message, 'errorMessage');
+        // v2
+        //     {
+        //         "error": "Unsupported field: 'price' for the given msg type: add order",
+        //         "method": "add_order",
+        //         "success": false,
+        //         "time_in": "2025-05-13T08:59:44.803511Z",
+        //         "time_out": "2025-05-13T08:59:44.803542Z'
+        //     }
+        //
+        const errorMessage = this.safeString2(message, 'errorMessage', 'error');
         if (errorMessage !== undefined) {
-            const requestId = this.safeValue(message, 'reqid');
+            const requestId = this.safeValue2(message, 'reqid', 'req_id');
             if (requestId !== undefined) {
                 const broad = this.exceptions['ws']['broad'];
                 const broadKey = this.findBroadlyMatchedKey(broad, errorMessage);
@@ -1575,15 +1785,15 @@ export default class kraken extends krakenRest {
                 }
             }
             if (this.handleErrorMessage(client, message)) {
-                const event = this.safeString(message, 'event');
+                const event = this.safeString2(message, 'event', 'method');
                 const methods = {
                     'heartbeat': this.handleHeartbeat,
                     'systemStatus': this.handleSystemStatus,
                     'subscriptionStatus': this.handleSubscriptionStatus,
-                    'addOrderStatus': this.handleCreateEditOrder,
-                    'editOrderStatus': this.handleCreateEditOrder,
-                    'cancelOrderStatus': this.handleCancelOrder,
-                    'cancelAllStatus': this.handleCancelAllOrders,
+                    'add_order': this.handleCreateEditOrder,
+                    'amend_order': this.handleCreateEditOrder,
+                    'cancel_order': this.handleCancelOrder,
+                    'cancel_all': this.handleCancelAllOrders,
                 };
                 const method = this.safeValue(methods, event);
                 if (method !== undefined) {

package/js/src/pro/mexc.d.ts

@@ -138,6 +138,64 @@ export default class mexc extends mexcRest {
      */
     watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: Client, message: any): void;
+    /**
+     * @method
+     * @name mexc#unWatchTicker
+     * @description unWatches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+     * @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}
+     */
+    unWatchTicker(symbol: string, params?: {}): Promise<any>;
+    /**
+     * @method
+     * @name mexc#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
+     * @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}
+     */
+    unWatchTickers(symbols?: Strings, params?: {}): Promise<any>;
+    /**
+     * @method
+     * @name mexc#unWatchBidsAsks
+     * @description unWatches 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}
+     */
+    unWatchBidsAsks(symbols?: Strings, params?: {}): Promise<any>;
+    /**
+     * @method
+     * @name mexc#unWatchOHLCV
+     * @description unWatches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+     * @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
+     * @param {object} [params.timezone] if provided, kline intervals are interpreted in that timezone instead of UTC, example '+08:00'
+     * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
+     */
+    unWatchOHLCV(symbol: string, timeframe?: string, params?: {}): Promise<any>;
+    /**
+     * @method
+     * @name mexc#unWatchOrderBook
+     * @description unWatches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+     * @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
+     */
+    unWatchOrderBook(symbol: string, params?: {}): Promise<any>;
+    /**
+     * @method
+     * @name mexc#unWatchTrades
+     * @description unsubscribes from the trades channel
+     * @param {string} symbol unified symbol of the market to fetch trades for
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {string} [params.name] the name of the method to call, 'trade' or 'aggTrade', default is 'trade'
+     * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
+     */
+    unWatchTrades(symbol: string, params?: {}): Promise<any>;
+    handleUnsubscriptions(client: Client, messageHashes: string[]): void;
     authenticate(subscriptionHash: any, params?: {}): Promise<string>;
     keepAliveListenKey(listenKey: any, params?: {}): Promise<void>;
     handlePong(client: Client, message: any): any;