ccxt 4.1.100 → 4.2.2

package/js/src/bitstamp.js

@@ -1335,6 +1335,12 @@ export default class bitstamp extends Exchange {
          * @method
          * @name bitstamp#createOrder
          * @description create a trade order
+         * @see https://www.bitstamp.net/api/#tag/Orders/operation/OpenInstantBuyOrder
+         * @see https://www.bitstamp.net/api/#tag/Orders/operation/OpenMarketBuyOrder
+         * @see https://www.bitstamp.net/api/#tag/Orders/operation/OpenLimitBuyOrder
+         * @see https://www.bitstamp.net/api/#tag/Orders/operation/OpenInstantSellOrder
+         * @see https://www.bitstamp.net/api/#tag/Orders/operation/OpenMarketSellOrder
+         * @see https://www.bitstamp.net/api/#tag/Orders/operation/OpenLimitSellOrder
          * @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'
@@ -1345,27 +1351,42 @@ export default class bitstamp extends Exchange {
          */
         await this.loadMarkets();
         const market = this.market(symbol);
-        let method = 'privatePost' + this.capitalize(side);
         const request = {
             'pair': market['id'],
             'amount': this.amountToPrecision(symbol, amount),
         };
+        const clientOrderId = this.safeString2(params, 'client_order_id', 'clientOrderId');
+        if (clientOrderId !== undefined) {
+            request['client_order_id'] = clientOrderId;
+            params = this.omit(params, ['clientOrderId']);
+        }
+        let response = undefined;
+        const capitalizedSide = this.capitalize(side);
         if (type === 'market') {
-            method += 'Market';
+            if (capitalizedSide === 'Buy') {
+                response = await this.privatePostBuyMarketPair(this.extend(request, params));
+            }
+            else {
+                response = await this.privatePostSellMarketPair(this.extend(request, params));
+            }
         }
         else if (type === 'instant') {
-            method += 'Instant';
+            if (capitalizedSide === 'Buy') {
+                response = await this.privatePostBuyInstantPair(this.extend(request, params));
+            }
+            else {
+                response = await this.privatePostSellInstantPair(this.extend(request, params));
+            }
         }
         else {
             request['price'] = this.priceToPrecision(symbol, price);
+            if (capitalizedSide === 'Buy') {
+                response = await this.privatePostBuyPair(this.extend(request, params));
+            }
+            else {
+                response = await this.privatePostSellPair(this.extend(request, params));
+            }
         }
-        method += 'Pair';
-        const clientOrderId = this.safeString2(params, 'client_order_id', 'clientOrderId');
-        if (clientOrderId !== undefined) {
-            request['client_order_id'] = clientOrderId;
-            params = this.omit(params, ['client_order_id', 'clientOrderId']);
-        }
-        const response = await this[method](this.extend(request, params));
         const order = this.parseOrder(response, market);
         order['type'] = type;
         return order;
@@ -1398,13 +1419,16 @@ export default class bitstamp extends Exchange {
         await this.loadMarkets();
         let market = undefined;
         const request = {};
-        let method = 'privatePostCancelAllOrders';
+        let response = undefined;
         if (symbol !== undefined) {
             market = this.market(symbol);
             request['pair'] = market['id'];
-            method = 'privatePostCancelAllOrdersPair';
+            response = await this.privatePostCancelAllOrdersPair(this.extend(request, params));
+        }
+        else {
+            response = await this.privatePostCancelAllOrders(this.extend(request, params));
         }
-        return await this[method](this.extend(request, params));
+        return response;
     }
     parseOrderStatus(status) {
         const statuses = {

package/js/src/cex.js

@@ -1171,14 +1171,16 @@ export default class cex extends Exchange {
          */
         await this.loadMarkets();
         const request = {};
-        let method = 'privatePostOpenOrders';
         let market = undefined;
+        let orders = undefined;
         if (symbol !== undefined) {
             market = this.market(symbol);
             request['pair'] = market['id'];
-            method += 'Pair';
+            orders = await this.privatePostOpenOrdersPair(this.extend(request, params));
+        }
+        else {
+            orders = await this.privatePostOpenOrders(this.extend(request, params));
         }
-        const orders = await this[method](this.extend(request, params));
         for (let i = 0; i < orders.length; i++) {
             orders[i] = this.extend(orders[i], { 'status': 'open' });
         }
@@ -1200,10 +1202,9 @@ export default class cex extends Exchange {
             throw new ArgumentsRequired(this.id + ' fetchClosedOrders() requires a symbol argument');
         }
         await this.loadMarkets();
-        const method = 'privatePostArchivedOrdersPair';
         const market = this.market(symbol);
         const request = { 'pair': market['id'] };
-        const response = await this[method](this.extend(request, params));
+        const response = await this.privatePostArchivedOrdersPair(this.extend(request, params));
         return this.parseOrders(response, market, since, limit);
     }
     async fetchOrder(id, symbol = undefined, params = {}) {

package/js/src/deribit.js

@@ -1320,14 +1320,19 @@ export default class deribit extends Exchange {
             'instrument_name': market['id'],
             'include_old': true,
         };
-        const method = (since === undefined) ? 'publicGetGetLastTradesByInstrument' : 'publicGetGetLastTradesByInstrumentAndTime';
         if (since !== undefined) {
             request['start_timestamp'] = since;
         }
         if (limit !== undefined) {
             request['count'] = Math.min(limit, 1000); // default 10
         }
-        const response = await this[method](this.extend(request, params));
+        let response = undefined;
+        if (since === undefined) {
+            response = await this.publicGetGetLastTradesByInstrument(this.extend(request, params));
+        }
+        else {
+            response = await this.publicGetGetLastTradesByInstrumentAndTime(this.extend(request, params));
+        }
         //
         //      {
         //          "jsonrpc":"2.0",
@@ -1824,9 +1829,14 @@ export default class deribit extends Exchange {
                 request['time_in_force'] = 'fill_or_kill';
             }
         }
-        const method = 'privateGet' + this.capitalize(side);
         params = this.omit(params, ['timeInForce', 'stopLossPrice', 'takeProfitPrice', 'postOnly', 'reduceOnly']);
-        const response = await this[method](this.extend(request, params));
+        let response = undefined;
+        if (this.capitalize(side) === 'Buy') {
+            response = await this.privateGetBuy(this.extend(request, params));
+        }
+        else {
+            response = await this.privateGetSell(this.extend(request, params));
+        }
         //
         //     {
         //         "jsonrpc": "2.0",
@@ -1941,16 +1951,15 @@ export default class deribit extends Exchange {
          */
         await this.loadMarkets();
         const request = {};
-        let method = undefined;
+        let response = undefined;
         if (symbol === undefined) {
-            method = 'privateGetCancelAll';
+            response = await this.privateGetCancelAll(this.extend(request, params));
         }
         else {
-            method = 'privateGetCancelAllByInstrument';
             const market = this.market(symbol);
             request['instrument_name'] = market['id'];
+            response = await this.privateGetCancelAllByInstrument(this.extend(request, params));
         }
-        const response = await this[method](this.extend(request, params));
         return response;
     }
     async fetchOpenOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
@@ -1967,19 +1976,18 @@ export default class deribit extends Exchange {
         await this.loadMarkets();
         const request = {};
         let market = undefined;
-        let method = undefined;
+        let response = undefined;
         if (symbol === undefined) {
             const code = this.codeFromOptions('fetchOpenOrders', params);
             const currency = this.currency(code);
             request['currency'] = currency['id'];
-            method = 'privateGetGetOpenOrdersByCurrency';
+            response = await this.privateGetGetOpenOrdersByCurrency(this.extend(request, params));
         }
         else {
             market = this.market(symbol);
             request['instrument_name'] = market['id'];
-            method = 'privateGetGetOpenOrdersByInstrument';
+            response = await this.privateGetGetOpenOrdersByInstrument(this.extend(request, params));
         }
-        const response = await this[method](this.extend(request, params));
         const result = this.safeValue(response, 'result', []);
         return this.parseOrders(result, market, since, limit);
     }
@@ -1997,19 +2005,18 @@ export default class deribit extends Exchange {
         await this.loadMarkets();
         const request = {};
         let market = undefined;
-        let method = undefined;
+        let response = undefined;
         if (symbol === undefined) {
             const code = this.codeFromOptions('fetchClosedOrders', params);
             const currency = this.currency(code);
             request['currency'] = currency['id'];
-            method = 'privateGetGetOrderHistoryByCurrency';
+            response = await this.privateGetGetOrderHistoryByCurrency(this.extend(request, params));
         }
         else {
             market = this.market(symbol);
             request['instrument_name'] = market['id'];
-            method = 'privateGetGetOrderHistoryByInstrument';
+            response = await this.privateGetGetOrderHistoryByInstrument(this.extend(request, params));
         }
-        const response = await this[method](this.extend(request, params));
         const result = this.safeValue(response, 'result', []);
         return this.parseOrders(result, market, since, limit);
     }
@@ -2082,34 +2089,33 @@ export default class deribit extends Exchange {
             'include_old': true,
         };
         let market = undefined;
-        let method = undefined;
+        if (limit !== undefined) {
+            request['count'] = limit; // default 10
+        }
+        let response = undefined;
         if (symbol === undefined) {
             const code = this.codeFromOptions('fetchMyTrades', params);
             const currency = this.currency(code);
             request['currency'] = currency['id'];
             if (since === undefined) {
-                method = 'privateGetGetUserTradesByCurrency';
+                response = await this.privateGetGetUserTradesByCurrency(this.extend(request, params));
             }
             else {
-                method = 'privateGetGetUserTradesByCurrencyAndTime';
                 request['start_timestamp'] = since;
+                response = await this.privateGetGetUserTradesByCurrencyAndTime(this.extend(request, params));
             }
         }
         else {
             market = this.market(symbol);
             request['instrument_name'] = market['id'];
             if (since === undefined) {
-                method = 'privateGetGetUserTradesByInstrument';
+                response = await this.privateGetGetUserTradesByInstrument(this.extend(request, params));
             }
             else {
-                method = 'privateGetGetUserTradesByInstrumentAndTime';
                 request['start_timestamp'] = since;
+                response = await this.privateGetGetUserTradesByInstrumentAndTime(this.extend(request, params));
             }
         }
-        if (limit !== undefined) {
-            request['count'] = limit; // default 10
-        }
-        const response = await this[method](this.extend(request, params));
         //
         //     {
         //         "jsonrpc": "2.0",
@@ -2643,7 +2649,13 @@ export default class deribit extends Exchange {
             const transferOptions = this.safeValue(this.options, 'transfer', {});
             method = this.safeString(transferOptions, 'method', 'privateGetSubmitTransferToSubaccount');
         }
-        const response = await this[method](this.extend(request, params));
+        let response = undefined;
+        if (method === 'privateGetSubmitTransferToUser') {
+            response = await this.privateGetSubmitTransferToUser(this.extend(request, params));
+        }
+        else {
+            response = await this.privateGetSubmitTransferToSubaccount(this.extend(request, params));
+        }
         //
         //     {
         //         "jsonrpc": "2.0",

package/js/src/kucoinfutures.js

@@ -1735,14 +1735,18 @@ export default class kucoinfutures extends kucoin {
         const cancelExist = this.safeValue(order, 'cancelExist', false);
         let status = isActive ? 'open' : 'closed';
         status = cancelExist ? 'canceled' : status;
-        const fee = {
-            'currency': feeCurrency,
-            'cost': feeCost,
-        };
+        let fee = undefined;
+        if (feeCost !== undefined) {
+            fee = {
+                'currency': feeCurrency,
+                'cost': feeCost,
+            };
+        }
         const clientOrderId = this.safeString(order, 'clientOid');
         const timeInForce = this.safeString(order, 'timeInForce');
         const stopPrice = this.safeNumber(order, 'stopPrice');
         const postOnly = this.safeValue(order, 'postOnly');
+        const reduceOnly = this.safeValue(order, 'reduceOnly');
         const lastUpdateTimestamp = this.safeInteger(order, 'updatedAt');
         return this.safeOrder({
             'id': orderId,
@@ -1751,6 +1755,7 @@ export default class kucoinfutures extends kucoin {
             'type': type,
             'timeInForce': timeInForce,
             'postOnly': postOnly,
+            'reduceOnly': reduceOnly,
             'side': side,
             'amount': amount,
             'price': price,

package/js/src/lykke.js

@@ -435,7 +435,13 @@ export default class lykke extends Exchange {
         };
         // publicGetTickers or publicGetPrices
         const method = this.safeString(this.options, 'fetchTickerMethod', 'publicGetTickers');
-        const response = await this[method](this.extend(request, params));
+        let response = undefined;
+        if (method === 'publicGetPrices') {
+            response = await this.publicGetPrices(this.extend(request, params));
+        }
+        else {
+            response = await this.publicGetTickers(this.extend(request, params));
+        }
         const ticker = this.safeValue(response, 'payload', []);
         //
         // publicGetTickers
@@ -789,8 +795,13 @@ export default class lykke extends Exchange {
         if (type === 'limit') {
             query['price'] = parseFloat(this.priceToPrecision(market['symbol'], price));
         }
-        const method = 'privatePostOrders' + this.capitalize(type);
-        const result = await this[method](this.extend(query, params));
+        let result = undefined;
+        if (this.capitalize(type) === 'Market') {
+            result = await this.privatePostOrdersMarket(this.extend(query, params));
+        }
+        else {
+            result = await this.privatePostOrdersLimit(this.extend(query, params));
+        }
         //
         // market
         //

package/js/src/poloniexfutures.js

@@ -1192,9 +1192,15 @@ export default class poloniexfutures extends Exchange {
         if (symbol !== undefined) {
             request['symbol'] = this.marketId(symbol);
         }
-        const stop = this.safeValue(params, 'stop');
-        const method = stop ? 'privateDeleteStopOrders' : 'privateDeleteOrders';
-        const response = await this[method](this.extend(request, params));
+        const stop = this.safeValue2(params, 'stop', 'trigger');
+        params = this.omit(params, ['stop', 'trigger']);
+        let response = undefined;
+        if (stop) {
+            response = await this.privateDeleteStopOrders(this.extend(request, params));
+        }
+        else {
+            response = await this.privateDeleteOrders(this.extend(request, params));
+        }
         //
         //   {
         //       "code": "200000",
@@ -1256,9 +1262,9 @@ export default class poloniexfutures extends Exchange {
          * @returns An [array of order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         await this.loadMarkets();
-        const stop = this.safeValue(params, 'stop');
+        const stop = this.safeValue2(params, 'stop', 'trigger');
         const until = this.safeInteger2(params, 'until', 'till');
-        params = this.omit(params, ['stop', 'until', 'till']);
+        params = this.omit(params, ['triger', 'stop', 'until', 'till']);
         if (status === 'closed') {
             status = 'done';
         }
@@ -1280,8 +1286,13 @@ export default class poloniexfutures extends Exchange {
         if (until !== undefined) {
             request['endAt'] = until;
         }
-        const method = stop ? 'privateGetStopOrders' : 'privateGetOrders';
-        const response = await this[method](this.extend(request, params));
+        let response = undefined;
+        if (stop) {
+            response = await this.privateGetStopOrders(this.extend(request, params));
+        }
+        else {
+            response = await this.privateGetOrders(this.extend(request, params));
+        }
         //
         //    {
         //        "code": "200000",
@@ -1391,20 +1402,20 @@ export default class poloniexfutures extends Exchange {
          */
         await this.loadMarkets();
         const request = {};
-        let method = 'privateGetOrdersOrderId';
+        let response = undefined;
         if (id === undefined) {
             const clientOrderId = this.safeString2(params, 'clientOid', 'clientOrderId');
             if (clientOrderId === undefined) {
                 throw new InvalidOrder(this.id + ' fetchOrder() requires parameter id or params.clientOid');
             }
             request['clientOid'] = clientOrderId;
-            method = 'privateGetOrdersByClientOid';
             params = this.omit(params, ['clientOid', 'clientOrderId']);
+            response = await this.privateGetClientOrderIdClientOid(this.extend(request, params));
         }
         else {
             request['order-id'] = id;
+            response = await this.privateGetOrdersOrderId(this.extend(request, params));
         }
-        const response = await this[method](this.extend(request, params));
         //
         //    {
         //        "code": "200000",
@@ -1724,7 +1735,7 @@ export default class poloniexfutures extends Exchange {
         const version = this.safeString(params, 'version', defaultVersion);
         const tail = '/api/' + version + '/' + this.implodeParams(path, params);
         url += tail;
-        const query = this.omit(params, path);
+        const query = this.omit(params, this.extractParams(path));
         const queryLength = Object.keys(query).length;
         if (api === 'public') {
             if (queryLength) {

package/js/src/pro/binance.js

@@ -1117,25 +1117,27 @@ export default class binance extends binanceRest {
         const listenKeyRefreshRate = this.safeInteger(this.options, 'listenKeyRefreshRate', 1200000);
         const delay = this.sum(listenKeyRefreshRate, 10000);
         if (time - lastAuthenticatedTime > delay) {
-            let method = 'publicPostUserDataStream';
+            let response = undefined;
             if (type === 'future') {
-                method = 'fapiPrivatePostListenKey';
+                response = await this.fapiPrivatePostListenKey(query);
             }
             else if (type === 'delivery') {
-                method = 'dapiPrivatePostListenKey';
+                response = await this.dapiPrivatePostListenKey(query);
             }
             else if (type === 'margin' && isCrossMargin) {
-                method = 'sapiPostUserDataStream';
+                response = await this.sapiPostUserDataStream(query);
             }
             else if (isIsolatedMargin) {
-                method = 'sapiPostUserDataStreamIsolated';
                 if (symbol === undefined) {
                     throw new ArgumentsRequired(this.id + ' authenticate() requires a symbol argument for isolated margin mode');
                 }
                 const marketId = this.marketId(symbol);
                 query = this.extend(query, { 'symbol': marketId });
+                response = await this.sapiPostUserDataStreamIsolated(query);
+            }
+            else {
+                response = await this.publicPostUserDataStream(query);
             }
-            const response = await this[method](query);
             this.options[type] = this.extend(options, {
                 'listenKey': this.safeString(response, 'listenKey'),
                 'lastAuthenticatedTime': time,
@@ -1161,26 +1163,27 @@ export default class binance extends binanceRest {
             // A network error happened: we can't renew a listen key that does not exist.
             return;
         }
-        let method = 'publicPutUserDataStream';
         const request = {};
         const symbol = this.safeString(params, 'symbol');
         const sendParams = this.omit(params, ['type', 'symbol']);
-        if (type === 'future') {
-            method = 'fapiPrivatePutListenKey';
-        }
-        else if (type === 'delivery') {
-            method = 'dapiPrivatePutListenKey';
-        }
-        else {
-            request['listenKey'] = listenKey;
-            if (type === 'margin') {
-                request['symbol'] = symbol;
-                method = 'sapiPutUserDataStream';
-            }
-        }
         const time = this.milliseconds();
         try {
-            await this[method](this.extend(request, sendParams));
+            if (type === 'future') {
+                await this.fapiPrivatePutListenKey(this.extend(request, sendParams));
+            }
+            else if (type === 'delivery') {
+                await this.dapiPrivatePutListenKey(this.extend(request, sendParams));
+            }
+            else {
+                request['listenKey'] = listenKey;
+                if (type === 'margin') {
+                    request['symbol'] = symbol;
+                    await this.sapiPutUserDataStream(this.extend(request, sendParams));
+                }
+                else {
+                    await this.publicPutUserDataStream(this.extend(request, sendParams));
+                }
+            }
         }
         catch (error) {
             const url = this.urls['api']['ws'][type] + '/' + this.options[type]['listenKey'];