ccxt 4.2.12 → 4.2.14

package/js/src/lbank.js

@@ -932,13 +932,17 @@ export default class lbank extends Exchange {
         else {
             request['size'] = 600; // max
         }
-        let method = this.safeString(params, 'method');
+        const options = this.safeValue(this.options, 'fetchTrades', {});
+        const defaultMethod = this.safeString(options, 'method', 'spotPublicGetTrades');
+        const method = this.safeString(params, 'method', defaultMethod);
         params = this.omit(params, 'method');
-        if (method === undefined) {
-            const options = this.safeValue(this.options, 'fetchTrades', {});
-            method = this.safeString(options, 'method', 'spotPublicGetTrades');
+        let response = undefined;
+        if (method === 'spotPublicGetSupplementTrades') {
+            response = await this.spotPublicGetSupplementTrades(this.extend(request, params));
+        }
+        else {
+            response = await this.spotPublicGetTrades(this.extend(request, params));
         }
-        const response = await this[method](this.extend(request, params));
         //
         //      {
         //          "result":"true",
@@ -1175,12 +1179,19 @@ export default class lbank extends Exchange {
          * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
          */
         await this.loadMarkets();
-        let method = this.safeString(params, 'method');
-        if (method === undefined) {
-            const options = this.safeValue(this.options, 'fetchBalance', {});
-            method = this.safeString(options, 'method', 'spotPrivatePostSupplementUserInfo');
+        const options = this.safeValue(this.options, 'fetchBalance', {});
+        const defaultMethod = this.safeString(options, 'method', 'spotPrivatePostSupplementUserInfo');
+        const method = this.safeString(params, 'method', defaultMethod);
+        let response = undefined;
+        if (method === 'spotPrivatePostSupplementUserInfoAccount') {
+            response = await this.spotPrivatePostSupplementUserInfoAccount();
+        }
+        else if (method === 'spotPrivatePostUserInfo') {
+            response = await this.spotPrivatePostUserInfo();
+        }
+        else {
+            response = await this.spotPrivatePostSupplementUserInfo();
         }
-        const response = await this[method]();
         //
         //    {
         //        "result": "true",
@@ -1365,14 +1376,17 @@ export default class lbank extends Exchange {
         if (clientOrderId !== undefined) {
             request['custom_id'] = clientOrderId;
         }
-        let method = undefined;
-        method = this.safeString(params, 'method');
+        const options = this.safeValue(this.options, 'createOrder', {});
+        const defaultMethod = this.safeString(options, 'method', 'spotPrivatePostSupplementCreateOrder');
+        const method = this.safeString(params, 'method', defaultMethod);
         params = this.omit(params, 'method');
-        if (method === undefined) {
-            const options = this.safeValue(this.options, 'createOrder', {});
-            method = this.safeString(options, 'method', 'spotPrivatePostSupplementCreateOrder');
+        let response = undefined;
+        if (method === 'spotPrivatePostCreateOrder') {
+            response = await this.spotPrivatePostCreateOrder(this.extend(request, params));
+        }
+        else {
+            response = await this.spotPrivatePostSupplementCreateOrder(this.extend(request, params));
         }
-        const response = await this[method](this.extend(request, params));
         //
         //      {
         //          "result":true,
@@ -1907,13 +1921,18 @@ export default class lbank extends Exchange {
          * @returns {object} an [address structure]{@link https://docs.ccxt.com/#/?id=address-structure}
          */
         await this.loadMarkets();
-        let method = this.safeString(params, 'method');
+        const options = this.safeValue(this.options, 'fetchDepositAddress', {});
+        const defaultMethod = this.safeString(options, 'method', 'fetchDepositAddressDefault');
+        const method = this.safeString(params, 'method', defaultMethod);
         params = this.omit(params, 'method');
-        if (method === undefined) {
-            const options = this.safeValue(this.options, 'fetchDepositAddress', {});
-            method = this.safeString(options, 'method', 'fetchDepositAddressDefault');
+        let response = undefined;
+        if (method === 'fetchDepositAddressSupplement') {
+            response = await this.fetchDepositAddressSupplement(code, params);
         }
-        return await this[method](code, params);
+        else {
+            response = await this.fetchDepositAddressDefault(code, params);
+        }
+        return response;
     }
     async fetchDepositAddressDefault(code, params = {}) {
         await this.loadMarkets();
@@ -2285,13 +2304,16 @@ export default class lbank extends Exchange {
         const isAuthorized = this.checkRequiredCredentials(false);
         let result = undefined;
         if (isAuthorized === true) {
-            let method = this.safeString(params, 'method');
+            const options = this.safeValue(this.options, 'fetchTransactionFees', {});
+            const defaultMethod = this.safeString(options, 'method', 'fetchPrivateTransactionFees');
+            const method = this.safeString(params, 'method', defaultMethod);
             params = this.omit(params, 'method');
-            if (method === undefined) {
-                const options = this.safeValue(this.options, 'fetchTransactionFees', {});
-                method = this.safeString(options, 'method', 'fetchPrivateTransactionFees');
+            if (method === 'fetchPublicTransactionFees') {
+                result = await this.fetchPublicTransactionFees(params);
+            }
+            else {
+                result = await this.fetchPrivateTransactionFees(params);
             }
-            result = await this[method](params);
         }
         else {
             result = await this.fetchPublicTransactionFees(params);
@@ -2429,19 +2451,23 @@ export default class lbank extends Exchange {
          */
         await this.loadMarkets();
         const isAuthorized = this.checkRequiredCredentials(false);
-        let method = undefined;
+        const response = undefined;
         if (isAuthorized === true) {
-            method = this.safeString(params, 'method');
+            const options = this.safeValue(this.options, 'fetchDepositWithdrawFees', {});
+            const defaultMethod = this.safeString(options, 'method', 'fetchPrivateDepositWithdrawFees');
+            const method = this.safeString(params, 'method', defaultMethod);
             params = this.omit(params, 'method');
-            if (method === undefined) {
-                const options = this.safeValue(this.options, 'fetchDepositWithdrawFees', {});
-                method = this.safeString(options, 'method', 'fetchPrivateDepositWithdrawFees');
+            if (method === 'fetchPublicDepositWithdrawFees') {
+                await this.fetchPublicDepositWithdrawFees(codes, params);
+            }
+            else {
+                await this.fetchPrivateDepositWithdrawFees(codes, params);
             }
         }
         else {
-            method = 'fetchPublicDepositWithdrawFees';
+            await this.fetchPublicDepositWithdrawFees(codes, params);
         }
-        return await this[method](codes, params);
+        return response;
     }
     async fetchPrivateDepositWithdrawFees(codes = undefined, params = {}) {
         // complete response

package/js/src/oceanex.js

@@ -475,7 +475,7 @@ export default class oceanex extends Exchange {
             'market': market['id'],
         };
         if (limit !== undefined) {
-            request['limit'] = limit;
+            request['limit'] = Math.min(limit, 1000);
         }
         const response = await this.publicGetTrades(this.extend(request, params));
         //

package/js/src/okx.js

@@ -41,14 +41,18 @@ export default class okx extends Exchange {
                 'createDepositAddress': false,
                 'createMarketBuyOrderWithCost': true,
                 'createMarketSellOrderWithCost': true,
-                'createTrailingPercentOrder': true,
                 'createOrder': true,
                 'createOrders': true,
+                'createOrderWithTakeProfitAndStopLoss': true,
                 'createPostOnlyOrder': true,
                 'createReduceOnlyOrder': true,
+                'createStopLossOrder': true,
                 'createStopLimitOrder': true,
                 'createStopMarketOrder': true,
                 'createStopOrder': true,
+                'createTakeProfitOrder': true,
+                'createTrailingPercentOrder': true,
+                'createTriggerOrder': true,
                 'editOrder': true,
                 'fetchAccounts': true,
                 'fetchBalance': true,
@@ -262,6 +266,7 @@ export default class okx extends Exchange {
                         'sprd/order': 1 / 3,
                         'sprd/orders-pending': 1 / 3,
                         'sprd/orders-history': 1 / 2,
+                        'sprd/orders-history-archive': 1 / 2,
                         'sprd/trades': 1 / 3,
                         // trade
                         'trade/order': 1 / 3,
@@ -2135,17 +2140,14 @@ export default class okx extends Exchange {
         let defaultType = 'Candles';
         if (since !== undefined) {
             const now = this.milliseconds();
-            const difference = now - since;
             const durationInMilliseconds = duration * 1000;
-            // if the since timestamp is more than limit candles back in the past
-            // additional one bar for max offset to round the current day to UTC
-            const calc = (1440 - limit - 1) * durationInMilliseconds;
-            if (difference > calc) {
+            // switch to history candles if since is past the cutoff for current candles
+            const historyBorder = now - ((1440 - 1) * durationInMilliseconds);
+            if (since < historyBorder) {
                 defaultType = 'HistoryCandles';
             }
-            const startTime = Math.max(since - 1, 0);
-            request['before'] = startTime;
-            request['after'] = this.sum(startTime, durationInMilliseconds * limit);
+            request['before'] = since;
+            request['after'] = this.sum(since, durationInMilliseconds * limit);
         }
         const until = this.safeInteger(params, 'until');
         if (until !== undefined) {

package/js/src/phemex.js

@@ -455,7 +455,7 @@ export default class phemex extends Exchange {
                 },
             },
             'options': {
-                'brokerId': 'CCXT',
+                'brokerId': 'CCXT123456',
                 'x-phemex-request-expiry': 60,
                 'createOrderByQuoteRequiresPrice': true,
                 'networks': {
@@ -2480,7 +2480,7 @@ export default class phemex extends Exchange {
         const takeProfit = this.safeValue(params, 'takeProfit');
         const takeProfitDefined = (takeProfit !== undefined);
         if (clientOrderId === undefined) {
-            const brokerId = this.safeString(this.options, 'brokerId');
+            const brokerId = this.safeString(this.options, 'brokerId', 'CCXT123456');
             if (brokerId !== undefined) {
                 request['clOrdID'] = brokerId + this.uuid16();
             }
@@ -4276,6 +4276,13 @@ export default class phemex extends Exchange {
             };
             let payload = '';
             if (method === 'POST') {
+                const isOrderPlacement = (path === 'g-orders') || (path === 'spot/orders') || (path === 'orders');
+                if (isOrderPlacement) {
+                    if (this.safeString(params, 'clOrdID') === undefined) {
+                        const id = this.safeString(this.options, 'brokerId', 'CCXT123456');
+                        params['clOrdID'] = id + this.uuid16();
+                    }
+                }
                 payload = this.json(params);
                 body = payload;
                 headers['Content-Type'] = 'application/json';

package/js/src/pro/kraken.js

@@ -545,7 +545,7 @@ export default class kraken extends krakenRest {
             ],
             'subscription': {
                 'name': name,
-                'interval': this.safeString(this.timeframes, timeframe, timeframe),
+                'interval': this.safeValue(this.timeframes, timeframe, timeframe),
             },
         };
         const request = this.deepExtend(subscribe, params);

package/js/src/pro/okx.d.ts

@@ -13,6 +13,7 @@ export default class okx extends okxRest {
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     handleTicker(client: Client, message: any): any;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
+    watchOHLCVForSymbols(symbolsAndTimeframes: string[][], since?: Int, limit?: Int, params?: {}): Promise<import("../base/types.js").Dictionary<import("../base/types.js").Dictionary<OHLCV[]>>>;
     handleOHLCV(client: Client, message: any): void;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;

package/js/src/pro/okx.js

@@ -23,6 +23,7 @@ export default class okx extends okxRest {
                 'watchOrderBookForSymbols': true,
                 'watchBalance': true,
                 'watchOHLCV': true,
+                'watchOHLCVForSymbols': true,
                 'watchOrders': true,
                 'watchMyTrades': true,
                 'watchPositions': true,
@@ -359,6 +360,50 @@ export default class okx extends okxRest {
         }
         return this.filterBySinceLimit(ohlcv, since, limit, 0, true);
     }
+    async watchOHLCVForSymbols(symbolsAndTimeframes, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name okx#watchOHLCVForSymbols
+         * @description watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+         * @param {string[][]} symbolsAndTimeframes array of arrays containing unified symbols and timeframes to fetch OHLCV data for, example [['BTC/USDT', '1m'], ['LTC/USDT', '5m']]
+         * @param {int} [since] timestamp in ms of the earliest candle to fetch
+         * @param {int} [limit] the maximum amount of candles to fetch
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
+         */
+        const symbolsLength = symbolsAndTimeframes.length;
+        if (symbolsLength === 0 || !Array.isArray(symbolsAndTimeframes[0])) {
+            throw new ArgumentsRequired(this.id + " watchOHLCVForSymbols() requires a an array of symbols and timeframes, like  [['BTC/USDT', '1m'], ['LTC/USDT', '5m']]");
+        }
+        await this.loadMarkets();
+        const topics = [];
+        const messageHashes = [];
+        for (let i = 0; i < symbolsAndTimeframes.length; i++) {
+            const symbolAndTimeframe = symbolsAndTimeframes[i];
+            const sym = symbolAndTimeframe[0];
+            const tf = symbolAndTimeframe[1];
+            const marketId = this.marketId(sym);
+            const interval = this.safeString(this.timeframes, tf, tf);
+            const channel = 'candle' + interval;
+            const topic = {
+                'channel': channel,
+                'instId': marketId,
+            };
+            topics.push(topic);
+            messageHashes.push('multi:' + channel + ':' + sym);
+        }
+        const request = {
+            'op': 'subscribe',
+            'args': topics,
+        };
+        const url = this.getUrl('candle', 'public');
+        const [symbol, timeframe, candles] = await this.watchMultiple(url, messageHashes, request, messageHashes);
+        if (this.newUpdates) {
+            limit = candles.getLimit(symbol, limit);
+        }
+        const filtered = this.filterBySinceLimit(candles, since, limit, 0, true);
+        return this.createOHLCVObject(symbol, timeframe, filtered);
+    }
     handleOHLCV(client, message) {
         //
         //     {
@@ -381,7 +426,7 @@ export default class okx extends okxRest {
         const data = this.safeValue(message, 'data', []);
         const marketId = this.safeString(arg, 'instId');
         const market = this.safeMarket(marketId);
-        const symbol = market['id'];
+        const symbol = market['symbol'];
         const interval = channel.replace('candle', '');
         // use a reverse lookup in a static map instead
         const timeframe = this.findTimeframe(interval);
@@ -395,8 +440,13 @@ export default class okx extends okxRest {
                 this.ohlcvs[symbol][timeframe] = stored;
             }
             stored.append(parsed);
-            const messageHash = channel + ':' + marketId;
+            const messageHash = channel + ':' + market['id'];
             client.resolve(stored, messageHash);
+            // for multiOHLCV we need special object, as opposed to other "multi"
+            // methods, because OHLCV response item does not contain symbol
+            // or timeframe, thus otherwise it would be unrecognizable
+            const messageHashForMulti = 'multi:' + channel + ':' + symbol;
+            client.resolve([symbol, timeframe, stored], messageHashForMulti);
         }
     }
     async watchOrderBook(symbol, limit = undefined, params = {}) {

package/js/src/probit.js

@@ -779,7 +779,6 @@ export default class probit extends Exchange {
         const market = this.market(symbol);
         const request = {
             'market_id': market['id'],
-            'limit': 100,
             'start_time': '1970-01-01T00:00:00.000Z',
             'end_time': this.iso8601(this.milliseconds()),
         };
@@ -787,7 +786,10 @@ export default class probit extends Exchange {
             request['start_time'] = this.iso8601(since);
         }
         if (limit !== undefined) {
-            request['limit'] = Math.min(limit, 10000);
+            request['limit'] = Math.min(limit, 1000);
+        }
+        else {
+            request['limit'] = 1000; // required to set any value
         }
         const response = await this.publicGetTrade(this.extend(request, params));
         //

package/js/src/wavesexchange.js

@@ -2095,7 +2095,7 @@ export default class wavesexchange extends Exchange {
             'priceAsset': market['quoteId'],
         };
         if (limit !== undefined) {
-            request['limit'] = limit;
+            request['limit'] = Math.min(limit, 100);
         }
         if (since !== undefined) {
             request['timeStart'] = since;

package/js/src/woo.d.ts

@@ -14,6 +14,8 @@ export default class woo extends Exchange {
     fetchTradingFees(params?: {}): Promise<{}>;
     fetchCurrencies(params?: {}): Promise<{}>;
     createMarketBuyOrderWithCost(symbol: string, cost: any, params?: {}): Promise<Order>;
+    createTrailingAmountOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, trailingAmount?: any, trailingTriggerPrice?: any, params?: {}): Promise<Order>;
+    createTrailingPercentOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, trailingPercent?: any, trailingTriggerPrice?: any, params?: {}): Promise<Order>;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, params?: {}): Promise<Order>;
     editOrder(id: string, symbol: any, type: any, side: any, amount?: any, price?: any, params?: {}): Promise<Order>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<any>;

package/js/src/woo.js

@@ -44,13 +44,17 @@ export default class woo extends Exchange {
                 'createMarketOrder': false,
                 'createMarketOrderWithCost': false,
                 'createMarketSellOrderWithCost': false,
-                'createTrailingAmountOrder': true,
-                'createTrailingPercentOrder': true,
                 'createOrder': true,
                 'createReduceOnlyOrder': true,
                 'createStopLimitOrder': false,
                 'createStopMarketOrder': false,
                 'createStopOrder': false,
+                'createTrailingAmountOrder': true,
+                'createTrailingPercentOrder': true,
+                'createTriggerOrder': true,
+                'createTakeProfitOrder': true,
+                'createStopLossOrder': true,
+                'createOrderWithTakeProfitAndStopLoss': true,
                 'fetchAccounts': true,
                 'fetchBalance': true,
                 'fetchCanceledOrders': false,
@@ -766,6 +770,56 @@ export default class woo extends Exchange {
         params['createMarketBuyOrderRequiresPrice'] = false;
         return await this.createOrder(symbol, 'market', 'buy', cost, undefined, params);
     }
+    async createTrailingAmountOrder(symbol, type, side, amount, price = undefined, trailingAmount = undefined, trailingTriggerPrice = undefined, params = {}) {
+        /**
+         * @method
+         * @name woo#createTrailingAmountOrder
+         * @description create a trailing order by providing the symbol, type, side, amount, price and trailingAmount
+         * @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 you want to trade in units of the base currency, or number of contracts
+         * @param {float} [price] the price for the order to be filled at, in units of the quote currency, ignored in market orders
+         * @param {float} trailingAmount the quote amount to trail away from the current market price
+         * @param {float} trailingTriggerPrice the price to activate a trailing order, default uses the price argument
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        if (trailingAmount === undefined) {
+            throw new ArgumentsRequired(this.id + ' createTrailingAmountOrder() requires a trailingAmount argument');
+        }
+        if (trailingTriggerPrice === undefined) {
+            throw new ArgumentsRequired(this.id + ' createTrailingAmountOrder() requires a trailingTriggerPrice argument');
+        }
+        params['trailingAmount'] = trailingAmount;
+        params['trailingTriggerPrice'] = trailingTriggerPrice;
+        return await this.createOrder(symbol, type, side, amount, price, params);
+    }
+    async createTrailingPercentOrder(symbol, type, side, amount, price = undefined, trailingPercent = undefined, trailingTriggerPrice = undefined, params = {}) {
+        /**
+         * @method
+         * @name woo#createTrailingPercentOrder
+         * @description create a trailing order by providing the symbol, type, side, amount, price and trailingPercent
+         * @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 you want to trade in units of the base currency, or number of contracts
+         * @param {float} [price] the price for the order to be filled at, in units of the quote currency, ignored in market orders
+         * @param {float} trailingPercent the percent to trail away from the current market price
+         * @param {float} trailingTriggerPrice the price to activate a trailing order, default uses the price argument
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        if (trailingPercent === undefined) {
+            throw new ArgumentsRequired(this.id + ' createTrailingPercentOrder() requires a trailingPercent argument');
+        }
+        if (trailingTriggerPrice === undefined) {
+            throw new ArgumentsRequired(this.id + ' createTrailingPercentOrder() requires a trailingTriggerPrice argument');
+        }
+        params['trailingPercent'] = trailingPercent;
+        params['trailingTriggerPrice'] = trailingTriggerPrice;
+        return await this.createOrder(symbol, type, side, amount, price, params);
+    }
     async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
         /**
          * @method

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccxt",
-  "version": "4.2.12",
+  "version": "4.2.14",
   "description": "A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges",
   "unpkg": "dist/ccxt.browser.js",
   "type": "module",