ccxt 4.1.95 → 4.1.96

package/dist/cjs/src/coinbase.js

@@ -2363,6 +2363,12 @@ class coinbase extends coinbase$1 {
         //                 "base_size": "0.2",
         //                 "limit_price": "0.006",
         //                 "post_only": false
+        //             },
+        //             "stop_limit_stop_limit_gtc": {
+        //                 "base_size": "48.54",
+        //                 "limit_price": "6.998",
+        //                 "stop_price": "7.0687",
+        //                 "stop_direction": "STOP_DIRECTION_STOP_DOWN"
         //             }
         //         },
         //         "side": "SELL",
@@ -2396,11 +2402,11 @@ class coinbase extends coinbase$1 {
             market = this.market(symbol);
         }
         const orderConfiguration = this.safeValue(order, 'order_configuration', {});
-        const limitGTC = this.safeValue(orderConfiguration, 'limit_limit_gtc', {});
-        const limitGTD = this.safeValue(orderConfiguration, 'limit_limit_gtd', {});
-        const stopLimitGTC = this.safeValue(orderConfiguration, 'stop_limit_stop_limit_gtc', {});
-        const stopLimitGTD = this.safeValue(orderConfiguration, 'stop_limit_stop_limit_gtd', {});
-        const marketIOC = this.safeValue(orderConfiguration, 'market_market_ioc', {});
+        const limitGTC = this.safeValue(orderConfiguration, 'limit_limit_gtc');
+        const limitGTD = this.safeValue(orderConfiguration, 'limit_limit_gtd');
+        const stopLimitGTC = this.safeValue(orderConfiguration, 'stop_limit_stop_limit_gtc');
+        const stopLimitGTD = this.safeValue(orderConfiguration, 'stop_limit_stop_limit_gtd');
+        const marketIOC = this.safeValue(orderConfiguration, 'market_market_ioc');
         const isLimit = ((limitGTC !== undefined) || (limitGTD !== undefined));
         const isStop = ((stopLimitGTC !== undefined) || (stopLimitGTD !== undefined));
         let price = undefined;

package/dist/cjs/src/cryptocom.js

@@ -1907,6 +1907,7 @@ class cryptocom extends cryptocom$1 {
         const timestamp = this.safeInteger(ticker, 't');
         const marketId = this.safeString(ticker, 'i');
         market = this.safeMarket(marketId, market, '_');
+        const quote = this.safeString(market, 'quote');
         const last = this.safeString(ticker, 'a');
         return this.safeTicker({
             'symbol': market['symbol'],
@@ -1927,7 +1928,7 @@ class cryptocom extends cryptocom$1 {
             'percentage': this.safeString(ticker, 'c'),
             'average': undefined,
             'baseVolume': this.safeString(ticker, 'v'),
-            'quoteVolume': this.safeString(ticker, 'vv'),
+            'quoteVolume': (quote === 'USD') ? this.safeString(ticker, 'vv') : undefined,
             'info': ticker,
         }, market);
     }

package/dist/cjs/src/delta.js

@@ -31,6 +31,8 @@ class delta extends delta$1 {
                 'addMargin': true,
                 'cancelAllOrders': true,
                 'cancelOrder': true,
+                'closeAllPositions': true,
+                'closePosition': false,
                 'createOrder': true,
                 'createReduceOnlyOrder': true,
                 'editOrder': true,
@@ -3175,6 +3177,29 @@ class delta extends delta$1 {
             'info': greeks,
         };
     }
+    async closeAllPositions(params = {}) {
+        /**
+         * @method
+         * @name delta#closeAllPositions
+         * @description closes all open positions for a market type
+         * @see https://docs.delta.exchange/#close-all-positions
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {int} [params.user_id] the users id
+         * @returns {object[]} A list of [position structures]{@link https://docs.ccxt.com/#/?id=position-structure}
+         */
+        await this.loadMarkets();
+        const request = {
+            'close_all_portfolio': true,
+            'close_all_isolated': true,
+            // 'user_id': 12345,
+        };
+        const response = await this.privatePostPositionsCloseAll(this.extend(request, params));
+        //
+        // {"result":{},"success":true}
+        //
+        const position = this.parsePosition(this.safeValue(response, 'result', {}));
+        return [position];
+    }
     sign(path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
         const requestPath = '/' + this.version + '/' + this.implodeParams(path, params);
         let url = this.urls['api'][api] + requestPath;

package/dist/cjs/src/gate.js

@@ -6992,7 +6992,7 @@ class gate extends gate$1 {
     async closePosition(symbol, side = undefined, params = {}) {
         /**
          * @method
-         * @name gate#closePositions
+         * @name gate#closePosition
          * @description closes open positions for a market
          * @see https://www.gate.io/docs/developers/apiv4/en/#create-a-futures-order
          * @see https://www.gate.io/docs/developers/apiv4/en/#create-a-futures-order-2
@@ -7000,7 +7000,7 @@ class gate extends gate$1 {
          * @param {string} symbol Unified CCXT market symbol
          * @param {string} side 'buy' or 'sell'
          * @param {object} [params] extra parameters specific to the okx api endpoint
-         * @returns {[object]} [A list of position structures]{@link https://docs.ccxt.com/#/?id=position-structure}
+         * @returns {object[]} [A list of position structures]{@link https://docs.ccxt.com/#/?id=position-structure}
          */
         const request = {
             'close': true,

package/dist/cjs/src/kraken.js

@@ -824,7 +824,6 @@ class kraken extends kraken$1 {
         //         "o":"2571.56000"
         //     }
         //
-        const timestamp = this.milliseconds();
         const symbol = this.safeSymbol(undefined, market);
         const v = this.safeValue(ticker, 'v', []);
         const baseVolume = this.safeString(v, 1);
@@ -839,8 +838,8 @@ class kraken extends kraken$1 {
         const ask = this.safeValue(ticker, 'a', []);
         return this.safeTicker({
             'symbol': symbol,
-            'timestamp': timestamp,
-            'datetime': this.iso8601(timestamp),
+            'timestamp': undefined,
+            'datetime': undefined,
             'high': this.safeString(high, 1),
             'low': this.safeString(low, 1),
             'bid': this.safeString(bid, 0),
@@ -1354,8 +1353,12 @@ class kraken extends kraken$1 {
          * @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 exchange API endpoint
-         * @param {bool} params.postOnly
-         * @param {bool} params.reduceOnly
+         * @param {bool} [params.postOnly] if true, the order will only be posted to the order book and not executed immediately
+         * @param {bool} [params.reduceOnly] *margin only* indicates if this order is to reduce the size of a position
+         * @param {float} [params.stopLossPrice] *margin only* the price that a stop loss order is triggered at
+         * @param {float} [params.takeProfitPrice] *margin only* the price that a take profit order is triggered at
+         * @param {string} [params.trailingStopPrice] *margin only* the quote amount to trail away from the current market price
+         * @param {string} [params.trigger] *margin only* the activation price type, 'last' or 'index', default is 'last'
          * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         await this.loadMarkets();
@@ -1610,50 +1613,48 @@ class kraken extends kraken$1 {
         if (clientOrderId !== undefined) {
             request['userref'] = clientOrderId;
         }
-        //
-        //     market
-        //     limit (price = limit price)
-        //     stop-loss (price = stop loss trigger price)
-        //     take-profit (price = take profit trigger price)
-        //     stop-loss-limit (price = stop loss trigger price, price2 = triggered limit price)
-        //     take-profit-limit (price = take profit trigger price, price2 = triggered limit price)
-        //     settle-position
-        //
+        const stopLossTriggerPrice = this.safeString(params, 'stopLossPrice');
+        const takeProfitTriggerPrice = this.safeString(params, 'takeProfitPrice');
+        const isStopLossTriggerOrder = stopLossTriggerPrice !== undefined;
+        const isTakeProfitTriggerOrder = takeProfitTriggerPrice !== undefined;
+        const isStopLossOrTakeProfitTrigger = isStopLossTriggerOrder || isTakeProfitTriggerOrder;
+        const trailingStopPrice = this.safeString(params, 'trailingStopPrice');
+        const isTrailingStopPriceOrder = trailingStopPrice !== undefined;
         if (type === 'limit') {
             request['price'] = this.priceToPrecision(symbol, price);
         }
-        else if ((type === 'stop-loss') || (type === 'take-profit')) {
-            const stopPrice = this.safeNumber2(params, 'price', 'stopPrice', price);
-            if (stopPrice === undefined) {
-                throw new errors.ArgumentsRequired(this.id + method + ' requires a price argument or a price/stopPrice parameter for a ' + type + ' order');
+        let reduceOnly = this.safeValue2(params, 'reduceOnly', 'reduce_only');
+        if (isStopLossOrTakeProfitTrigger) {
+            if (isStopLossTriggerOrder) {
+                request['price'] = this.priceToPrecision(symbol, stopLossTriggerPrice);
+                request['ordertype'] = 'stop-loss-limit';
             }
-            else {
-                request['price'] = this.priceToPrecision(symbol, stopPrice);
+            else if (isTakeProfitTriggerOrder) {
+                request['price'] = this.priceToPrecision(symbol, takeProfitTriggerPrice);
+                request['ordertype'] = 'take-profit-limit';
             }
-        }
-        else if ((type === 'stop-loss-limit') || (type === 'take-profit-limit')) {
-            const stopPrice = this.safeNumber2(params, 'price', 'stopPrice');
-            const limitPrice = this.safeNumber(params, 'price2');
-            const stopPriceDefined = (stopPrice !== undefined);
-            const limitPriceDefined = (limitPrice !== undefined);
-            if (stopPriceDefined && limitPriceDefined) {
-                request['price'] = this.priceToPrecision(symbol, stopPrice);
-                request['price2'] = this.priceToPrecision(symbol, limitPrice);
-            }
-            else if ((price === undefined) || (!(stopPriceDefined || limitPriceDefined))) {
-                throw new errors.ArgumentsRequired(this.id + method + ' requires a price argument and/or price/stopPrice/price2 parameters for a ' + type + ' order');
+            request['price2'] = this.priceToPrecision(symbol, price);
+            reduceOnly = true;
+        }
+        else if (isTrailingStopPriceOrder) {
+            const trailingStopActivationPriceType = this.safeString(params, 'trigger', 'last');
+            const trailingStopPriceString = '+' + trailingStopPrice;
+            request['trigger'] = trailingStopActivationPriceType;
+            reduceOnly = true;
+            if (type === 'limit') {
+                const trailingStopLimitPriceString = '+' + this.numberToString(price);
+                request['price'] = trailingStopPriceString;
+                request['price2'] = trailingStopLimitPriceString;
+                request['ordertype'] = 'trailing-stop-limit';
             }
             else {
-                if (stopPriceDefined) {
-                    request['price'] = this.priceToPrecision(symbol, stopPrice);
-                    request['price2'] = this.priceToPrecision(symbol, price);
-                }
-                else if (limitPriceDefined) {
-                    request['price'] = this.priceToPrecision(symbol, price);
-                    request['price2'] = this.priceToPrecision(symbol, limitPrice);
-                }
+                request['price'] = trailingStopPriceString;
+                request['ordertype'] = 'trailing-stop';
             }
         }
+        if (reduceOnly) {
+            request['reduce_only'] = 'true'; // not using boolean in this case, because the urlencodedNested transforms it into 'True' string
+        }
         let close = this.safeValue(params, 'close');
         if (close !== undefined) {
             close = this.extend({}, close);
@@ -1677,11 +1678,7 @@ class kraken extends kraken$1 {
         if (postOnly) {
             request['oflags'] = 'post';
         }
-        const reduceOnly = this.safeValue(params, 'reduceOnly');
-        if (reduceOnly) {
-            request['reduce_only'] = true;
-        }
-        params = this.omit(params, ['price', 'stopPrice', 'price2', 'close', 'timeInForce', 'reduceOnly']);
+        params = this.omit(params, ['timeInForce', 'reduceOnly', 'stopLossPrice', 'takeProfitPrice', 'trailingStopPrice']);
         return [request, params];
     }
     async editOrder(id, symbol, type, side, amount = undefined, price = undefined, params = {}) {
@@ -1697,6 +1694,10 @@ class kraken extends kraken$1 {
          * @param {float} amount how much of the currency you want to trade in units of the 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 exchange API endpoint
+         * @param {float} [params.stopLossPrice] *margin only* the price that a stop loss order is triggered at
+         * @param {float} [params.takeProfitPrice] *margin only* the price that a take profit order is triggered at
+         * @param {string} [params.trailingStopPrice] *margin only* the quote price away from the current market price
+         * @param {string} [params.trigger] *margin only* the activation price type, 'last' or 'index', default is 'last'
          * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         await this.loadMarkets();

package/dist/cjs/src/krakenfutures.js

@@ -841,20 +841,12 @@ class krakenfutures extends krakenfutures$1 {
         });
     }
     createOrderRequest(symbol, type, side, amount, price = undefined, params = {}) {
+        const market = this.market(symbol);
         type = this.safeString(params, 'orderType', type);
         const timeInForce = this.safeString(params, 'timeInForce');
-        const stopPrice = this.safeString(params, 'stopPrice');
         let postOnly = false;
         [postOnly, params] = this.handlePostOnly(type === 'market', type === 'post', params);
-        const clientOrderId = this.safeString2(params, 'clientOrderId', 'cliOrdId');
-        params = this.omit(params, ['clientOrderId', 'cliOrdId']);
-        if ((type === 'stp' || type === 'take_profit') && stopPrice === undefined) {
-            throw new errors.ArgumentsRequired(this.id + ' createOrder requires params.stopPrice when type is ' + type);
-        }
-        if (stopPrice !== undefined && type !== 'take_profit') {
-            type = 'stp';
-        }
-        else if (postOnly) {
+        if (postOnly) {
             type = 'post';
         }
         else if (timeInForce === 'ioc') {
@@ -867,17 +859,49 @@ class krakenfutures extends krakenfutures$1 {
             type = 'mkt';
         }
         const request = {
-            'orderType': type,
-            'symbol': this.marketId(symbol),
+            'symbol': market['id'],
             'side': side,
             'size': amount,
         };
-        if (price !== undefined) {
-            request['limitPrice'] = price;
-        }
+        const clientOrderId = this.safeString2(params, 'clientOrderId', 'cliOrdId');
         if (clientOrderId !== undefined) {
             request['cliOrdId'] = clientOrderId;
         }
+        const triggerPrice = this.safeString2(params, 'triggerPrice', 'stopPrice');
+        const isTriggerOrder = triggerPrice !== undefined;
+        const stopLossTriggerPrice = this.safeString(params, 'stopLossPrice');
+        const takeProfitTriggerPrice = this.safeString(params, 'takeProfitPrice');
+        const isStopLossTriggerOrder = stopLossTriggerPrice !== undefined;
+        const isTakeProfitTriggerOrder = takeProfitTriggerPrice !== undefined;
+        const isStopLossOrTakeProfitTrigger = isStopLossTriggerOrder || isTakeProfitTriggerOrder;
+        const triggerSignal = this.safeString(params, 'triggerSignal', 'last');
+        let reduceOnly = this.safeValue(params, 'reduceOnly');
+        if (isStopLossOrTakeProfitTrigger || isTriggerOrder) {
+            request['triggerSignal'] = triggerSignal;
+        }
+        if (isTriggerOrder) {
+            type = 'stp';
+            request['stopPrice'] = this.priceToPrecision(symbol, triggerPrice);
+        }
+        else if (isStopLossOrTakeProfitTrigger) {
+            reduceOnly = true;
+            if (isStopLossTriggerOrder) {
+                type = 'stp';
+                request['stopPrice'] = this.priceToPrecision(symbol, stopLossTriggerPrice);
+            }
+            else if (isTakeProfitTriggerOrder) {
+                type = 'take_profit';
+                request['stopPrice'] = this.priceToPrecision(symbol, takeProfitTriggerPrice);
+            }
+        }
+        if (reduceOnly) {
+            request['reduceOnly'] = true;
+        }
+        request['orderType'] = type;
+        if (price !== undefined) {
+            request['limitPrice'] = price;
+        }
+        params = this.omit(params, ['clientOrderId', 'timeInForce', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice']);
         return this.extend(request, params);
     }
     async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
@@ -885,19 +909,22 @@ class krakenfutures extends krakenfutures$1 {
          * @method
          * @name krakenfutures#createOrder
          * @description Create an order on the exchange
-         * @param {string} symbol market symbol
-         * @param {string} type One of 'limit', 'market', 'take_profit'
-         * @param {string} side buy or sell
-         * @param {int} amount Contract quantity
-         * @param {float} [price] Limit order price
-         * @param {float} [params.stopPrice] The stop price associated with a stop or take profit order, Required if orderType is stp or take_profit, Must not have more than 2 decimal places, Note that for stop orders, limitPrice denotes the worst price at which the stop or take_profit order can get filled at. If no limitPrice is provided the stop or take_profit order will trigger a market order,
-         * @param {bool} [params.reduceOnly] Set as true if you wish the order to only reduce an existing position, Any order which increases an existing position will be rejected, Default false,
-         * @param {bool} [params.postOnly] Set as true if you wish to make a postOnly order, Default false
-         * @param {string} [params.triggerSignal] If placing a stp or take_profit, the signal used for trigger, One of: 'mark', 'index', 'last', last is market price
-         * @param {string} [params.cliOrdId] UUID The order identity that is specified from the user, It must be globally unique
+         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-order-management-send-order
+         * @param {string} symbol unified market symbol
+         * @param {string} type 'limit' or 'market'
+         * @param {string} side 'buy' or 'sell'
+         * @param {float} amount number of contracts
+         * @param {float} [price] limit order price
+         * @param {bool} [params.reduceOnly] set as true if you wish the order to only reduce an existing position, any order which increases an existing position will be rejected, default is false
+         * @param {bool} [params.postOnly] set as true if you wish to make a postOnly order, default is false
          * @param {string} [params.clientOrderId] UUID The order identity that is specified from the user, It must be globally unique
+         * @param {float} [params.triggerPrice] the price that a stop order is triggered at
+         * @param {float} [params.stopLossPrice] the price that a stop loss order is triggered at
+         * @param {float} [params.takeProfitPrice] the price that a take profit order is triggered at
+         * @param {string} [params.triggerSignal] for triggerPrice, stopLossPrice and takeProfitPrice orders, the trigger price type, 'last', 'mark' or 'index', default is 'last'
          */
         await this.loadMarkets();
+        const market = this.market(symbol);
         const orderRequest = this.createOrderRequest(symbol, type, side, amount, price, params);
         const response = await this.privatePostSendorder(orderRequest);
         //
@@ -933,7 +960,7 @@ class krakenfutures extends krakenfutures$1 {
         const sendStatus = this.safeValue(response, 'sendStatus');
         const status = this.safeString(sendStatus, 'status');
         this.verifyOrderActionSuccess(status, 'createOrder', ['filled']);
-        return this.parseOrder(sendStatus);
+        return this.parseOrder(sendStatus, market);
     }
     async createOrders(orders, params = {}) {
         /**

package/dist/cjs/src/kucoin.js

@@ -44,6 +44,9 @@ class kucoin extends kucoin$1 {
                 'createStopLimitOrder': true,
                 'createStopMarketOrder': true,
                 'createStopOrder': true,
+                'createMarketBuyOrderWithCost': true,
+                'createMarketOrderWithCost': true,
+                'createMarketSellOrderWithCost': true,
                 'editOrder': true,
                 'fetchAccounts': true,
                 'fetchBalance': true,
@@ -205,6 +208,10 @@ class kucoin extends kucoin$1 {
                         'stop-order': 8,
                         'stop-order/{orderId}': 3,
                         'stop-order/queryOrderByClientOid': 3,
+                        'oco/order/{orderId}': 2,
+                        'oco/order/details/{orderId}': 2,
+                        'oco/client-order/{clientOid}': 2,
+                        'oco/orders': 2,
                         // margin trading
                         'hf/margin/orders/active': 4,
                         'hf/margin/orders/done': 10,
@@ -212,6 +219,7 @@ class kucoin extends kucoin$1 {
                         'hf/margin/orders/client-order/{clientOid}': 5,
                         'hf/margin/fills': 5,
                         'etf/info': 25,
+                        'margin/currencies': 20,
                         'risk/limit/strategy': 20,
                         'isolated/symbols': 20,
                         'isolated/account/{symbol}': 50,
@@ -247,6 +255,7 @@ class kucoin extends kucoin$1 {
                         'orders/test': 2,
                         'orders/multi': 3,
                         'stop-order': 2,
+                        'oco/order': 2,
                         // margin trading
                         'hf/margin/order': 5,
                         'hf/margin/order/test': 5,
@@ -272,12 +281,16 @@ class kucoin extends kucoin$1 {
                         'hf/orders/sync/client-order/{clientOid}': 1,
                         'hf/orders/cancel/{orderId}': 2,
                         'hf/orders': 2,
+                        'hf/orders/cancelAll': 30,
                         'orders/{orderId}': 3,
                         'order/client-order/{clientOid}': 5,
                         'orders': 20,
                         'stop-order/{orderId}': 3,
                         'stop-order/cancelOrderByClientOid': 5,
                         'stop-order/cancel': 3,
+                        'oco/order/{orderId}': 3,
+                        'oco/client-order/{clientOid}': 3,
+                        'oco/orders': 3,
                         // margin trading
                         'hf/margin/orders/{orderId}': 5,
                         'hf/margin/orders/client-order/{clientOid}': 5,
@@ -298,6 +311,7 @@ class kucoin extends kucoin$1 {
                         'index/query': 3,
                         'mark-price/{symbol}/current': 4.5,
                         'premium/query': 4.5,
+                        'trade-statistics': 4.5,
                         'funding-rate/{symbol}/current': 3,
                         'timestamp': 3,
                         'status': 6,
@@ -346,6 +360,7 @@ class kucoin extends kucoin$1 {
                     },
                     'delete': {
                         'orders/{orderId}': 1.5,
+                        'orders/client-order/{clientOid}': 1.5,
                         'orders': 45,
                         'stopOrders': 22.5, // 15FW
                     },
@@ -533,6 +548,10 @@ class kucoin extends kucoin$1 {
                             'market/orderbook/level2': 'v3',
                             'market/orderbook/level3': 'v3',
                             'market/orderbook/level{level}': 'v3',
+                            'oco/order/{orderId}': 'v3',
+                            'oco/order/details/{orderId}': 'v3',
+                            'oco/client-order/{clientOid}': 'v3',
+                            'oco/orders': 'v3',
                             // margin trading
                             'hf/margin/orders/active': 'v3',
                             'hf/margin/orders/done': 'v3',
@@ -540,6 +559,7 @@ class kucoin extends kucoin$1 {
                             'hf/margin/orders/client-order/{clientOid}': 'v3',
                             'hf/margin/fills': 'v3',
                             'etf/info': 'v3',
+                            'margin/currencies': 'v3',
                             'margin/borrow': 'v3',
                             'margin/repay': 'v3',
                             'project/list': 'v3',
@@ -556,6 +576,7 @@ class kucoin extends kucoin$1 {
                             'accounts/inner-transfer': 'v2',
                             'transfer-out': 'v3',
                             // spot trading
+                            'oco/order': 'v3',
                             // margin trading
                             'hf/margin/order': 'v3',
                             'hf/margin/order/test': 'v3',
@@ -572,6 +593,9 @@ class kucoin extends kucoin$1 {
                             'hf/margin/orders/{orderId}': 'v3',
                             'hf/margin/orders/client-order/{clientOid}': 'v3',
                             'hf/margin/orders': 'v3',
+                            'oco/order/{orderId}': 'v3',
+                            'oco/client-order/{clientOid}': 'v3',
+                            'oco/orders': 'v3',
                             // margin trading
                         },
                     },
@@ -1927,6 +1951,50 @@ class kucoin extends kucoin$1 {
         const data = this.safeValue(response, 'data', {});
         return this.parseOrder(data, market);
     }
+    async createMarketOrderWithCost(symbol, side, cost, params = {}) {
+        /**
+         * @method
+         * @name kucoin#createMarketOrderWithCost
+         * @description create a market order by providing the symbol, side and cost
+         * @see https://www.kucoin.com/docs/rest/spot-trading/orders/place-order
+         * @param {string} symbol unified symbol of the market to create an order in
+         * @param {string} side 'buy' or 'sell'
+         * @param {float} cost how much you want to trade in units of the quote currency
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        params['cost'] = cost;
+        return await this.createOrder(symbol, 'market', side, cost, undefined, params);
+    }
+    async createMarketBuyOrderWithCost(symbol, cost, params = {}) {
+        /**
+         * @method
+         * @name kucoin#createMarketBuyOrderWithCost
+         * @description create a market buy order by providing the symbol and cost
+         * @see https://www.kucoin.com/docs/rest/spot-trading/orders/place-order
+         * @param {string} symbol unified symbol of the market to create an order in
+         * @param {float} cost how much you want to trade in units of the quote currency
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        return await this.createMarketOrderWithCost(symbol, 'buy', cost, params);
+    }
+    async createMarketSellOrderWithCost(symbol, cost, params = {}) {
+        /**
+         * @method
+         * @name kucoin#createMarketSellOrderWithCost
+         * @description create a market sell order by providing the symbol and cost
+         * @see https://www.kucoin.com/docs/rest/spot-trading/orders/place-order
+         * @param {string} symbol unified symbol of the market to create an order in
+         * @param {float} cost how much you want to trade in units of the quote currency
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        return await this.createMarketOrderWithCost(symbol, 'sell', cost, params);
+    }
     async createOrders(orders, params = {}) {
         /**
          * @method
@@ -2225,9 +2293,11 @@ class kucoin extends kucoin$1 {
         }
         else if (hf) {
             if (symbol === undefined) {
-                throw new errors.ArgumentsRequired(this.id + ' cancelAllOrders() requires a symbol parameter for hf orders');
+                response = await this.privateDeleteHfOrdersCancelAll(this.extend(request, query));
+            }
+            else {
+                response = await this.privateDeleteHfOrders(this.extend(request, query));
             }
-            response = await this.privateDeleteHfOrders(this.extend(request, query));
         }
         else {
             response = await this.privateDeleteOrders(this.extend(request, query));
@@ -2484,7 +2554,7 @@ class kucoin extends kucoin$1 {
                 response = await this.privateGetOrdersOrderId(this.extend(request, params));
             }
         }
-        let responseData = this.safeValue(response, 'data');
+        let responseData = this.safeValue(response, 'data', {});
         if (Array.isArray(responseData)) {
             responseData = this.safeValue(responseData, 0);
         }

package/dist/cjs/src/kucoinfutures.js

@@ -2440,7 +2440,7 @@ class kucoinfutures extends kucoinfutures$1 {
          * @param {string} side not used by kucoinfutures closePositions
          * @param {object} [params] extra parameters specific to the okx api endpoint
          * @param {string} [params.clientOrderId] client order id of the order
-         * @returns {[object]} [A list of position structures]{@link https://docs.ccxt.com/#/?id=position-structure}
+         * @returns {object[]} [A list of position structures]{@link https://docs.ccxt.com/#/?id=position-structure}
          */
         await this.loadMarkets();
         const market = this.market(symbol);

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

@@ -942,14 +942,13 @@ class binance extends binance$1 {
             event = 'ticker';
         }
         let timestamp = undefined;
-        const now = this.milliseconds();
         if (event === 'bookTicker') {
             // take the event timestamp, if available, for spot tickers it is not
-            timestamp = this.safeInteger(message, 'E', now);
+            timestamp = this.safeInteger(message, 'E');
         }
         else {
             // take the timestamp of the closing price for candlestick streams
-            timestamp = this.safeInteger(message, 'C', now);
+            timestamp = this.safeInteger(message, 'C');
         }
         const marketId = this.safeString(message, 's');
         const symbol = this.safeSymbol(marketId, undefined, undefined, marketType);

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

@@ -209,7 +209,6 @@ class bitfinex extends bitfinex$1 {
         //         220.05,        // 10 LOW float Daily low
         //     ]
         //
-        const timestamp = this.milliseconds();
         const marketId = this.safeString(subscription, 'pair');
         const symbol = this.safeSymbol(marketId);
         const channel = 'ticker';
@@ -222,8 +221,8 @@ class bitfinex extends bitfinex$1 {
         }
         const result = {
             'symbol': symbol,
-            'timestamp': timestamp,
-            'datetime': this.iso8601(timestamp),
+            'timestamp': undefined,
+            'datetime': undefined,
             'high': this.safeFloat(message, 9),
             'low': this.safeFloat(message, 10),
             'bid': this.safeFloat(message, 1),

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

@@ -732,7 +732,7 @@ class cex extends cex$1 {
                 'rate': undefined,
             };
         }
-        const timestamp = this.safeInteger(data, 'time', this.milliseconds());
+        const timestamp = this.safeInteger(data, 'time');
         order['timestamp'] = timestamp;
         order['datetime'] = this.iso8601(timestamp);
         order = this.safeOrder(order);

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

@@ -720,7 +720,7 @@ class gate extends gate$1 {
         //   }
         //
         const result = this.safeValue(message, 'result', []);
-        const timestamp = this.safeInteger(message, 'time');
+        const timestamp = this.safeInteger(message, 'time_ms');
         this.balance['info'] = result;
         this.balance['timestamp'] = timestamp;
         this.balance['datetime'] = this.iso8601(timestamp);
@@ -796,7 +796,7 @@ class gate extends gate$1 {
         if (this.newUpdates) {
             return positions;
         }
-        return this.filterBySymbolsSinceLimit(this.positions, symbols, since, limit, true);
+        return this.filterBySymbolsSinceLimit(this.positions[type], symbols, since, limit, true);
     }
     setPositionsCache(client, type, symbols = undefined) {
         if (this.positions === undefined) {

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

@@ -322,11 +322,10 @@ class kraken extends kraken$1 {
             quoteVolume = Precise["default"].stringMul(baseVolume, vwap);
         }
         const last = this.safeString(ticker['c'], 0);
-        const timestamp = this.milliseconds();
         const result = this.safeTicker({
             'symbol': symbol,
-            'timestamp': timestamp,
-            'datetime': this.iso8601(timestamp),
+            'timestamp': undefined,
+            'datetime': undefined,
             'high': this.safeString(ticker['h'], 0),
             'low': this.safeString(ticker['l'], 0),
             'bid': this.safeString(ticker['b'], 0),