ccxt 4.0.101 → 4.0.102

package/js/src/bybit.js

@@ -3724,12 +3724,12 @@ export default class bybit extends Exchange {
         }
         else if (isStopLoss || isTakeProfit) {
             if (isStopLoss) {
-                const stopLossTriggerPrice = this.safeValue2(stopLoss, 'triggerPrice', 'stopPrice', stopLoss);
-                request['stopLoss'] = this.priceToPrecision(symbol, stopLossTriggerPrice);
+                const slTriggerPrice = this.safeValue2(stopLoss, 'triggerPrice', 'stopPrice', stopLoss);
+                request['stopLoss'] = this.priceToPrecision(symbol, slTriggerPrice);
             }
             if (isTakeProfit) {
-                const takeProfitTriggerPrice = this.safeValue2(takeProfit, 'triggerPrice', 'stopPrice', takeProfit);
-                request['takeProfit'] = this.priceToPrecision(symbol, takeProfitTriggerPrice);
+                const tpTriggerPrice = this.safeValue2(takeProfit, 'triggerPrice', 'stopPrice', takeProfit);
+                request['takeProfit'] = this.priceToPrecision(symbol, tpTriggerPrice);
             }
         }
         if (market['spot']) {
@@ -3838,12 +3838,12 @@ export default class bybit extends Exchange {
             }
             else if (isStopLoss || isTakeProfit) {
                 if (isStopLoss) {
-                    const stopLossTriggerPrice = this.safeValue2(stopLoss, 'triggerPrice', 'stopPrice', stopLoss);
-                    request['stopLoss'] = this.priceToPrecision(symbol, stopLossTriggerPrice);
+                    const slTriggerPrice = this.safeValue2(stopLoss, 'triggerPrice', 'stopPrice', stopLoss);
+                    request['stopLoss'] = this.priceToPrecision(symbol, slTriggerPrice);
                 }
                 if (isTakeProfit) {
-                    const takeProfitTriggerPrice = this.safeValue2(takeProfit, 'triggerPrice', 'stopPrice', takeProfit);
-                    request['takeProfit'] = this.priceToPrecision(symbol, takeProfitTriggerPrice);
+                    const tpTriggerPrice = this.safeValue2(takeProfit, 'triggerPrice', 'stopPrice', takeProfit);
+                    request['takeProfit'] = this.priceToPrecision(symbol, tpTriggerPrice);
                 }
             }
             else {
@@ -4024,12 +4024,12 @@ export default class bybit extends Exchange {
         }
         if (isStopLoss || isTakeProfit) {
             if (isStopLoss) {
-                const stopLossTriggerPrice = this.safeValue2(stopLoss, 'triggerPrice', 'stopPrice', stopLoss);
-                request['stopLoss'] = this.priceToPrecision(symbol, stopLossTriggerPrice);
+                const slTriggerPrice = this.safeValue2(stopLoss, 'triggerPrice', 'stopPrice', stopLoss);
+                request['stopLoss'] = this.priceToPrecision(symbol, slTriggerPrice);
             }
             if (isTakeProfit) {
-                const takeProfitTriggerPrice = this.safeValue2(takeProfit, 'triggerPrice', 'stopPrice', takeProfit);
-                request['takeProfit'] = this.priceToPrecision(symbol, takeProfitTriggerPrice);
+                const tpTriggerPrice = this.safeValue2(takeProfit, 'triggerPrice', 'stopPrice', takeProfit);
+                request['takeProfit'] = this.priceToPrecision(symbol, tpTriggerPrice);
             }
         }
         const clientOrderId = this.safeString(params, 'clientOrderId');
@@ -5999,12 +5999,10 @@ export default class bybit extends Exchange {
         await this.loadMarkets();
         const [enableUnifiedMargin, enableUnifiedAccount] = await this.isUnifiedEnabled();
         const isUnifiedAccount = (enableUnifiedMargin || enableUnifiedAccount);
+        let market = undefined;
         let response = undefined;
-        if (symbol === undefined) {
+        if (isUnifiedAccount) {
             if (marginMode === 'isolated') {
-                if (!isUnifiedAccount) {
-                    throw new NotSupported(this.id + ' setMarginMode() Normal Account not support ISOLATED_MARGIN');
-                }
                 marginMode = 'ISOLATED_MARGIN';
             }
             else if (marginMode === 'cross') {
@@ -6022,44 +6020,70 @@ export default class bybit extends Exchange {
             response = await this.privatePostV5AccountSetMarginMode(this.extend(request, params));
         }
         else {
-            const market = this.market(symbol);
-            let type = undefined;
-            [type, params] = this.getBybitType('setMarginMode', market, params);
-            if (type === 'linear') {
-                if (isUnifiedAccount) {
-                    throw new NotSupported(this.id + ' setMarginMode() with symbol Unified Account only support inverse contract');
+            if (symbol === undefined) {
+                throw new ArgumentsRequired(this.id + ' setMarginMode() requires a symbol parameter for non unified account');
+            }
+            market = this.market(symbol);
+            const isUsdcSettled = market['settle'] === 'USDC';
+            if (isUsdcSettled) {
+                if (marginMode === 'cross') {
+                    marginMode = 'REGULAR_MARGIN';
                 }
-                const isUsdtSettled = market['settle'] === 'USDT';
-                if (!isUsdtSettled) {
-                    throw new NotSupported(this.id + ' setMarginMode() with symbol only support USDT perpetual / inverse contract');
+                else if (marginMode === 'portfolio') {
+                    marginMode = 'PORTFOLIO_MARGIN';
                 }
-            }
-            else if (type !== 'inverse') {
-                throw new NotSupported(this.id + ' setMarginMode() does not support this market type');
-            }
-            let tradeMode = undefined;
-            if (marginMode === 'cross') {
-                tradeMode = 0;
-            }
-            else if (marginMode === 'isolated') {
-                tradeMode = 1;
+                else {
+                    throw new NotSupported(this.id + ' setMarginMode() for usdc market marginMode must be either [cross, portfolio]');
+                }
+                const request = {
+                    'setMarginMode': marginMode,
+                };
+                response = await this.privatePostV5AccountSetMarginMode(this.extend(request, params));
             }
             else {
-                throw new NotSupported(this.id + ' setMarginMode() with symbol marginMode must be either [isolated, cross]');
-            }
-            const leverage = this.safeString(params, 'leverage');
-            params = this.omit(params, ['leverage']);
-            if (leverage === undefined) {
-                throw new ArgumentsRequired(this.id + ' setMarginMode() with symbol requires leverage');
+                let type = undefined;
+                [type, params] = this.getBybitType('setPositionMode', market, params);
+                let tradeMode = undefined;
+                if (marginMode === 'cross') {
+                    tradeMode = 0;
+                }
+                else if (marginMode === 'isolated') {
+                    tradeMode = 1;
+                }
+                else {
+                    throw new NotSupported(this.id + ' setMarginMode() with symbol marginMode must be either [isolated, cross]');
+                }
+                let sellLeverage = undefined;
+                let buyLeverage = undefined;
+                const leverage = this.safeString(params, 'leverage');
+                if (leverage === undefined) {
+                    sellLeverage = this.safeString2(params, 'sell_leverage', 'sellLeverage');
+                    buyLeverage = this.safeString2(params, 'buy_leverage', 'buyLeverage');
+                    if (sellLeverage === undefined && buyLeverage === undefined) {
+                        throw new ArgumentsRequired(this.id + ' setMarginMode() requires a leverage parameter or sell_leverage and buy_leverage parameters');
+                    }
+                    if (buyLeverage === undefined) {
+                        buyLeverage = sellLeverage;
+                    }
+                    if (sellLeverage === undefined) {
+                        sellLeverage = buyLeverage;
+                    }
+                    params = this.omit(params, ['buy_leverage', 'sell_leverage', 'sellLeverage', 'buyLeverage']);
+                }
+                else {
+                    sellLeverage = leverage;
+                    buyLeverage = leverage;
+                    params = this.omit(params, 'leverage');
+                }
+                const request = {
+                    'category': type,
+                    'symbol': market['id'],
+                    'tradeMode': tradeMode,
+                    'buyLeverage': buyLeverage,
+                    'sellLeverage': sellLeverage,
+                };
+                response = await this.privatePostV5PositionSwitchIsolated(this.extend(request, params));
             }
-            const request = {
-                'category': type,
-                'symbol': market['id'],
-                'tradeMode': tradeMode,
-                'buyLeverage': leverage,
-                'sellLeverage': leverage,
-            };
-            response = await this.privatePostV5PositionSwitchIsolated(this.extend(request, params));
         }
         return response;
     }

package/js/src/gemini.js

@@ -224,6 +224,7 @@ export default class gemini extends Exchange {
                     'InsufficientFunds': InsufficientFunds,
                     'InvalidJson': BadRequest,
                     'InvalidNonce': InvalidNonce,
+                    'InvalidApiKey': AuthenticationError,
                     'InvalidOrderType': InvalidOrder,
                     'InvalidPrice': InvalidOrder,
                     'InvalidQuantity': InvalidOrder,

package/js/src/pro/binance.js

@@ -505,8 +505,8 @@ export default class binance extends binanceRest {
         for (let i = 0; i < symbols.length; i++) {
             const symbol = symbols[i];
             const market = this.market(symbol);
-            const messageHash = market['lowercaseId'] + '@' + name;
-            subParams.push(messageHash);
+            const currentMessageHash = market['lowercaseId'] + '@' + name;
+            subParams.push(currentMessageHash);
         }
         const messageHash = 'multipleTrades::' + symbols.join(',');
         const query = this.omit(params, 'type');
@@ -824,10 +824,10 @@ export default class binance extends binanceRest {
         const hashes = [];
         for (let i = 0; i < symbolsAndTimeframes.length; i++) {
             const data = symbolsAndTimeframes[i];
-            const symbol = data[0];
-            const timeframe = data[1];
-            const interval = this.safeString(this.timeframes, timeframe, timeframe);
-            const market = this.market(symbol);
+            const symbolString = data[0];
+            const timeframeString = data[1];
+            const interval = this.safeString(this.timeframes, timeframeString, timeframeString);
+            const market = this.market(symbolString);
             let marketId = market['lowercaseId'];
             if (name === 'indexPriceKline') {
                 // weird behavior for index price kline we can't use the perp suffix
@@ -835,7 +835,7 @@ export default class binance extends binanceRest {
             }
             const topic = marketId + '@' + name + '_' + interval;
             subParams.push(topic);
-            hashes.push(symbol + '#' + timeframe);
+            hashes.push(symbolString + '#' + timeframeString);
         }
         const messageHash = 'multipleOHLCV::' + hashes.join(',');
         const url = this.urls['api']['ws'][type] + '/' + this.stream(type, messageHash);

package/js/src/pro/bybit.js

@@ -364,17 +364,17 @@ export default class bybit extends bybitRest {
         let firstSymbol = undefined;
         for (let i = 0; i < symbolsAndTimeframes.length; i++) {
             const data = symbolsAndTimeframes[i];
-            let symbol = this.safeString(data, 0);
-            const timeframe = this.safeString(data, 1);
-            const market = this.market(symbol);
-            symbol = market['symbol'];
+            let symbolString = this.safeString(data, 0);
+            const timeframeString = this.safeString(data, 1);
+            const market = this.market(symbolString);
+            symbolString = market['symbol'];
             if (i === 0) {
                 firstSymbol = market['symbol'];
             }
-            const timeframeId = this.safeString(this.timeframes, timeframe, timeframe);
+            const timeframeId = this.safeString(this.timeframes, timeframeString, timeframeString);
             const topic = 'kline.' + timeframeId + '.' + market['id'];
             topics.push(topic);
-            hashes.push(symbol + '#' + timeframe);
+            hashes.push(symbolString + '#' + timeframeString);
         }
         const messageHash = 'multipleOHLCV::' + hashes.join(',');
         const url = this.getUrlByMarketType(firstSymbol, false, params);
@@ -921,8 +921,8 @@ export default class bybit extends bybitRest {
         }
         const keys = Object.keys(symbols);
         for (let i = 0; i < keys.length; i++) {
-            const messageHash = 'myTrades:' + keys[i];
-            client.resolve(trades, messageHash);
+            const currentMessageHash = 'myTrades:' + keys[i];
+            client.resolve(trades, currentMessageHash);
         }
         // non-symbol specific
         const messageHash = 'myTrades';
@@ -1054,25 +1054,26 @@ export default class bybit extends bybitRest {
         const first = this.safeValue(rawOrders, 0, {});
         const category = this.safeString(first, 'category');
         const isSpot = category === 'spot';
-        let parser = undefined;
-        if (isSpot) {
-            parser = 'parseWsSpotOrder';
-        }
-        else {
-            parser = 'parseContractOrder';
+        if (!isSpot) {
             rawOrders = this.safeValue(rawOrders, 'result', rawOrders);
         }
         const symbols = {};
         for (let i = 0; i < rawOrders.length; i++) {
-            const parsed = this[parser](rawOrders[i]);
+            let parsed = undefined;
+            if (isSpot) {
+                parsed = this.parseWsSpotOrder(rawOrders[i]);
+            }
+            else {
+                parsed = this.parseOrder(rawOrders[i]);
+            }
             const symbol = parsed['symbol'];
             symbols[symbol] = true;
             orders.append(parsed);
         }
         const symbolsArray = Object.keys(symbols);
         for (let i = 0; i < symbolsArray.length; i++) {
-            const messageHash = 'orders:' + symbolsArray[i];
-            client.resolve(orders, messageHash);
+            const currentMessageHash = 'orders:' + symbolsArray[i];
+            client.resolve(orders, currentMessageHash);
         }
         const messageHash = 'orders';
         client.resolve(orders, messageHash);

package/js/src/pro/coinbasepro.js

@@ -526,11 +526,11 @@ export default class coinbasepro extends coinbaseproRest {
         //         reason: 'filled'
         //     }
         //
-        let orders = this.orders;
-        if (orders === undefined) {
+        let currentOrders = this.orders;
+        if (currentOrders === undefined) {
             const limit = this.safeInteger(this.options, 'ordersLimit', 1000);
-            orders = new ArrayCacheBySymbolById(limit);
-            this.orders = orders;
+            currentOrders = new ArrayCacheBySymbolById(limit);
+            this.orders = currentOrders;
         }
         const type = this.safeString(message, 'type');
         const marketId = this.safeString(message, 'product_id');
@@ -567,9 +567,9 @@ export default class coinbasepro extends coinbaseproRest {
                         let totalAmount = 0;
                         const trades = previousOrder['trades'];
                         for (let i = 0; i < trades.length; i++) {
-                            const trade = trades[i];
-                            totalCost = this.sum(totalCost, trade['cost']);
-                            totalAmount = this.sum(totalAmount, trade['amount']);
+                            const tradeEntry = trades[i];
+                            totalCost = this.sum(totalCost, tradeEntry['cost']);
+                            totalAmount = this.sum(totalAmount, tradeEntry['amount']);
                         }
                         if (totalAmount > 0) {
                             previousOrder['average'] = totalCost / totalAmount;
@@ -697,12 +697,12 @@ export default class coinbasepro extends coinbaseproRest {
             client.resolve(ticker, messageHash);
             const messageHashes = this.findMessageHashes(client, 'tickers::');
             for (let i = 0; i < messageHashes.length; i++) {
-                const messageHash = messageHashes[i];
-                const parts = messageHash.split('::');
+                const currentMessageHash = messageHashes[i];
+                const parts = currentMessageHash.split('::');
                 const symbolsString = parts[1];
                 const symbols = symbolsString.split(',');
                 if (this.inArray(symbol, symbols)) {
-                    client.resolve(ticker, messageHash);
+                    client.resolve(ticker, currentMessageHash);
                 }
             }
         }

package/js/src/pro/kucoin.js

@@ -238,15 +238,15 @@ export default class kucoin extends kucoinRest {
         client.resolve(ticker, 'tickers');
         const messageHashes = this.findMessageHashes(client, 'tickers::');
         for (let i = 0; i < messageHashes.length; i++) {
-            const messageHash = messageHashes[i];
-            const parts = messageHash.split('::');
+            const currentMessageHash = messageHashes[i];
+            const parts = currentMessageHash.split('::');
             const symbolsString = parts[1];
             const symbols = symbolsString.split(',');
             const tickers = this.filterByArray(this.tickers, 'symbol', symbols);
             const tickersSymbols = Object.keys(tickers);
             const numTickers = tickersSymbols.length;
             if (numTickers > 0) {
-                client.resolve(tickers, messageHash);
+                client.resolve(tickers, currentMessageHash);
             }
         }
     }

package/package.json

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

package/skip-tests.json

@@ -537,7 +537,6 @@
         }
     },
     "coinbasepro": {
-		"skipPhpAsync":true,
         "skipMethods": {
             "fetchStatus": "request timeout",
             "fetchCurrencies": {
@@ -547,7 +546,6 @@
         }
     },
     "coinbaseprime": {
-		"skipPhpAsync":true,
         "skipMethods": {
             "fetchStatus": "request timeout",
             "fetchCurrencies": {
@@ -780,7 +778,6 @@
         "skipWs": true
     },
     "huobi": {
-		"skipPhpAsync": true,
         "skipWs": true,
         "skipMethods": {
             "loadMarkets": {
@@ -1018,7 +1015,9 @@
         "skipMethods": {
             "fetchTickers": {
                 "quoteVolume": "quoteVolume >= baseVolume * low is failing",
-                "baseVolume": "quoteVolume >= baseVolume * low is failing"
+                "baseVolume": "quoteVolume >= baseVolume * low is failing",
+                "ask": "https://app.travis-ci.com/github/ccxt/ccxt/builds/266029139",
+                "bid": "https://app.travis-ci.com/github/ccxt/ccxt/builds/266029139"
             },
             "fetchTicker": {
                 "quoteVolume": "quoteVolume >= baseVolume * low is failing",
@@ -1036,9 +1035,7 @@
         }
     },
     "mexc": {
-	"skip": "OnMaintenance https://www.mexc.com/support/articles/17827791510263",
         "skipWs": true,
-        "skipPhpAsync": "Connection ended before receiving response...",
         "skipMethods": {
             "loadMarkets":{
                 "currencyIdAndCode": "messed"
@@ -1283,7 +1280,6 @@
         }
     },
 	"woo": {
-		"skipPhpAsync": true,
         "skipMethods":{
             "loadMarkets":{
                 "active": "undefined",

package/js/src/abstract/bkex.d.ts

@@ -1,61 +0,0 @@
-import { implicitReturnType } from '../base/types.js';
-import { Exchange as _Exchange } from '../base/Exchange.js';
-interface Exchange {
-    publicSpotGetCommonSymbols(params?: {}): Promise<implicitReturnType>;
-    publicSpotGetCommonCurrencys(params?: {}): Promise<implicitReturnType>;
-    publicSpotGetCommonTimestamp(params?: {}): Promise<implicitReturnType>;
-    publicSpotGetQKline(params?: {}): Promise<implicitReturnType>;
-    publicSpotGetQTickers(params?: {}): Promise<implicitReturnType>;
-    publicSpotGetQTickerPrice(params?: {}): Promise<implicitReturnType>;
-    publicSpotGetQDepth(params?: {}): Promise<implicitReturnType>;
-    publicSpotGetQDeals(params?: {}): Promise<implicitReturnType>;
-    publicSwapGetMarketCandle(params?: {}): Promise<implicitReturnType>;
-    publicSwapGetMarketDeals(params?: {}): Promise<implicitReturnType>;
-    publicSwapGetMarketDepth(params?: {}): Promise<implicitReturnType>;
-    publicSwapGetMarketFundingRate(params?: {}): Promise<implicitReturnType>;
-    publicSwapGetMarketIndex(params?: {}): Promise<implicitReturnType>;
-    publicSwapGetMarketRiskLimit(params?: {}): Promise<implicitReturnType>;
-    publicSwapGetMarketSymbols(params?: {}): Promise<implicitReturnType>;
-    publicSwapGetMarketTickerPrice(params?: {}): Promise<implicitReturnType>;
-    publicSwapGetMarketTickers(params?: {}): Promise<implicitReturnType>;
-    publicSwapGetServerPing(params?: {}): Promise<implicitReturnType>;
-    privateSpotGetUApiInfo(params?: {}): Promise<implicitReturnType>;
-    privateSpotGetUAccountBalance(params?: {}): Promise<implicitReturnType>;
-    privateSpotGetUWalletAddress(params?: {}): Promise<implicitReturnType>;
-    privateSpotGetUWalletDepositRecord(params?: {}): Promise<implicitReturnType>;
-    privateSpotGetUWalletWithdrawRecord(params?: {}): Promise<implicitReturnType>;
-    privateSpotGetUOrderOpenOrders(params?: {}): Promise<implicitReturnType>;
-    privateSpotGetUOrderOpenOrderDetail(params?: {}): Promise<implicitReturnType>;
-    privateSpotGetUOrderHistoryOrders(params?: {}): Promise<implicitReturnType>;
-    privateSpotPostUAccountTransfer(params?: {}): Promise<implicitReturnType>;
-    privateSpotPostUWalletWithdraw(params?: {}): Promise<implicitReturnType>;
-    privateSpotPostUOrderCreate(params?: {}): Promise<implicitReturnType>;
-    privateSpotPostUOrderCancel(params?: {}): Promise<implicitReturnType>;
-    privateSpotPostUOrderBatchCreate(params?: {}): Promise<implicitReturnType>;
-    privateSpotPostUOrderBatchCancel(params?: {}): Promise<implicitReturnType>;
-    privateSwapGetAccountBalance(params?: {}): Promise<implicitReturnType>;
-    privateSwapGetAccountBalanceRecord(params?: {}): Promise<implicitReturnType>;
-    privateSwapGetAccountOrder(params?: {}): Promise<implicitReturnType>;
-    privateSwapGetAccountOrderForced(params?: {}): Promise<implicitReturnType>;
-    privateSwapGetAccountPosition(params?: {}): Promise<implicitReturnType>;
-    privateSwapGetEntrustFinished(params?: {}): Promise<implicitReturnType>;
-    privateSwapGetEntrustUnFinish(params?: {}): Promise<implicitReturnType>;
-    privateSwapGetOrderFinished(params?: {}): Promise<implicitReturnType>;
-    privateSwapGetOrderFinishedInfo(params?: {}): Promise<implicitReturnType>;
-    privateSwapGetOrderUnFinish(params?: {}): Promise<implicitReturnType>;
-    privateSwapGetPositionInfo(params?: {}): Promise<implicitReturnType>;
-    privateSwapPostAccountSetLeverage(params?: {}): Promise<implicitReturnType>;
-    privateSwapPostEntrustAdd(params?: {}): Promise<implicitReturnType>;
-    privateSwapPostEntrustCancel(params?: {}): Promise<implicitReturnType>;
-    privateSwapPostOrderBatchCancel(params?: {}): Promise<implicitReturnType>;
-    privateSwapPostOrderBatchOpen(params?: {}): Promise<implicitReturnType>;
-    privateSwapPostOrderCancel(params?: {}): Promise<implicitReturnType>;
-    privateSwapPostOrderClose(params?: {}): Promise<implicitReturnType>;
-    privateSwapPostOrderCloseAll(params?: {}): Promise<implicitReturnType>;
-    privateSwapPostOrderOpen(params?: {}): Promise<implicitReturnType>;
-    privateSwapPostPositionSetSpSl(params?: {}): Promise<implicitReturnType>;
-    privateSwapPostPositionUpdate(params?: {}): Promise<implicitReturnType>;
-}
-declare abstract class Exchange extends _Exchange {
-}
-export default Exchange;

package/js/src/abstract/bkex.js

@@ -1,11 +0,0 @@
-// ----------------------------------------------------------------------------
-
-// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
-// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
-// EDIT THE CORRESPONDENT .ts FILE INSTEAD
-
-// -------------------------------------------------------------------------------
-import { Exchange as _Exchange } from '../base/Exchange.js';
-class Exchange extends _Exchange {
-}
-export default Exchange;