ccxt 4.0.97 → 4.0.99

package/dist/cjs/ccxt.js

@@ -180,7 +180,7 @@ var woo$1 = require('./src/pro/woo.js');
 
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.0.97';
+const version = '4.0.99';
 Exchange["default"].ccxtVersion = version;
 const exchanges = {
     'ace': ace,

package/dist/cjs/src/bigone.js

@@ -31,6 +31,7 @@ class bigone extends bigone$1 {
                 'cancelAllOrders': true,
                 'cancelOrder': true,
                 'createOrder': true,
+                'createPostOnlyOrder': true,
                 'createStopLimitOrder': true,
                 'createStopMarketOrder': true,
                 'createStopOrder': true,
@@ -132,6 +133,7 @@ class bigone extends bigone$1 {
                 },
             },
             'options': {
+                'createMarketBuyOrderRequiresPrice': true,
                 'accountsByType': {
                     'spot': 'SPOT',
                     'fund': 'FUND',
@@ -1088,30 +1090,39 @@ class bigone extends bigone$1 {
         //
         return this.parseBalance(response);
     }
+    parseType(type) {
+        const types = {
+            'STOP_LIMIT': 'limit',
+            'STOP_MARKET': 'market',
+            'LIMIT': 'limit',
+            'MARKET': 'market',
+        };
+        return this.safeString(types, type, type);
+    }
     parseOrder(order, market = undefined) {
         //
         //    {
-        //        "id": 10,
-        //        "asset_pair_name": "EOS-BTC",
-        //        "price": "10.00",
-        //        "amount": "10.00",
-        //        "filled_amount": "9.0",
-        //        "avg_deal_price": "12.0",
-        //        "side": "ASK",
-        //        "state": "FILLED",
-        //        "created_at":"2019-01-29T06:05:56Z",
-        //        "updated_at":"2019-01-29T06:05:56Z",
+        //        "id": '42154072251',
+        //        "asset_pair_name": 'SOL-USDT',
+        //        "price": '20',
+        //        "amount": '0.5',
+        //        "filled_amount": '0',
+        //        "avg_deal_price": '0',
+        //        "side": 'ASK',
+        //        "state": 'PENDING',
+        //        "created_at": '2023-09-13T03:42:00Z',
+        //        "updated_at": '2023-09-13T03:42:00Z',
+        //        "type": 'LIMIT',
+        //        "stop_price": '0',
+        //        "immediate_or_cancel": false,
+        //        "post_only": false,
+        //        "client_order_id": ''
         //    }
         //
         const id = this.safeString(order, 'id');
         const marketId = this.safeString(order, 'asset_pair_name');
         const symbol = this.safeSymbol(marketId, market, '-');
         const timestamp = this.parse8601(this.safeString(order, 'created_at'));
-        const price = this.safeString(order, 'price');
-        const amount = this.safeString(order, 'amount');
-        const average = this.safeString(order, 'avg_deal_price');
-        const filled = this.safeString(order, 'filled_amount');
-        const status = this.parseOrderStatus(this.safeString(order, 'state'));
         let side = this.safeString(order, 'side');
         if (side === 'BID') {
             side = 'buy';
@@ -1119,28 +1130,48 @@ class bigone extends bigone$1 {
         else {
             side = 'sell';
         }
-        const lastTradeTimestamp = this.parse8601(this.safeString(order, 'updated_at'));
+        let triggerPrice = this.safeString(order, 'stop_price');
+        if (Precise["default"].stringEq(triggerPrice, '0')) {
+            triggerPrice = undefined;
+        }
+        const immediateOrCancel = this.safeValue(order, 'immediate_or_cancel');
+        let timeInForce = undefined;
+        if (immediateOrCancel) {
+            timeInForce = 'IOC';
+        }
+        const type = this.parseType(this.safeString(order, 'type'));
+        const price = this.safeString(order, 'price');
+        let amount = undefined;
+        let filled = undefined;
+        let cost = undefined;
+        if (type === 'market' && side === 'buy') {
+            cost = this.safeString(order, 'filled_amount');
+        }
+        else {
+            amount = this.safeString(order, 'amount');
+            filled = this.safeString(order, 'filled_amount');
+        }
         return this.safeOrder({
             'info': order,
             'id': id,
-            'clientOrderId': undefined,
+            'clientOrderId': this.safeString(order, 'client_order_id'),
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
-            'lastTradeTimestamp': lastTradeTimestamp,
+            'lastTradeTimestamp': this.parse8601(this.safeString(order, 'updated_at')),
             'symbol': symbol,
-            'type': undefined,
-            'timeInForce': undefined,
-            'postOnly': undefined,
+            'type': type,
+            'timeInForce': timeInForce,
+            'postOnly': this.safeValue(order, 'post_only'),
             'side': side,
             'price': price,
-            'stopPrice': undefined,
-            'triggerPrice': undefined,
+            'stopPrice': triggerPrice,
+            'triggerPrice': triggerPrice,
             'amount': amount,
-            'cost': undefined,
-            'average': average,
+            'cost': cost,
+            'average': this.safeString(order, 'avg_deal_price'),
             'filled': filled,
             'remaining': undefined,
-            'status': status,
+            'status': this.parseOrderStatus(this.safeString(order, 'state')),
             'fee': undefined,
             'trades': undefined,
         }, market);
@@ -1150,46 +1181,79 @@ class bigone extends bigone$1 {
          * @method
          * @name bigone#createOrder
          * @description create a trade order
+         * @see https://open.big.one/docs/spot_orders.html#create-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'
          * @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, ignored in market orders
          * @param {object} [params] extra parameters specific to the bigone api endpoint
+         * @param {float} [params.triggerPrice] the price at which a trigger order is triggered at
+         * @param {bool} [params.postOnly] if true, the order will only be posted to the order book and not executed immediately
+         * @param {string} [params.timeInForce] "GTC", "IOC", or "PO"
+         *
+         * EXCHANGE SPECIFIC PARAMETERS
+         * @param {string} operator *stop order only* GTE or LTE (default)
+         * @param {string} client_order_id must match ^[a-zA-Z0-9-_]{1,36}$ this regex. client_order_id is unique in 24 hours, If created 24 hours later and the order closed, it will be released and can be reused
          * @returns {object} an [order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
          */
         await this.loadMarkets();
         const market = this.market(symbol);
-        const requestSide = (side === 'buy') ? 'BID' : 'ASK';
-        const uppercaseType = type.toUpperCase();
+        const isBuy = (side === 'buy');
+        const requestSide = isBuy ? 'BID' : 'ASK';
+        let uppercaseType = type.toUpperCase();
+        const isLimit = uppercaseType === 'LIMIT';
+        const exchangeSpecificParam = this.safeValue(params, 'post_only');
+        let postOnly = undefined;
+        [postOnly, params] = this.handlePostOnly((uppercaseType === 'MARKET'), exchangeSpecificParam, params);
+        const triggerPrice = this.safeStringN(params, ['triggerPrice', 'stopPrice', 'stop_price']);
         const request = {
             'asset_pair_name': market['id'],
             'side': requestSide,
-            'amount': this.amountToPrecision(symbol, amount),
+            'amount': this.amountToPrecision(symbol, amount), // order amount, string, required
             // 'price': this.priceToPrecision (symbol, price), // order price, string, required
-            'type': uppercaseType,
             // 'operator': 'GTE', // stop orders only, GTE greater than and equal, LTE less than and equal
             // 'immediate_or_cancel': false, // limit orders only, must be false when post_only is true
             // 'post_only': false, // limit orders only, must be false when immediate_or_cancel is true
         };
-        if (uppercaseType === 'LIMIT') {
+        if (isLimit || (uppercaseType === 'STOP_LIMIT')) {
             request['price'] = this.priceToPrecision(symbol, price);
+            if (isLimit) {
+                const timeInForce = this.safeString(params, 'timeInForce');
+                if (timeInForce === 'IOC') {
+                    request['immediate_or_cancel'] = true;
+                }
+                if (postOnly) {
+                    request['post_only'] = true;
+                }
+            }
         }
         else {
-            const isStopLimit = (uppercaseType === 'STOP_LIMIT');
-            const isStopMarket = (uppercaseType === 'STOP_MARKET');
-            if (isStopLimit || isStopMarket) {
-                const stopPrice = this.safeNumber2(params, 'stop_price', 'stopPrice');
-                if (stopPrice === undefined) {
-                    throw new errors.ArgumentsRequired(this.id + ' createOrder() requires a stop_price parameter');
+            const createMarketBuyOrderRequiresPrice = this.safeValue(this.options, 'createMarketBuyOrderRequiresPrice');
+            if (createMarketBuyOrderRequiresPrice && (side === 'buy')) {
+                if (price === undefined) {
+                    throw new errors.InvalidOrder(this.id + ' createOrder() requires price argument for market buy orders on spot markets to calculate the total amount to spend (amount * price), alternatively set the createMarketBuyOrderRequiresPrice option to false and pass in the cost to spend into the amount parameter');
                 }
-                request['stop_price'] = this.priceToPrecision(symbol, stopPrice);
-                params = this.omit(params, ['stop_price', 'stopPrice']);
+                else {
+                    const amountString = this.numberToString(amount);
+                    const priceString = this.numberToString(price);
+                    amount = this.parseNumber(Precise["default"].stringMul(amountString, priceString));
+                }
+            }
+        }
+        request['amount'] = this.amountToPrecision(symbol, amount);
+        if (triggerPrice !== undefined) {
+            request['stop_price'] = this.priceToPrecision(symbol, triggerPrice);
+            request['operator'] = isBuy ? 'GTE' : 'LTE';
+            if (isLimit) {
+                uppercaseType = 'STOP_LIMIT';
             }
-            if (isStopLimit) {
-                request['price'] = this.priceToPrecision(symbol, price);
+            else if (uppercaseType === 'MARKET') {
+                uppercaseType = 'STOP_MARKET';
             }
         }
+        request['type'] = uppercaseType;
+        params = this.omit(params, ['stop_price', 'stopPrice', 'triggerPrice', 'timeInForce']);
         const response = await this.privatePostOrders(this.extend(request, params));
         //
         //    {

package/dist/cjs/src/bithumb.js

@@ -80,15 +80,14 @@ class bithumb extends bithumb$1 {
             'api': {
                 'public': {
                     'get': [
-                        'ticker/{currency}',
-                        'ticker/all',
-                        'ticker/ALL_BTC',
-                        'ticker/ALL_KRW',
-                        'orderbook/{currency}',
-                        'orderbook/all',
-                        'transaction_history/{currency}',
-                        'transaction_history/all',
-                        'candlestick/{currency}/{interval}',
+                        'ticker/ALL_{quoteId}',
+                        'ticker/{baseId}_{quoteId}',
+                        'orderbook/ALL_{quoteId}',
+                        'orderbook/{baseId}_{quoteId}',
+                        'transaction_history/{baseId}_{quoteId}',
+                        'assetsstatus/ALL',
+                        'assetsstatus/{baseId}',
+                        'candlestick/{baseId}_{quoteId}/{interval}',
                     ],
                 },
                 'private': {
@@ -107,6 +106,7 @@ class bithumb extends bithumb$1 {
                         'trade/krw_withdrawal',
                         'trade/market_buy',
                         'trade/market_sell',
+                        'trade/stop_limit',
                     ],
                 },
             },
@@ -195,8 +195,10 @@ class bithumb extends bithumb$1 {
             const quote = quotes[i];
             const quoteId = quote;
             const extension = this.safeValue(quoteCurrencies, quote, {});
-            const method = 'publicGetTickerALL' + quote;
-            const response = await this[method](params);
+            const request = {
+                'quoteId': quoteId,
+            };
+            const response = await this.publicGetTickerALLQuoteId(this.extend(request, params));
             const data = this.safeValue(response, 'data');
             const currencyIds = Object.keys(data);
             for (let j = 0; j < currencyIds.length; j++) {
@@ -307,12 +309,13 @@ class bithumb extends bithumb$1 {
         await this.loadMarkets();
         const market = this.market(symbol);
         const request = {
-            'currency': market['base'] + '_' + market['quote'],
+            'baseId': market['baseId'],
+            'quoteId': market['quoteId'],
         };
         if (limit !== undefined) {
             request['count'] = limit; // default 30, max 30
         }
-        const response = await this.publicGetOrderbookCurrency(this.extend(request, params));
+        const response = await this.publicGetOrderbookBaseIdQuoteId(this.extend(request, params));
         //
         //     {
         //         "status":"0000",
@@ -400,8 +403,11 @@ class bithumb extends bithumb$1 {
         const quotes = Object.keys(quoteCurrencies);
         for (let i = 0; i < quotes.length; i++) {
             const quote = quotes[i];
-            const method = 'publicGetTickerALL' + quote;
-            const response = await this[method](params);
+            const quoteId = quote;
+            const request = {
+                'quoteId': quoteId,
+            };
+            const response = await this.publicGetTickerALLQuoteId(this.extend(request, params));
             //
             //     {
             //         "status":"0000",
@@ -451,9 +457,10 @@ class bithumb extends bithumb$1 {
         await this.loadMarkets();
         const market = this.market(symbol);
         const request = {
-            'currency': market['base'],
+            'baseId': market['baseId'],
+            'quoteId': market['quoteId'],
         };
-        const response = await this.publicGetTickerCurrency(this.extend(request, params));
+        const response = await this.publicGetTickerBaseIdQuoteId(this.extend(request, params));
         //
         //     {
         //         "status":"0000",
@@ -511,10 +518,11 @@ class bithumb extends bithumb$1 {
         await this.loadMarkets();
         const market = this.market(symbol);
         const request = {
-            'currency': market['base'],
+            'baseId': market['baseId'],
+            'quoteId': market['quoteId'],
             'interval': this.safeString(this.timeframes, timeframe, timeframe),
         };
-        const response = await this.publicGetCandlestickCurrencyInterval(this.extend(request, params));
+        const response = await this.publicGetCandlestickBaseIdQuoteIdInterval(this.extend(request, params));
         //
         //     {
         //         'status': '0000',
@@ -633,12 +641,13 @@ class bithumb extends bithumb$1 {
         await this.loadMarkets();
         const market = this.market(symbol);
         const request = {
-            'currency': market['base'] + '_' + market['quote'],
+            'baseId': market['baseId'],
+            'quoteId': market['quoteId'],
         };
         if (limit !== undefined) {
             request['count'] = limit; // default 20, max 100
         }
-        const response = await this.publicGetTransactionHistoryCurrency(this.extend(request, params));
+        const response = await this.publicGetTransactionHistoryBaseIdQuoteId(this.extend(request, params));
         //
         //     {
         //         "status":"0000",

package/dist/cjs/src/bitmart.js

@@ -85,7 +85,7 @@ class bitmart extends bitmart$1 {
                 'fetchWithdrawals': true,
                 'reduceMargin': false,
                 'repayMargin': true,
-                'setLeverage': false,
+                'setLeverage': true,
                 'setMarginMode': false,
                 'transfer': true,
                 'withdraw': true,
@@ -148,6 +148,9 @@ class bitmart extends bitmart$1 {
                         'account/sub-account/v1/transfer-history': 7.5,
                         'account/sub-account/main/v1/wallet': 5,
                         'account/sub-account/main/v1/subaccount-list': 7.5,
+                        'account/contract/sub-account/main/v1/wallet': 5,
+                        'account/contract/sub-account/main/v1/transfer-list': 7.5,
+                        'account/contract/sub-account/v1/transfer-history': 7.5,
                         // account
                         'account/v1/wallet': 5,
                         'account/v1/currencies': 30,
@@ -173,9 +176,11 @@ class bitmart extends bitmart$1 {
                         'spot/v1/user_fee': 6,
                         // contract
                         'contract/private/assets-detail': 5,
-                        'contract/private/order': 2,
+                        'contract/private/order': 1.2,
                         'contract/private/order-history': 10,
                         'contract/private/position': 10,
+                        'contract/private/get-open-orders': 1.2,
+                        'contract/private/trades': 10,
                     },
                     'post': {
                         // sub-account endpoints
@@ -184,6 +189,9 @@ class bitmart extends bitmart$1 {
                         'account/sub-account/main/v1/main-to-sub': 30,
                         'account/sub-account/sub/v1/sub-to-sub': 30,
                         'account/sub-account/main/v1/sub-to-sub': 30,
+                        'account/contract/sub-account/main/v1/sub-to-main': 7.5,
+                        'account/contract/sub-account/main/v1/main-to-sub': 7.5,
+                        'account/contract/sub-account/sub/v1/sub-to-main': 7.5,
                         // account
                         'account/v1/withdraw/apply': 7.5,
                         // transaction and trading
@@ -207,7 +215,14 @@ class bitmart extends bitmart$1 {
                         'spot/v1/margin/isolated/repay': 6,
                         'spot/v1/margin/isolated/transfer': 6,
                         // contract
-                        'contract/private/trades': 10,
+                        'account/v1/transfer-contract-list': 60,
+                        'account/v1/transfer-contract': 60,
+                        'contract/private/submit-order': 2.5,
+                        'contract/private/cancel-order': 1.5,
+                        'contract/private/cancel-orders': 30,
+                        'contract/private/submit-plan-order': 2.5,
+                        'contract/private/cancel-plan-order': 1.5,
+                        'contract/private/submit-leverage': 2.5,
                     },
                 },
             },
@@ -2052,6 +2067,9 @@ class bitmart extends bitmart$1 {
         }
         const [marginMode, query] = this.handleMarginModeAndParams('createOrder', params);
         if (marginMode !== undefined) {
+            if (marginMode !== 'isolated') {
+                throw new errors.NotSupported(this.id + ' only isolated margin is supported');
+            }
             method = 'privatePostSpotV1MarginSubmitOrder';
         }
         const response = await this[method](this.extend(request, query));
@@ -3204,22 +3222,33 @@ class bitmart extends bitmart$1 {
             'info': interest,
         };
     }
-    handleMarginModeAndParams(methodName, params = {}, defaultValue = undefined) {
+    async setLeverage(leverage, symbol = undefined, params = {}) {
         /**
-         * @ignore
          * @method
-         * @description marginMode specified by params["marginMode"], this.options["marginMode"], this.options["defaultMarginMode"], params["margin"] = true or this.options["defaultType"] = 'margin'
-         * @param {object} [params] extra parameters specific to the exchange api endpoint
-         * @returns {array} the marginMode in lowercase
+         * @name bitmart#setLeverage
+         * @description set the level of leverage for a market
+         * @see https://developer-pro.bitmart.com/en/futures/#submit-leverage-signed
+         * @param {float} leverage the rate of leverage
+         * @param {string} symbol unified market symbol
+         * @param {object} [params] extra parameters specific to the bitmart api endpoint
+         * @param {string} [params.marginMode] 'isolated' or 'cross'
+         * @returns {object} response from the exchange
          */
+        this.checkRequiredSymbol('setLeverage', symbol);
         let marginMode = undefined;
-        [marginMode, params] = super.handleMarginModeAndParams(methodName, params, defaultValue);
-        if (marginMode !== undefined) {
-            if (marginMode !== 'isolated') {
-                throw new errors.NotSupported(this.id + ' only isolated margin is supported');
-            }
+        [marginMode, params] = this.handleMarginModeAndParams('setLeverage', params);
+        this.checkRequiredArgument('setLeverage', marginMode, 'marginMode', ['isolated', 'cross']);
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        if (!market['swap']) {
+            throw new errors.BadSymbol(this.id + ' setLeverage() supports swap contracts only');
         }
-        return [marginMode, params];
+        const request = {
+            'symbol': market['id'],
+            'leverage': leverage.toString(),
+            'open_type': marginMode,
+        };
+        return await this.privatePostContractPrivateSubmitLeverage(this.extend(request, params));
     }
     nonce() {
         return this.milliseconds();

package/dist/cjs/src/exmo.js

@@ -203,6 +203,7 @@ class exmo extends exmo$1 {
             'precisionMode': number.TICK_SIZE,
             'exceptions': {
                 'exact': {
+                    '140434': errors.BadRequest,
                     '40005': errors.AuthenticationError,
                     '40009': errors.InvalidNonce,
                     '40015': errors.ExchangeError,
@@ -1382,34 +1383,42 @@ class exmo extends exmo$1 {
          * @name exmo#createOrder
          * @description create a trade order
          * @see https://documenter.getpostman.com/view/10287440/SzYXWKPi#80daa469-ec59-4d0a-b229-6a311d8dd1cd
+         * @see https://documenter.getpostman.com/view/10287440/SzYXWKPi#de6f4321-eeac-468c-87f7-c4ad7062e265  // stop market
+         * @see https://documenter.getpostman.com/view/10287440/SzYXWKPi#3561b86c-9ff1-436e-8e68-ac926b7eb523  // margin
          * @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'
          * @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, ignored in market orders
          * @param {object} [params] extra parameters specific to the exmo api endpoint
+         * @param {float} [params.stopPrice] the price at which a trigger order is triggered at
+         * @param {string} [params.timeInForce] *spot only* 'fok', 'ioc' or 'post_only'
+         * @param {boolean} [params.postOnly] *spot only* true for post only orders
          * @returns {object} an [order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
          */
         await this.loadMarkets();
         const market = this.market(symbol);
-        const prefix = (type === 'market') ? (type + '_') : '';
-        const orderType = prefix + side;
         const isMarket = (type === 'market') && (price === undefined);
+        let marginMode = undefined;
+        [marginMode, params] = this.handleMarginModeAndParams('createOrder', params);
+        if (marginMode === 'cross') {
+            throw new errors.BadRequest(this.id + ' only supports isolated margin');
+        }
+        const isSpot = (marginMode !== 'isolated');
+        const triggerPrice = this.safeNumberN(params, ['triggerPrice', 'stopPrice', 'stop_price']);
         const request = {
             'pair': market['id'],
             // 'leverage': 2,
             'quantity': this.amountToPrecision(market['symbol'], amount),
             // spot - buy, sell, market_buy, market_sell, market_buy_total, market_sell_total
             // margin - limit_buy, limit_sell, market_buy, market_sell, stop_buy, stop_sell, stop_limit_buy, stop_limit_sell, trailing_stop_buy, trailing_stop_sell
-            'type': orderType,
-            'price': isMarket ? 0 : this.priceToPrecision(market['symbol'], price),
             // 'stop_price': this.priceToPrecision (symbol, stopPrice),
             // 'distance': 0, // distance for trailing stop orders
             // 'expire': 0, // expiration timestamp in UTC timezone for the order, unless expire is 0
             // 'client_id': 123, // optional, must be a positive integer
             // 'comment': '', // up to 50 latin symbols, whitespaces, underscores
         };
-        let method = 'privatePostOrderCreate';
+        let method = isSpot ? 'privatePostOrderCreate' : 'privatePostMarginUserOrderCreate';
         let clientOrderId = this.safeValue2(params, 'client_id', 'clientOrderId');
         if (clientOrderId !== undefined) {
             clientOrderId = this.safeInteger2(params, 'client_id', 'clientOrderId');
@@ -1419,19 +1428,68 @@ class exmo extends exmo$1 {
             else {
                 request['client_id'] = clientOrderId;
             }
-            params = this.omit(params, ['client_id', 'clientOrderId']);
         }
-        if ((type === 'stop') || (type === 'stop_limit') || (type === 'trailing_stop')) {
-            const stopPrice = this.safeNumber2(params, 'stop_price', 'stopPrice');
-            if (stopPrice === undefined) {
-                throw new errors.InvalidOrder(this.id + ' createOrder() requires a stopPrice extra param for a ' + type + ' order');
+        const leverage = this.safeNumber(params, 'leverage');
+        if (!isSpot && (leverage === undefined)) {
+            throw new errors.ArgumentsRequired(this.id + ' createOrder requires an extra param params["leverage"] for margin orders');
+        }
+        params = this.omit(params, ['stopPrice', 'stop_price', 'triggerPrice', 'timeInForce', 'client_id', 'clientOrderId']);
+        if (triggerPrice !== undefined) {
+            if (isSpot) {
+                if (type === 'limit') {
+                    throw new errors.BadRequest(this.id + ' createOrder () cannot create stop limit orders for spot, only stop market');
+                }
+                else {
+                    method = 'privatePostStopMarketOrderCreate';
+                    request['type'] = side;
+                    request['trigger_price'] = this.priceToPrecision(symbol, triggerPrice);
+                }
+            }
+            else {
+                request['stop_price'] = this.priceToPrecision(symbol, triggerPrice);
+                if (type === 'limit') {
+                    request['type'] = 'stop_limit_' + side;
+                }
+                else if (type === 'market') {
+                    request['type'] = 'stop_' + side;
+                }
+                else {
+                    request['type'] = type;
+                }
+            }
+        }
+        else {
+            if (isSpot) {
+                const execType = this.safeString(params, 'exec_type');
+                let isPostOnly = undefined;
+                [isPostOnly, params] = this.handlePostOnly(type === 'market', execType === 'post_only', params);
+                const timeInForce = this.safeString(params, 'timeInForce');
+                request['price'] = isMarket ? 0 : this.priceToPrecision(market['symbol'], price);
+                if (type === 'limit') {
+                    request['type'] = side;
+                }
+                else if (type === 'market') {
+                    request['type'] = 'market_' + side;
+                }
+                if (isPostOnly) {
+                    request['exec_type'] = 'post_only';
+                }
+                else if (timeInForce !== undefined) {
+                    request['exec_type'] = timeInForce;
+                }
             }
             else {
-                params = this.omit(params, ['stopPrice', 'stop_price']);
-                request['stop_price'] = this.priceToPrecision(symbol, stopPrice);
-                method = 'privatePostMarginUserOrderCreate';
+                if (type === 'limit' || type === 'market') {
+                    request['type'] = type + '_' + side;
+                }
+                else {
+                    request['type'] = type;
+                }
             }
         }
+        if (price !== undefined) {
+            request['price'] = this.priceToPrecision(market['symbol'], price);
+        }
         const response = await this[method](this.extend(request, params));
         return this.parseOrder(response, market);
     }
@@ -2240,6 +2298,19 @@ class exmo extends exmo$1 {
         if (response === undefined) {
             return undefined; // fallback to default error handler
         }
+        if ('error' in response) {
+            // error: {
+            //     code: '140434',
+            //     msg: "Your margin balance is not sufficient to place the order for '5 TON'. Please top up your margin wallet by '2.5 USDT'."
+            // }
+            const errorCode = this.safeValue(response, 'error', {});
+            const messageError = this.safeString(errorCode, 'msg');
+            const code = this.safeString(errorCode, 'code');
+            const feedback = this.id + ' ' + body;
+            this.throwExactlyMatchedException(this.exceptions['exact'], code, feedback);
+            this.throwBroadlyMatchedException(this.exceptions['broad'], messageError, feedback);
+            throw new errors.ExchangeError(feedback);
+        }
         if (('result' in response) || ('errmsg' in response)) {
             //
             //     {"result":false,"error":"Error 50052: Insufficient funds"}

package/dist/cjs/src/gate.js

@@ -4167,7 +4167,7 @@ class gate extends gate$1 {
             type = isMarketOrder ? 'market' : 'limit';
             side = Precise["default"].stringGt(amount, '0') ? 'buy' : 'sell';
         }
-        const rawStatus = this.safeStringN(order, ['status', 'finish_as', 'open']);
+        const rawStatus = this.safeStringN(order, ['finish_as', 'status', 'open']);
         let timestamp = this.safeInteger(order, 'create_time_ms');
         if (timestamp === undefined) {
             timestamp = this.safeTimestamp2(order, 'create_time', 'ctime');

package/dist/cjs/src/latoken.js

@@ -201,6 +201,7 @@ class latoken extends latoken$1 {
                 'defaultType': 'spot',
                 'types': {
                     'wallet': 'ACCOUNT_TYPE_WALLET',
+                    'funding': 'ACCOUNT_TYPE_WALLET',
                     'spot': 'ACCOUNT_TYPE_SPOT',
                 },
                 'accounts': {