ccxt 4.3.42 → 4.3.44

package/js/src/coinex.js

@@ -21,7 +21,7 @@ export default class coinex extends Exchange {
         return this.deepExtend(super.describe(), {
             'id': 'coinex',
             'name': 'CoinEx',
-            'version': 'v1',
+            'version': 'v2',
             'countries': ['CN'],
             // IP ratelimit is 400 requests per second
             // rateLimit = 1000ms / 400 = 2.5
@@ -318,6 +318,8 @@ export default class coinex extends Exchange {
                             'futures/position-level': 1,
                             'futures/liquidation-history': 1,
                             'futures/basis-history': 1,
+                            'assets/deposit-withdraw-config': 1,
+                            'assets/all-deposit-withdraw-config': 1,
                         },
                     },
                     'private': {
@@ -340,7 +342,6 @@ export default class coinex extends Exchange {
                             'assets/deposit-address': 40,
                             'assets/deposit-history': 40,
                             'assets/withdraw': 40,
-                            'assets/deposit-withdraw-config': 1,
                             'assets/transfer-history': 40,
                             'spot/order-status': 8,
                             'spot/batch-order-status': 8,
@@ -534,131 +535,129 @@ export default class coinex extends Exchange {
         });
     }
     async fetchCurrencies(params = {}) {
-        const response = await this.v1PublicGetCommonAssetConfig(params);
+        /**
+         * @method
+         * @name coinex#fetchCurrencies
+         * @description fetches all available currencies on an exchange
+         * @see https://docs.coinex.com/api/v2/assets/deposit-withdrawal/http/list-all-deposit-withdrawal-config
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} an associative dictionary of currencies
+         */
+        const response = await this.v2PublicGetAssetsAllDepositWithdrawConfig(params);
+        //
         //     {
         //         "code": 0,
-        //         "data": {
-        //             "USDT-ERC20": {
-        //                  "asset": "USDT",
-        //                  "chain": "ERC20",
-        //                  "withdrawal_precision": 6,
-        //                  "can_deposit": true,
-        //                  "can_withdraw": true,
-        //                  "deposit_least_amount": "4.9",
-        //                  "withdraw_least_amount": "4.9",
-        //                  "withdraw_tx_fee": "4.9",
-        //                  "explorer_asset_url": "https://etherscan.io/token/0xdac17f958d2ee523a2206206994597c13d831ec7"
-        //             },
-        //             ...
-        //         },
-        //         "message": "Success",
+        //         "data": [
+        //             {
+        //                 "asset": {
+        //                     "ccy": "CET",
+        //                     "deposit_enabled": true,
+        //                     "withdraw_enabled": true,
+        //                     "inter_transfer_enabled": true,
+        //                     "is_st": false
+        //                 },
+        //                 "chains": [
+        //                     {
+        //                         "chain": "CSC",
+        //                         "min_deposit_amount": "0.8",
+        //                         "min_withdraw_amount": "8",
+        //                         "deposit_enabled": true,
+        //                         "withdraw_enabled": true,
+        //                         "deposit_delay_minutes": 0,
+        //                         "safe_confirmations": 10,
+        //                         "irreversible_confirmations": 20,
+        //                         "deflation_rate": "0",
+        //                         "withdrawal_fee": "0.026",
+        //                         "withdrawal_precision": 8,
+        //                         "memo": "",
+        //                         "is_memo_required_for_deposit": false,
+        //                         "explorer_asset_url": ""
+        //                     },
+        //                 ]
+        //             }
+        //         ],
+        //         "message": "OK"
         //     }
         //
-        const data = this.safeValue(response, 'data', []);
-        const coins = Object.keys(data);
+        const data = this.safeList(response, 'data', []);
         const result = {};
-        for (let i = 0; i < coins.length; i++) {
-            const coin = coins[i];
-            const currency = data[coin];
-            const currencyId = this.safeString(currency, 'asset');
-            const networkId = this.safeString(currency, 'chain');
+        for (let i = 0; i < data.length; i++) {
+            const coin = data[i];
+            const asset = this.safeDict(coin, 'asset', {});
+            const chains = this.safeList(coin, 'chains', []);
+            const currencyId = this.safeString(asset, 'ccy');
+            if (currencyId === undefined) {
+                continue; // coinex returns empty structures for some reason
+            }
             const code = this.safeCurrencyCode(currencyId);
-            const precisionString = this.parsePrecision(this.safeString(currency, 'withdrawal_precision'));
-            const precision = this.parseNumber(precisionString);
-            const canDeposit = this.safeValue(currency, 'can_deposit');
-            const canWithdraw = this.safeValue(currency, 'can_withdraw');
-            const feeString = this.safeString(currency, 'withdraw_tx_fee');
-            const fee = this.parseNumber(feeString);
-            const minNetworkDepositString = this.safeString(currency, 'deposit_least_amount');
-            const minNetworkDeposit = this.parseNumber(minNetworkDepositString);
-            const minNetworkWithdrawString = this.safeString(currency, 'withdraw_least_amount');
-            const minNetworkWithdraw = this.parseNumber(minNetworkWithdrawString);
-            if (this.safeValue(result, code) === undefined) {
-                result[code] = {
-                    'id': currencyId,
-                    'numericId': undefined,
-                    'code': code,
-                    'info': undefined,
+            const canDeposit = this.safeBool(asset, 'deposit_enabled');
+            const canWithdraw = this.safeBool(asset, 'withdraw_enabled');
+            const firstChain = this.safeDict(chains, 0, {});
+            const firstPrecisionString = this.parsePrecision(this.safeString(firstChain, 'withdrawal_precision'));
+            result[code] = {
+                'id': currencyId,
+                'code': code,
+                'name': undefined,
+                'active': canDeposit && canWithdraw,
+                'deposit': canDeposit,
+                'withdraw': canWithdraw,
+                'fee': undefined,
+                'precision': this.parseNumber(firstPrecisionString),
+                'limits': {
+                    'amount': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
+                    'deposit': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
+                    'withdraw': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
+                },
+                'networks': {},
+                'info': coin,
+            };
+            for (let j = 0; j < chains.length; j++) {
+                const chain = chains[j];
+                const networkId = this.safeString(chain, 'chain');
+                const precisionString = this.parsePrecision(this.safeString(chain, 'withdrawal_precision'));
+                const feeString = this.safeString(chain, 'withdrawal_fee');
+                const minNetworkDepositString = this.safeString(chain, 'min_deposit_amount');
+                const minNetworkWithdrawString = this.safeString(chain, 'min_withdraw_amount');
+                const canDepositChain = this.safeBool(chain, 'deposit_enabled');
+                const canWithdrawChain = this.safeBool(chain, 'withdraw_enabled');
+                const network = {
+                    'id': networkId,
+                    'network': networkId,
                     'name': undefined,
-                    'active': canDeposit && canWithdraw,
-                    'deposit': canDeposit,
-                    'withdraw': canWithdraw,
-                    'fee': fee,
-                    'precision': precision,
+                    'active': canDepositChain && canWithdrawChain,
+                    'deposit': canDepositChain,
+                    'withdraw': canWithdrawChain,
+                    'fee': this.parseNumber(feeString),
+                    'precision': this.parseNumber(precisionString),
                     'limits': {
                         'amount': {
                             'min': undefined,
                             'max': undefined,
                         },
                         'deposit': {
-                            'min': minNetworkDeposit,
+                            'min': this.parseNumber(minNetworkDepositString),
                             'max': undefined,
                         },
                         'withdraw': {
-                            'min': minNetworkWithdraw,
+                            'min': this.parseNumber(minNetworkWithdrawString),
                             'max': undefined,
                         },
                     },
+                    'info': chain,
                 };
+                const networks = this.safeDict(result[code], 'networks', {});
+                networks[networkId] = network;
+                result[code]['networks'] = networks;
             }
-            let minFeeString = this.safeString(result[code], 'fee');
-            if (feeString !== undefined) {
-                minFeeString = (minFeeString === undefined) ? feeString : Precise.stringMin(feeString, minFeeString);
-            }
-            let depositAvailable = this.safeValue(result[code], 'deposit');
-            depositAvailable = (canDeposit) ? canDeposit : depositAvailable;
-            let withdrawAvailable = this.safeValue(result[code], 'withdraw');
-            withdrawAvailable = (canWithdraw) ? canWithdraw : withdrawAvailable;
-            let minDepositString = this.safeString(result[code]['limits']['deposit'], 'min');
-            if (minNetworkDepositString !== undefined) {
-                minDepositString = (minDepositString === undefined) ? minNetworkDepositString : Precise.stringMin(minNetworkDepositString, minDepositString);
-            }
-            let minWithdrawString = this.safeString(result[code]['limits']['withdraw'], 'min');
-            if (minNetworkWithdrawString !== undefined) {
-                minWithdrawString = (minWithdrawString === undefined) ? minNetworkWithdrawString : Precise.stringMin(minNetworkWithdrawString, minWithdrawString);
-            }
-            let minPrecisionString = this.safeString(result[code], 'precision');
-            if (precisionString !== undefined) {
-                minPrecisionString = (minPrecisionString === undefined) ? precisionString : Precise.stringMin(precisionString, minPrecisionString);
-            }
-            const networks = this.safeValue(result[code], 'networks', {});
-            const network = {
-                'info': currency,
-                'id': networkId,
-                'network': networkId,
-                'name': undefined,
-                'limits': {
-                    'amount': {
-                        'min': undefined,
-                        'max': undefined,
-                    },
-                    'deposit': {
-                        'min': this.safeNumber(currency, 'deposit_least_amount'),
-                        'max': undefined,
-                    },
-                    'withdraw': {
-                        'min': this.safeNumber(currency, 'withdraw_least_amount'),
-                        'max': undefined,
-                    },
-                },
-                'active': canDeposit && canWithdraw,
-                'deposit': canDeposit,
-                'withdraw': canWithdraw,
-                'fee': fee,
-                'precision': precision,
-            };
-            networks[networkId] = network;
-            result[code]['networks'] = networks;
-            result[code]['active'] = depositAvailable && withdrawAvailable;
-            result[code]['deposit'] = depositAvailable;
-            result[code]['withdraw'] = withdrawAvailable;
-            const info = this.safeValue(result[code], 'info', []);
-            info.push(currency);
-            result[code]['info'] = info;
-            result[code]['fee'] = this.parseNumber(minFeeString);
-            result[code]['precision'] = this.parseNumber(minPrecisionString);
-            result[code]['limits']['deposit']['min'] = this.parseNumber(minDepositString);
-            result[code]['limits']['withdraw']['min'] = this.parseNumber(minWithdrawString);
         }
         return result;
     }
@@ -5431,7 +5430,7 @@ export default class coinex extends Exchange {
         const request = {
             'ccy': currency['id'],
         };
-        const response = await this.v2PrivateGetAssetsDepositWithdrawConfig(this.extend(request, params));
+        const response = await this.v2PublicGetAssetsDepositWithdrawConfig(this.extend(request, params));
         //
         //     {
         //         "code": 0,

package/js/src/lykke.d.ts

@@ -19,8 +19,8 @@ export default class lykke extends Exchange {
     parseOrderStatus(status: Str): 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<any>;
-    cancelAllOrders(symbol?: Str, params?: {}): Promise<any>;
+    cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
+    cancelAllOrders(symbol?: Str, params?: {}): Promise<Order[]>;
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;

package/js/src/lykke.js

@@ -883,7 +883,10 @@ export default class lykke extends Exchange {
         //         "error":null
         //     }
         //
-        return await this.privateDeleteOrdersOrderId(this.extend(request, params));
+        const response = await this.privateDeleteOrdersOrderId(this.extend(request, params));
+        return this.safeOrder({
+            'info': response,
+        });
     }
     async cancelAllOrders(symbol = undefined, params = {}) {
         /**
@@ -910,7 +913,12 @@ export default class lykke extends Exchange {
         //         "error":null
         //     }
         //
-        return await this.privateDeleteOrders(this.extend(request, params));
+        const response = await this.privateDeleteOrders(this.extend(request, params));
+        return [
+            this.safeOrder({
+                'info': response,
+            }),
+        ];
     }
     async fetchOrder(id, symbol = undefined, params = {}) {
         /**

package/js/src/ndax.d.ts

@@ -45,7 +45,7 @@ export default class ndax extends Exchange {
     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>;
     fetchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
-    cancelAllOrders(symbol?: Str, params?: {}): Promise<any>;
+    cancelAllOrders(symbol?: Str, params?: {}): Promise<Order[]>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<any>;
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;

package/js/src/ndax.js

@@ -1575,7 +1575,11 @@ export default class ndax extends Exchange {
         //         "detail":null
         //     }
         //
-        return response;
+        return [
+            this.safeOrder({
+                'info': response,
+            }),
+        ];
     }
     async cancelOrder(id, symbol = undefined, params = {}) {
         /**

package/js/src/phemex.js

@@ -6,7 +6,7 @@
 
 // ----------------------------------------------------------------------------
 import Exchange from './abstract/phemex.js';
-import { ExchangeError, BadSymbol, AuthenticationError, InsufficientFunds, InvalidOrder, ArgumentsRequired, OrderNotFound, BadRequest, PermissionDenied, AccountSuspended, CancelPending, DDoSProtection, DuplicateOrderId, RateLimitExceeded, NotSupported } from './base/errors.js';
+import { ExchangeError, BadSymbol, AuthenticationError, InsufficientFunds, InvalidOrder, ArgumentsRequired, OrderNotFound, BadRequest, PermissionDenied, AccountSuspended, CancelPending, DDoSProtection, DuplicateOrderId, RateLimitExceeded } from './base/errors.js';
 import { Precise } from './base/Precise.js';
 import { TICK_SIZE } from './base/functions/number.js';
 import { sha256 } from './static_dependencies/noble-hashes/sha256.js';
@@ -2957,6 +2957,7 @@ export default class phemex extends Exchange {
         /**
          * @method
          * @name phemex#fetchOrder
+         * @see https://phemex-docs.github.io/#query-orders-by-ids
          * @description fetches information on an order made by the user
          * @param {string} symbol unified symbol of the market the order was made in
          * @param {object} [params] extra parameters specific to the exchange API endpoint
@@ -2967,9 +2968,6 @@ export default class phemex extends Exchange {
         }
         await this.loadMarkets();
         const market = this.market(symbol);
-        if (market['settle'] === 'USDT') {
-            throw new NotSupported(this.id + 'fetchOrder() is not supported yet for USDT settled swap markets'); // https://github.com/phemex/phemex-api-docs/blob/master/Public-Hedged-Perpetual-API.md#query-user-order-by-orderid-or-query-user-order-by-client-order-id
-        }
         const request = {
             'symbol': market['id'],
         };
@@ -2982,7 +2980,10 @@ export default class phemex extends Exchange {
             request['orderID'] = id;
         }
         let response = undefined;
-        if (market['spot']) {
+        if (market['settle'] === 'USDT') {
+            response = await this.privateGetApiDataGFuturesOrdersByOrderId(this.extend(request, params));
+        }
+        else if (market['spot']) {
             response = await this.privateGetSpotOrdersActive(this.extend(request, params));
         }
         else {

package/js/src/poloniexfutures.js

@@ -1239,7 +1239,7 @@ export default class poloniexfutures extends Exchange {
         const cancelledOrderIdsLength = cancelledOrderIds.length;
         for (let i = 0; i < cancelledOrderIdsLength; i++) {
             const cancelledOrderId = this.safeString(cancelledOrderIds, i);
-            result.push({
+            result.push(this.safeOrder({
                 'id': cancelledOrderId,
                 'clientOrderId': undefined,
                 'timestamp': undefined,
@@ -1261,7 +1261,7 @@ export default class poloniexfutures extends Exchange {
                 'postOnly': undefined,
                 'stopPrice': undefined,
                 'info': response,
-            });
+            }));
         }
         return result;
     }

package/js/src/pro/bitget.js

@@ -1228,23 +1228,30 @@ export default class bitget extends bitgetRest {
         // isolated and cross margin
         //
         //     {
-        //         "enterPointSource": "web",
-        //         "force": "gtc",
-        //         "feeDetail": [],
-        //         "orderType": "limit",
-        //         "price": "35000.000000000",
-        //         "quoteSize": "10.500000000",
-        //         "side": "buy",
-        //         "status": "live",
-        //         "baseSize": "0.000300000",
-        //         "cTime": "1701923982427",
-        //         "clientOid": "4902047879864dc980c4840e9906db4e",
-        //         "fillPrice": "0.000000000",
-        //         "baseVolume": "0.000000000",
-        //         "fillTotalAmount": "0.000000000",
-        //         "loanType": "auto-loan-and-repay",
-        //         "orderId": "1116515595178356737"
-        //     }
+        //         enterPointSource: "web",
+        //         feeDetail: [
+        //           {
+        //             feeCoin: "AAVE",
+        //             deduction: "no",
+        //             totalDeductionFee: "0",
+        //             totalFee: "-0.00010740",
+        //           },
+        //         ],
+        //         force: "gtc",
+        //         orderType: "limit",
+        //         price: "93.170000000",
+        //         fillPrice: "93.170000000",
+        //         baseSize: "0.110600000", // total amount of order
+        //         quoteSize: "10.304602000", // total cost of order (independently if order is filled or pending)
+        //         baseVolume: "0.107400000", // filled amount of order (during order's lifecycle, and not for this specific incoming update)
+        //         fillTotalAmount: "10.006458000", // filled cost of order (during order's lifecycle, and not for this specific incoming update)
+        //         side: "buy",
+        //         status: "partially_filled",
+        //         cTime: "1717875017306",
+        //         clientOid: "b57afe789a06454e9c560a2aab7f7201",
+        //         loanType: "auto-loan",
+        //         orderId: "1183419084588060673",
+        //       }
         //
         const isSpot = !('posMode' in order);
         const isMargin = ('loanType' in order);
@@ -1285,12 +1292,12 @@ export default class bitget extends bitgetRest {
         let filledAmount = undefined;
         let cost = undefined;
         let remaining = undefined;
-        const totalFilled = this.safeString(order, 'accBaseVolume');
+        let totalFilled = this.safeString(order, 'accBaseVolume');
         if (isSpot) {
             if (isMargin) {
-                filledAmount = this.omitZero(this.safeString(order, 'fillTotalAmount'));
-                totalAmount = this.omitZero(this.safeString(order, 'baseSize')); // for margin trading
-                cost = this.safeString(order, 'quoteSize');
+                totalAmount = this.safeString(order, 'baseSize');
+                totalFilled = this.safeString(order, 'baseVolume');
+                cost = this.safeString(order, 'fillTotalAmount');
             }
             else {
                 const partialFillAmount = this.safeString(order, 'baseVolume');

package/js/src/pro/bitmex.js

@@ -1539,11 +1539,17 @@ export default class bitmex extends bitmexRest {
         //
         const action = this.safeString(message, 'action');
         const table = this.safeString(message, 'table');
+        if (table === undefined) {
+            return; // protecting from weird updates
+        }
         const data = this.safeValue(message, 'data', []);
         // if it's an initial snapshot
         if (action === 'partial') {
             const filter = this.safeDict(message, 'filter', {});
             const marketId = this.safeValue(filter, 'symbol');
+            if (marketId === undefined) {
+                return; // protecting from weird update
+            }
             const market = this.safeMarket(marketId);
             const symbol = market['symbol'];
             if (table === 'orderBookL2') {
@@ -1576,6 +1582,9 @@ export default class bitmex extends bitmexRest {
             const numUpdatesByMarketId = {};
             for (let i = 0; i < data.length; i++) {
                 const marketId = this.safeValue(data[i], 'symbol');
+                if (marketId === undefined) {
+                    return; // protecting from weird update
+                }
                 if (!(marketId in numUpdatesByMarketId)) {
                     numUpdatesByMarketId[marketId] = 0;
                 }

package/js/src/pro/bybit.js

@@ -126,7 +126,7 @@ export default class bybit extends bybitRest {
             },
             'streaming': {
                 'ping': this.ping,
-                'keepAlive': 19000,
+                'keepAlive': 18000,
             },
         });
     }

package/js/src/pro/mexc.js

@@ -64,7 +64,7 @@ export default class mexc extends mexcRest {
             },
             'streaming': {
                 'ping': this.ping,
-                'keepAlive': 10000,
+                'keepAlive': 8000,
             },
             'exceptions': {},
         });

package/js/src/pro/woo.js

@@ -56,7 +56,7 @@ export default class woo extends wooRest {
             },
             'streaming': {
                 'ping': this.ping,
-                'keepAlive': 10000,
+                'keepAlive': 9000,
             },
             'exceptions': {
                 'ws': {

package/js/src/static_dependencies/jsencrypt/lib/jsbn/jsbn.d.ts

@@ -15,7 +15,7 @@ export declare class BigInteger {
     protected intValue(): number;
     protected byteValue(): number;
     protected shortValue(): number;
-    protected signum(): 1 | 0 | -1;
+    protected signum(): 0 | 1 | -1;
     toByteArray(): number[];
     protected equals(a: BigInteger): boolean;
     protected min(a: BigInteger): BigInteger;

package/js/src/tradeogre.d.ts

@@ -18,7 +18,7 @@ export default class tradeogre extends Exchange {
     parseBalance(response: any): import("./base/types.js").Balances;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
-    cancelAllOrders(symbol?: Str, params?: {}): Promise<Order>;
+    cancelAllOrders(symbol?: Str, params?: {}): Promise<Order[]>;
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     parseOrder(order: Dict, market?: Market): Order;

package/js/src/tradeogre.js

@@ -6,7 +6,7 @@
 
 // ---------------------------------------------------------------------------
 import Exchange from './abstract/tradeogre.js';
-import { InsufficientFunds, AuthenticationError, BadRequest, ExchangeError } from './base/errors.js';
+import { InsufficientFunds, AuthenticationError, BadRequest, ExchangeError, ArgumentsRequired } from './base/errors.js';
 import { TICK_SIZE } from './base/functions/number.js';
 // ---------------------------------------------------------------------------
 /**
@@ -452,7 +452,7 @@ export default class tradeogre extends Exchange {
          * @name tradeogre#createOrder
          * @description create a trade order
          * @param {string} symbol unified symbol of the market to create an order in
-         * @param {string} type not used by tradeogre
+         * @param {string} type must be 'limit'
          * @param {string} side 'buy' or 'sell'
          * @param {float} amount how much of currency you want to trade in units of base currency
          * @param {float} price the price at which the order is to be fullfilled, in units of the quote currency
@@ -461,14 +461,17 @@ export default class tradeogre extends Exchange {
          */
         await this.loadMarkets();
         const market = this.market(symbol);
+        if (type === 'market') {
+            throw new BadRequest(this.id + ' createOrder does not support market orders');
+        }
+        if (price === undefined) {
+            throw new ArgumentsRequired(this.id + ' createOrder requires a limit parameter');
+        }
         const request = {
             'market': market['id'],
             'quantity': this.parseToNumeric(this.amountToPrecision(symbol, amount)),
             'price': this.parseToNumeric(this.priceToPrecision(symbol, price)),
         };
-        if (type === 'market') {
-            throw new BadRequest(this.id + ' createOrder does not support market orders');
-        }
         let response = undefined;
         if (side === 'buy') {
             response = await this.privatePostOrderBuy(this.extend(request, params));
@@ -505,7 +508,10 @@ export default class tradeogre extends Exchange {
          * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         await this.loadMarkets();
-        return await this.cancelOrder('all', symbol, params);
+        const response = await this.cancelOrder('all', symbol, params);
+        return [
+            response,
+        ];
     }
     async fetchOpenOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**

package/js/src/wavesexchange.d.ts

@@ -53,26 +53,7 @@ export default class wavesexchange extends Exchange {
     safeGetDynamic(settings: any): any;
     safeGetRates(dynamic: any): any;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
-    cancelOrder(id: string, symbol?: Str, params?: {}): Promise<{
-        info: any;
-        id: string;
-        clientOrderId: any;
-        timestamp: any;
-        datetime: any;
-        lastTradeTimestamp: any;
-        symbol: string;
-        type: any;
-        side: any;
-        price: any;
-        amount: any;
-        cost: any;
-        average: any;
-        filled: any;
-        remaining: any;
-        status: any;
-        fee: any;
-        trades: any;
-    }>;
+    cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     fetchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;

package/js/src/wavesexchange.js

@@ -1502,7 +1502,7 @@ export default class wavesexchange extends Exchange {
         const firstMessage = this.safeValue(message, 0);
         const firstOrder = this.safeValue(firstMessage, 0);
         const returnedId = this.safeString(firstOrder, 'orderId');
-        return {
+        return this.safeOrder({
             'info': response,
             'id': returnedId,
             'clientOrderId': undefined,
@@ -1521,7 +1521,7 @@ export default class wavesexchange extends Exchange {
             'status': undefined,
             'fee': undefined,
             'trades': undefined,
-        };
+        });
     }
     async fetchOrder(id, symbol = undefined, params = {}) {
         /**