ccxt 4.3.40 → 4.3.42

package/js/src/binance.js

@@ -239,6 +239,9 @@ export default class binance extends Exchange {
                     // UID (sapi) request rate limit of 180 000 per minute
                     // 1 UID (sapi) => cost = 0.006667 => (1000 / (50 * 0.006667)) * 60 = 180000
                     'get': {
+                        // copy trading
+                        'copyTrading/futures/userStatus': 2,
+                        'copyTrading/futures/leadSymbol': 2,
                         'system/status': 0.1,
                         // these endpoints require this.apiKey
                         'accountSnapshot': 240,

package/js/src/bitfinex2.js

@@ -1724,7 +1724,7 @@ export default class bitfinex2 extends Exchange {
         }
         const orders = this.safeList(response, 4, []);
         const order = this.safeList(orders, 0);
-        return this.parseOrder(order, market);
+        return this.parseOrder(this.extend({ 'result': order }), market);
     }
     async createOrders(orders, params = {}) {
         /**

package/js/src/bithumb.d.ts

@@ -24,8 +24,8 @@ export default class bithumb extends Exchange {
     parseOrderStatus(status: Str): string;
     parseOrder(order: Dict, market?: Market): Order;
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    cancelOrder(id: string, symbol?: Str, params?: {}): Promise<any>;
-    cancelUnifiedOrder(order: any, params?: {}): Promise<any>;
+    cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
+    cancelUnifiedOrder(order: any, params?: {}): Promise<Order>;
     withdraw(code: string, amount: number, address: string, tag?: any, params?: {}): Promise<Transaction>;
     parseTransaction(transaction: Dict, currency?: Currency): Transaction;
     fixCommaNumber(numberStr: any): any;

package/js/src/bithumb.js

@@ -969,7 +969,15 @@ export default class bithumb extends Exchange {
             'order_currency': market['base'],
             'payment_currency': market['quote'],
         };
-        return await this.privatePostTradeCancel(this.extend(request, params));
+        const response = await this.privatePostTradeCancel(this.extend(request, params));
+        //
+        //    {
+        //       'status': 'string',
+        //    }
+        //
+        return this.safeOrder({
+            'info': response,
+        });
     }
     async cancelUnifiedOrder(order, params = {}) {
         const request = {

package/js/src/bitmart.js

@@ -1130,27 +1130,46 @@ export default class bitmart extends Exchange {
     }
     parseTicker(ticker, market = undefined) {
         //
-        // spot (REST)
+        // spot (REST) fetchTickers
         //
-        //      {
-        //          "symbol": "SOLAR_USDT",
-        //          "last_price": "0.020342",
-        //          "quote_volume_24h": "56817.811802",
-        //          "base_volume_24h": "2172060",
-        //          "high_24h": "0.256000",
-        //          "low_24h": "0.016980",
-        //          "open_24h": "0.022309",
-        //          "close_24h": "0.020342",
-        //          "best_ask": "0.020389",
-        //          "best_ask_size": "339.000000000000000000000000000000",
-        //          "best_bid": "0.020342",
-        //          "best_bid_size": "3369.000000000000000000000000000000",
-        //          "fluctuation": "-0.0882",
-        //          "url": "https://www.bitmart.com/trade?symbol=SOLAR_USDT",
-        //          "timestamp": 1667403439367
-        //      }
+        //     {
+        //         'result': [
+        //             "AFIN_USDT",     // symbol
+        //             "0.001047",      // last
+        //             "11110",         // v_24h
+        //             "11.632170",     // qv_24h
+        //             "0.001048",      // open_24h
+        //             "0.001048",      // high_24h
+        //             "0.001047",      // low_24h
+        //             "-0.00095",      // price_change_24h
+        //             "0.001029",      // bid_px
+        //             "5555",          // bid_sz
+        //             "0.001041",      // ask_px
+        //             "5297",          // ask_sz
+        //             "1717122550482"  // timestamp
+        //         ]
+        //     }
+        //
+        // spot (REST) fetchTicker
+        //
+        //     {
+        //         "symbol": "BTC_USDT",
+        //         "last": "68500.00",
+        //         "v_24h": "10491.65490",
+        //         "qv_24h": "717178990.42",
+        //         "open_24h": "68149.75",
+        //         "high_24h": "69499.99",
+        //         "low_24h": "67132.40",
+        //         "fluctuation": "0.00514",
+        //         "bid_px": "68500",
+        //         "bid_sz": "0.00162",
+        //         "ask_px": "68500.01",
+        //         "ask_sz": "0.01722",
+        //         "ts": "1717131391671"
+        //     }
         //
         // spot (WS)
+        //
         //      {
         //          "symbol":"BTC_USDT",
         //          "last_price":"146.24",
@@ -1176,21 +1195,47 @@ export default class bitmart extends Exchange {
         //          "legal_coin_price":"0.1302699"
         //      }
         //
-        let timestamp = this.safeInteger(ticker, 'timestamp');
+        const result = this.safeList(ticker, 'result', []);
+        const average = this.safeString2(ticker, 'avg_price', 'index_price');
+        let marketId = this.safeString2(ticker, 'symbol', 'contract_symbol');
+        let timestamp = this.safeInteger2(ticker, 'timestamp', 'ts');
+        let last = this.safeString2(ticker, 'last_price', 'last');
+        let percentage = this.safeString(ticker, 'price_change_percent_24h');
+        let change = this.safeString(ticker, 'fluctuation');
+        let high = this.safeString2(ticker, 'high_24h', 'high_price');
+        let low = this.safeString2(ticker, 'low_24h', 'low_price');
+        let bid = this.safeString2(ticker, 'best_bid', 'bid_px');
+        let bidVolume = this.safeString2(ticker, 'best_bid_size', 'bid_sz');
+        let ask = this.safeString2(ticker, 'best_ask', 'ask_px');
+        let askVolume = this.safeString2(ticker, 'best_ask_size', 'ask_sz');
+        let open = this.safeString(ticker, 'open_24h');
+        let baseVolume = this.safeString2(ticker, 'base_volume_24h', 'v_24h');
+        let quoteVolume = this.safeStringLower2(ticker, 'quote_volume_24h', 'qv_24h');
+        const listMarketId = this.safeString(result, 0);
+        if (listMarketId !== undefined) {
+            marketId = listMarketId;
+            timestamp = this.safeInteger(result, 12);
+            high = this.safeString(result, 5);
+            low = this.safeString(result, 6);
+            bid = this.safeString(result, 8);
+            bidVolume = this.safeString(result, 9);
+            ask = this.safeString(result, 10);
+            askVolume = this.safeString(result, 11);
+            open = this.safeString(result, 4);
+            last = this.safeString(result, 1);
+            change = this.safeString(result, 7);
+            baseVolume = this.safeString(result, 2);
+            quoteVolume = this.safeStringLower(result, 3);
+        }
+        market = this.safeMarket(marketId, market);
+        const symbol = market['symbol'];
         if (timestamp === undefined) {
             // ticker from WS has a different field (in seconds)
             timestamp = this.safeIntegerProduct(ticker, 's_t', 1000);
         }
-        const marketId = this.safeString2(ticker, 'symbol', 'contract_symbol');
-        market = this.safeMarket(marketId, market);
-        const symbol = market['symbol'];
-        const last = this.safeString2(ticker, 'close_24h', 'last_price');
-        let percentage = this.safeString(ticker, 'price_change_percent_24h');
         if (percentage === undefined) {
-            percentage = Precise.stringMul(this.safeString(ticker, 'fluctuation'), '100');
+            percentage = Precise.stringMul(change, '100');
         }
-        let baseVolume = this.safeString(ticker, 'base_volume_24h');
-        let quoteVolume = this.safeString(ticker, 'quote_volume_24h');
         if (quoteVolume === undefined) {
             if (baseVolume === undefined) {
                 // this is swap
@@ -1203,25 +1248,22 @@ export default class bitmart extends Exchange {
                 baseVolume = undefined;
             }
         }
-        const average = this.safeString2(ticker, 'avg_price', 'index_price');
-        const high = this.safeString2(ticker, 'high_24h', 'high_price');
-        const low = this.safeString2(ticker, 'low_24h', 'low_price');
         return this.safeTicker({
             'symbol': symbol,
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
             'high': high,
             'low': low,
-            'bid': this.safeString(ticker, 'best_bid'),
-            'bidVolume': this.safeString(ticker, 'best_bid_size'),
-            'ask': this.safeString(ticker, 'best_ask'),
-            'askVolume': this.safeString(ticker, 'best_ask_size'),
+            'bid': bid,
+            'bidVolume': bidVolume,
+            'ask': ask,
+            'askVolume': askVolume,
             'vwap': undefined,
-            'open': this.safeString(ticker, 'open_24h'),
+            'open': open,
             'close': last,
             'last': last,
             'previousClose': undefined,
-            'change': undefined,
+            'change': change,
             'percentage': percentage,
             'average': average,
             'baseVolume': baseVolume,
@@ -1234,6 +1276,7 @@ export default class bitmart extends Exchange {
          * @method
          * @name bitmart#fetchTicker
          * @description fetches 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/#get-ticker-of-a-trading-pair-v3
          * @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}
@@ -1245,78 +1288,72 @@ export default class bitmart extends Exchange {
         if (market['swap']) {
             request['contract_symbol'] = market['id'];
             response = await this.publicGetContractV1Tickers(this.extend(request, params));
+            //
+            //      {
+            //          "message":"OK",
+            //          "code":1000,
+            //          "trace":"4a0ebceb-d3f7-45a3-8feb-f61e230e24cd",
+            //          "data":{
+            //              "tickers":[
+            //                  {
+            //                      "contract_symbol":"DOGEUSDT",
+            //                      "last_price":"0.130180",
+            //                      "index_price":"0.13028635",
+            //                      "last_funding_rate":"0.00002025",
+            //                      "price_change_percent_24h":"-2.326",
+            //                      "volume_24h":"116789313.01797258",
+            //                      "url":"https://futures.bitmart.com/en?symbol=DOGEUSDT",
+            //                      "high_price":"0.134520",
+            //                      "low_price":"0.128570",
+            //                      "legal_coin_price":"0.13017401"
+            //                  }
+            //              ]
+            //          }
+            //      }
+            //
         }
         else if (market['spot']) {
             request['symbol'] = market['id'];
-            response = await this.publicGetSpotV1Ticker(this.extend(request, params));
+            response = await this.publicGetSpotQuotationV3Ticker(this.extend(request, params));
+            //
+            //     {
+            //         "code": 1000,
+            //         "trace": "f2194c2c202d2.99.1717535",
+            //         "message": "success",
+            //         "data": {
+            //             "symbol": "BTC_USDT",
+            //             "last": "68500.00",
+            //             "v_24h": "10491.65490",
+            //             "qv_24h": "717178990.42",
+            //             "open_24h": "68149.75",
+            //             "high_24h": "69499.99",
+            //             "low_24h": "67132.40",
+            //             "fluctuation": "0.00514",
+            //             "bid_px": "68500",
+            //             "bid_sz": "0.00162",
+            //             "ask_px": "68500.01",
+            //             "ask_sz": "0.01722",
+            //             "ts": "1717131391671"
+            //         }
+            //     }
+            //
         }
         else {
             throw new NotSupported(this.id + ' fetchTicker() does not support ' + market['type'] + ' markets, only spot and swap markets are accepted');
         }
-        //
-        // spot
-        //
-        //     {
-        //         "message":"OK",
-        //         "code":1000,
-        //         "trace":"6aa5b923-2f57-46e3-876d-feca190e0b82",
-        //         "data":{
-        //             "tickers":[
-        //                 {
-        //                     "symbol":"ETH_BTC",
-        //                     "last_price":"0.036037",
-        //                     "quote_volume_24h":"4380.6660000000",
-        //                     "base_volume_24h":"159.3582006712",
-        //                     "high_24h":"0.036972",
-        //                     "low_24h":"0.035524",
-        //                     "open_24h":"0.036561",
-        //                     "close_24h":"0.036037",
-        //                     "best_ask":"0.036077",
-        //                     "best_ask_size":"9.9500",
-        //                     "best_bid":"0.035983",
-        //                     "best_bid_size":"4.2792",
-        //                     "fluctuation":"-0.0143",
-        //                     "url":"https://www.bitmart.com/trade?symbol=ETH_BTC"
-        //                 }
-        //             ]
-        //         }
-        //     }
-        //
-        // swap
-        //
-        //      {
-        //          "message":"OK",
-        //          "code":1000,
-        //          "trace":"4a0ebceb-d3f7-45a3-8feb-f61e230e24cd",
-        //          "data":{
-        //              "tickers":[
-        //                  {
-        //                      "contract_symbol":"DOGEUSDT",
-        //                      "last_price":"0.130180",
-        //                      "index_price":"0.13028635",
-        //                      "last_funding_rate":"0.00002025",
-        //                      "price_change_percent_24h":"-2.326",
-        //                      "volume_24h":"116789313.01797258",
-        //                      "url":"https://futures.bitmart.com/en?symbol=DOGEUSDT",
-        //                      "high_price":"0.134520",
-        //                      "low_price":"0.128570",
-        //                      "legal_coin_price":"0.13017401"
-        //                  }
-        //              ]
-        //          }
-        //      }
-        //
-        const data = this.safeValue(response, 'data', {});
-        const tickers = this.safeValue(data, 'tickers', []);
         // fails in naming for contract tickers 'contract_symbol'
         let tickersById = undefined;
+        let tickers = [];
+        let ticker = {};
         if (market['spot']) {
-            tickersById = this.indexBy(tickers, 'symbol');
+            ticker = this.safeDict(response, 'data', {});
         }
-        else if (market['swap']) {
+        else {
+            const data = this.safeDict(response, 'data', {});
+            tickers = this.safeList(data, 'tickers', []);
             tickersById = this.indexBy(tickers, 'contract_symbol');
+            ticker = this.safeDict(tickersById, market['id']);
         }
-        const ticker = this.safeDict(tickersById, market['id']);
         return this.parseTicker(ticker, market);
     }
     async fetchTickers(symbols = undefined, params = {}) {
@@ -1324,7 +1361,7 @@ export default class bitmart extends Exchange {
          * @method
          * @name bitmart#fetchTickers
          * @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
-         * @see https://developer-pro.bitmart.com/en/spot/#get-ticker-of-all-pairs-v2
+         * @see https://developer-pro.bitmart.com/en/spot/#get-ticker-of-all-pairs-v3
          * @param {string[]|undefined} symbols unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} a dictionary of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure}
@@ -1340,19 +1377,78 @@ export default class bitmart extends Exchange {
         [type, params] = this.handleMarketTypeAndParams('fetchTickers', market, params);
         let response = undefined;
         if (type === 'spot') {
-            response = await this.publicGetSpotV2Ticker(params);
+            response = await this.publicGetSpotQuotationV3Tickers(params);
+            //
+            //     {
+            //         "code": 1000,
+            //         "trace": "17c5e5d9ac49f9b71efca2bed55f1a.105.171225637482393",
+            //         "message": "success",
+            //         "data": [
+            //             [
+            //                 "AFIN_USDT",
+            //                 "0.001047",
+            //                 "11110",
+            //                 "11.632170",
+            //                 "0.001048",
+            //                 "0.001048",
+            //                 "0.001047",
+            //                 "-0.00095",
+            //                 "0.001029",
+            //                 "5555",
+            //                 "0.001041",
+            //                 "5297",
+            //                 "1717122550482"
+            //             ],
+            //         ]
+            //     }
+            //
         }
         else if (type === 'swap') {
             response = await this.publicGetContractV1Tickers(params);
+            //
+            //     {
+            //         "message": "OK",
+            //         "code": 1000,
+            //         "trace": "c1dec681c24ea5d.105.171712565",
+            //         "data": {
+            //             "tickers": [
+            //                 {
+            //                     "contract_symbol": "SNTUSDT",
+            //                     "last_price": "0.0366600",
+            //                     "index_price": "0.03587373",
+            //                     "last_funding_rate": "0.00005000",
+            //                     "price_change_percent_24h": "-2.629",
+            //                     "volume_24h": "10102540.19909109848",
+            //                     "url": "https://futures.bitmart.com/en?symbol=SNTUSDT",
+            //                     "high_price": "0.0405600",
+            //                     "low_price": "0.0355000",
+            //                     "legal_coin_price": "0.03666697"
+            //                 },
+            //             ]
+            //         }
+            //     }
+            //
         }
         else {
             throw new NotSupported(this.id + ' fetchTickers() does not support ' + type + ' markets, only spot and swap markets are accepted');
         }
-        const data = this.safeValue(response, 'data', {});
-        const tickers = this.safeValue(data, 'tickers', []);
+        let tickers = [];
+        if (type === 'spot') {
+            tickers = this.safeList(response, 'data', []);
+        }
+        else {
+            const data = this.safeDict(response, 'data', {});
+            tickers = this.safeList(data, 'tickers', []);
+        }
         const result = {};
         for (let i = 0; i < tickers.length; i++) {
-            const ticker = this.parseTicker(tickers[i]);
+            let ticker = {};
+            if (type === 'spot') {
+                ticker = this.parseTicker({ 'result': tickers[i] });
+            }
+            else {
+                ticker = this.parseTicker(tickers[i]);
+            }
             const symbol = ticker['symbol'];
             result[symbol] = ticker;
         }

package/js/src/bitstamp.d.ts

@@ -61,8 +61,8 @@ export default class bitstamp extends Exchange {
     fetchDepositWithdrawFees(codes?: any, params?: {}): Promise<any>;
     parseDepositWithdrawFee(fee: any, currency?: any): any;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
-    cancelOrder(id: string, symbol?: Str, params?: {}): Promise<any>;
-    cancelAllOrders(symbol?: Str, params?: {}): Promise<any>;
+    cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
+    cancelAllOrders(symbol?: Str, params?: {}): Promise<Order[]>;
     parseOrderStatus(status: Str): string;
     fetchOrderStatus(id: string, symbol?: Str, params?: {}): Promise<string>;
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;

package/js/src/bitstamp.js

@@ -1446,7 +1446,17 @@ export default class bitstamp extends Exchange {
         const request = {
             'id': id,
         };
-        return await this.privatePostCancelOrder(this.extend(request, params));
+        const response = await this.privatePostCancelOrder(this.extend(request, params));
+        //
+        //    {
+        //        "id": 1453282316578816,
+        //        "amount": "0.02035278",
+        //        "price": "2100.45",
+        //        "type": 0,
+        //        "market": "BTC/USD"
+        //    }
+        //
+        return this.parseOrder(response);
     }
     async cancelAllOrders(symbol = undefined, params = {}) {
         /**
@@ -1471,7 +1481,23 @@ export default class bitstamp extends Exchange {
         else {
             response = await this.privatePostCancelAllOrders(this.extend(request, params));
         }
-        return response;
+        //
+        //    {
+        //        "canceled": [
+        //            {
+        //                "id": 1453282316578816,
+        //                "amount": "0.02035278",
+        //                "price": "2100.45",
+        //                "type": 0,
+        //                "currency_pair": "BTC/USD",
+        //                "market": "BTC/USD"
+        //            }
+        //        ],
+        //        "success": true
+        //    }
+        //
+        const canceled = this.safeList(response, 'canceled');
+        return this.parseOrders(canceled);
     }
     parseOrderStatus(status) {
         const statuses = {
@@ -1848,6 +1874,16 @@ export default class bitstamp extends Exchange {
         //           "id": "2814205012"
         //       }
         //
+        // cancelOrder
+        //
+        //    {
+        //        "id": 1453282316578816,
+        //        "amount": "0.02035278",
+        //        "price": "2100.45",
+        //        "type": 0,
+        //        "market": "BTC/USD"
+        //    }
+        //
         const id = this.safeString(order, 'id');
         const clientOrderId = this.safeString(order, 'client_order_id');
         let side = this.safeString(order, 'type');

package/js/src/blockchaincom.d.ts

@@ -16,14 +16,8 @@ export default class blockchaincom extends Exchange {
     parseOrderState(state: any): string;
     parseOrder(order: Dict, market?: Market): Order;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
-    cancelOrder(id: string, symbol?: Str, params?: {}): Promise<{
-        id: string;
-        info: any;
-    }>;
-    cancelAllOrders(symbol?: Str, params?: {}): Promise<{
-        symbol: string;
-        info: any;
-    }>;
+    cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
+    cancelAllOrders(symbol?: Str, params?: {}): Promise<Order[]>;
     fetchTradingFees(params?: {}): Promise<TradingFees>;
     fetchCanceledOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;

package/js/src/blockchaincom.js

@@ -616,17 +616,17 @@ export default class blockchaincom extends Exchange {
             'orderId': id,
         };
         const response = await this.privateDeleteOrdersOrderId(this.extend(request, params));
-        return {
+        return this.safeOrder({
             'id': id,
             'info': response,
-        };
+        });
     }
     async cancelAllOrders(symbol = undefined, params = {}) {
         /**
          * @method
          * @name blockchaincom#cancelAllOrders
          * @description cancel all open orders
-         * @see https://api.blockchain.com/v3/#/trading/deleteAllOrders
+         * @see https://api.blockchain.com/v3/#deleteallorders
          * @param {string} symbol unified market symbol of the market to cancel orders in, all markets are used if undefined, 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}
@@ -642,10 +642,14 @@ export default class blockchaincom extends Exchange {
             request['symbol'] = marketId;
         }
         const response = await this.privateDeleteOrders(this.extend(request, params));
-        return {
-            'symbol': symbol,
-            'info': response,
-        };
+        //
+        // {}
+        //
+        return [
+            this.safeOrder({
+                'info': response,
+            }),
+        ];
     }
     async fetchTradingFees(params = {}) {
         /**

package/js/src/coinex.js

@@ -5789,7 +5789,7 @@ export default class coinex extends Exchange {
                 preparedString += nonce + this.secret;
                 const signature = this.hash(this.encode(preparedString), sha256);
                 headers = {
-                    'Content-Type': 'application/json; charset=utf-8',
+                    'Content-Type': 'application/json',
                     'Accept': 'application/json',
                     'X-COINEX-KEY': this.apiKey,
                     'X-COINEX-SIGN': signature,

package/js/src/coinlist.d.ts

@@ -42,7 +42,7 @@ export default class coinlist extends Exchange {
     fetchCanceledOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     cancelAllOrders(symbol?: Str, params?: {}): Promise<Order[]>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
-    cancelOrders(ids: any, symbol?: Str, params?: {}): Promise<any>;
+    cancelOrders(ids: any, symbol?: Str, params?: {}): Promise<any[]>;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     editOrder(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: Num, price?: Num, params?: {}): Promise<Order>;
     parseOrder(order: Dict, market?: Market): Order;

package/js/src/coinlist.js

@@ -1458,7 +1458,26 @@ export default class coinlist extends Exchange {
         await this.loadMarkets();
         params = ids;
         const response = await this.privateDeleteV1OrdersBulk(params);
-        return response;
+        //
+        //    {
+        //        "message": "Cancel order requests received.",
+        //        "order_ids": [
+        //            "ff132955-43bc-4fe5-9d9c-5ba226cc89a0"
+        //        ],
+        //        "timestamp": "2024-06-01T02:32:30.305Z"
+        //    }
+        //
+        const orderIds = this.safeList(response, 'order_ids', []);
+        const orders = [];
+        const datetime = this.safeString(response, 'timestamp');
+        for (let i = 0; i < orderIds.length; i++) {
+            orders.push(this.safeOrder({
+                'info': orderIds[i],
+                'id': orderIds[i],
+                'lastUpdateTimestamp': this.parse8601(datetime),
+            }));
+        }
+        return orders;
     }
     async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
         /**

package/js/src/coinmate.d.ts

@@ -28,9 +28,7 @@ export default class coinmate extends Exchange {
     parseOrder(order: Dict, market?: Market): Order;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
-    cancelOrder(id: string, symbol?: Str, params?: {}): Promise<{
-        info: any;
-    }>;
+    cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     nonce(): number;
     sign(path: any, api?: string, method?: string, params?: {}, headers?: any, body?: any): {
         url: string;