ccxt 4.2.38 → 4.2.40

package/dist/cjs/ccxt.js

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

package/dist/cjs/src/ascendex.js

@@ -274,11 +274,14 @@ class ascendex extends ascendex$1 {
                     'fillResponseFromRequest': true,
                 },
                 'networks': {
-                    'BSC': 'BEP20 (BSC)',
+                    'BSC': 'BEP20 ' + '(BSC)',
                     'ARB': 'arbitrum',
                     'SOL': 'Solana',
                     'AVAX': 'avalanche C chain',
                     'OMNI': 'Omni',
+                    'TRC': 'TRC20',
+                    'TRX': 'TRC20',
+                    'ERC': 'ERC20',
                 },
                 'networksById': {
                     'BEP20 (BSC)': 'BSC',
@@ -286,6 +289,16 @@ class ascendex extends ascendex$1 {
                     'Solana': 'SOL',
                     'avalanche C chain': 'AVAX',
                     'Omni': 'OMNI',
+                    'TRC20': 'TRC20',
+                    'ERC20': 'ERC20',
+                    'GO20': 'GO20',
+                    'BEP2': 'BEP2',
+                    'Bitcoin': 'BTC',
+                    'Bitcoin ABC': 'BCH',
+                    'Litecoin': 'LTC',
+                    'Matic Network': 'MATIC',
+                    'xDai': 'STAKE',
+                    'Akash': 'AKT',
                 },
             },
             'exceptions': {
@@ -2375,8 +2388,8 @@ class ascendex extends ascendex$1 {
         const tag = this.safeString(depositAddress, tagId);
         this.checkAddress(address);
         const code = (currency === undefined) ? undefined : currency['code'];
-        const chainName = this.safeString(depositAddress, 'chainName');
-        const network = this.safeNetwork(chainName);
+        const chainName = this.safeString(depositAddress, 'blockchain');
+        const network = this.networkIdToCode(chainName, code);
         return {
             'currency': code,
             'address': address,
@@ -2386,20 +2399,7 @@ class ascendex extends ascendex$1 {
         };
     }
     safeNetwork(networkId) {
-        const networksById = {
-            'TRC20': 'TRC20',
-            'ERC20': 'ERC20',
-            'GO20': 'GO20',
-            'BEP2': 'BEP2',
-            'BEP20 (BSC)': 'BEP20',
-            'Bitcoin': 'BTC',
-            'Bitcoin ABC': 'BCH',
-            'Litecoin': 'LTC',
-            'Matic Network': 'MATIC',
-            'Solana': 'SOL',
-            'xDai': 'STAKE',
-            'Akash': 'AKT',
-        };
+        const networksById = this.safeDict(this.options, 'networksById');
         return this.safeString(networksById, networkId, networkId);
     }
     async fetchDepositAddress(code, params = {}) {
@@ -2407,16 +2407,20 @@ class ascendex extends ascendex$1 {
          * @method
          * @name ascendex#fetchDepositAddress
          * @description fetch the deposit address for a currency associated with this account
+         * @see https://ascendex.github.io/ascendex-pro-api/#query-deposit-addresses
          * @param {string} code unified currency code
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.network] unified network code for deposit chain
          * @returns {object} an [address structure]{@link https://docs.ccxt.com/#/?id=address-structure}
          */
         await this.loadMarkets();
         const currency = this.currency(code);
-        const chainName = this.safeString(params, 'chainName');
-        params = this.omit(params, 'chainName');
+        const networkCode = this.safeString2(params, 'network', 'chainName');
+        const networkId = this.networkCodeToId(networkCode);
+        params = this.omit(params, ['chainName']);
         const request = {
             'asset': currency['id'],
+            'blockchain': networkId,
         };
         const response = await this.v1PrivateGetWalletDepositAddress(this.extend(request, params));
         //
@@ -2452,22 +2456,22 @@ class ascendex extends ascendex$1 {
         //         }
         //     }
         //
-        const data = this.safeValue(response, 'data', {});
-        const addresses = this.safeValue(data, 'address', []);
+        const data = this.safeDict(response, 'data', {});
+        const addresses = this.safeList(data, 'address', []);
         const numAddresses = addresses.length;
         let address = undefined;
         if (numAddresses > 1) {
             const addressesByChainName = this.indexBy(addresses, 'chainName');
-            if (chainName === undefined) {
+            if (networkId === undefined) {
                 const chainNames = Object.keys(addressesByChainName);
                 const chains = chainNames.join(', ');
                 throw new errors.ArgumentsRequired(this.id + ' fetchDepositAddress() returned more than one address, a chainName parameter is required, one of ' + chains);
             }
-            address = this.safeValue(addressesByChainName, chainName, {});
+            address = this.safeDict(addressesByChainName, networkId, {});
         }
         else {
             // first address
-            address = this.safeValue(addresses, 0, {});
+            address = this.safeDict(addresses, 0, {});
         }
         const result = this.parseDepositAddress(address, currency);
         return this.extend(result, {

package/dist/cjs/src/base/Exchange.js

@@ -1936,6 +1936,18 @@ class Exchange {
     async setLeverage(leverage, symbol = undefined, params = {}) {
         throw new errors.NotSupported(this.id + ' setLeverage() is not supported yet');
     }
+    async fetchLeverage(symbol, params = {}) {
+        throw new errors.NotSupported(this.id + ' fetchLeverage() is not supported yet');
+    }
+    async setPositionMode(hedged, symbol = undefined, params = {}) {
+        throw new errors.NotSupported(this.id + ' setPositionMode() is not supported yet');
+    }
+    async setMarginMode(marginMode, symbol = undefined, params = {}) {
+        throw new errors.NotSupported(this.id + ' setMarginMode() is not supported yet');
+    }
+    async fetchDepositAddressesByNetwork(code, params = {}) {
+        throw new errors.NotSupported(this.id + ' fetchDepositAddressesByNetwork() is not supported yet');
+    }
     async fetchOpenInterestHistory(symbol, timeframe = '1h', since = undefined, limit = undefined, params = {}) {
         throw new errors.NotSupported(this.id + ' fetchOpenInterestHistory() is not supported yet');
     }
@@ -3162,11 +3174,11 @@ class Exchange {
          * @param {string|undefined} currencyCode unified currency code, but this argument is not required by default, unless there is an exchange (like huobi) that needs an override of the method to be able to pass currencyCode argument additionally
          * @returns {string|undefined} unified network code
          */
-        const networkCodesByIds = this.safeValue(this.options, 'networksById', {});
+        const networkCodesByIds = this.safeDict(this.options, 'networksById', {});
         let networkCode = this.safeString(networkCodesByIds, networkId, networkId);
         // replace mainnet network-codes (i.e. ERC20->ETH)
         if (currencyCode !== undefined) {
-            const defaultNetworkCodeReplacements = this.safeValue(this.options, 'defaultNetworkCodeReplacements', {});
+            const defaultNetworkCodeReplacements = this.safeDict(this.options, 'defaultNetworkCodeReplacements', {});
             if (currencyCode in defaultNetworkCodeReplacements) {
                 const replacementObject = this.safeDict(defaultNetworkCodeReplacements, currencyCode, {});
                 networkCode = this.safeString(replacementObject, networkCode, networkCode);
@@ -3184,14 +3196,14 @@ class Exchange {
     }
     defaultNetworkCode(currencyCode) {
         let defaultNetworkCode = undefined;
-        const defaultNetworks = this.safeValue(this.options, 'defaultNetworks', {});
+        const defaultNetworks = this.safeDict(this.options, 'defaultNetworks', {});
         if (currencyCode in defaultNetworks) {
             // if currency had set its network in "defaultNetworks", use it
             defaultNetworkCode = defaultNetworks[currencyCode];
         }
         else {
             // otherwise, try to use the global-scope 'defaultNetwork' value (even if that network is not supported by currency, it doesn't make any problem, this will be just used "at first" if currency supports this network at all)
-            const defaultNetwork = this.safeValue(this.options, 'defaultNetwork');
+            const defaultNetwork = this.safeDict(this.options, 'defaultNetwork');
             if (defaultNetwork !== undefined) {
                 defaultNetworkCode = defaultNetwork;
             }
@@ -3696,14 +3708,14 @@ class Exchange {
         throw new errors.NotSupported(this.id + ' fetchStatus() is not supported yet');
     }
     async fetchFundingFee(code, params = {}) {
-        const warnOnFetchFundingFee = this.safeValue(this.options, 'warnOnFetchFundingFee', true);
+        const warnOnFetchFundingFee = this.safeBool(this.options, 'warnOnFetchFundingFee', true);
         if (warnOnFetchFundingFee) {
             throw new errors.NotSupported(this.id + ' fetchFundingFee() method is deprecated, it will be removed in July 2022, please, use fetchTransactionFee() or set exchange.options["warnOnFetchFundingFee"] = false to suppress this warning');
         }
         return await this.fetchTransactionFee(code, params);
     }
     async fetchFundingFees(codes = undefined, params = {}) {
-        const warnOnFetchFundingFees = this.safeValue(this.options, 'warnOnFetchFundingFees', true);
+        const warnOnFetchFundingFees = this.safeBool(this.options, 'warnOnFetchFundingFees', true);
         if (warnOnFetchFundingFees) {
             throw new errors.NotSupported(this.id + ' fetchFundingFees() method is deprecated, it will be removed in July 2022. Please, use fetchTransactionFees() or set exchange.options["warnOnFetchFundingFees"] = false to suppress this warning');
         }
@@ -3754,7 +3766,7 @@ class Exchange {
             throw new errors.NotSupported(this.id + ' fetchIsolatedBorrowRate() is not supported yet');
         }
         const borrowRates = await this.fetchIsolatedBorrowRates(params);
-        const rate = this.safeValue(borrowRates, symbol);
+        const rate = this.safeDict(borrowRates, symbol);
         if (rate === undefined) {
             throw new errors.ExchangeError(this.id + ' fetchIsolatedBorrowRate() could not find the borrow rate for market symbol ' + symbol);
         }
@@ -3815,7 +3827,7 @@ class Exchange {
     }
     handleMarketTypeAndParams(methodName, market = undefined, params = {}) {
         const defaultType = this.safeString2(this.options, 'defaultType', 'type', 'spot');
-        const methodOptions = this.safeValue(this.options, methodName);
+        const methodOptions = this.safeDict(this.options, methodName);
         let methodType = defaultType;
         if (methodOptions !== undefined) {
             if (typeof methodOptions === 'string') {
@@ -3851,7 +3863,7 @@ class Exchange {
             }
             // if it was not defined in market object
             if (subType === undefined) {
-                const values = this.handleOptionAndParams(undefined, methodName, 'subType', defaultValue); // no need to re-test params here
+                const values = this.handleOptionAndParams({}, methodName, 'subType', defaultValue); // no need to re-test params here
                 subType = values[0];
             }
         }
@@ -3907,7 +3919,7 @@ class Exchange {
             const market = this.market(symbol);
             symbol = market['symbol'];
             const tickers = await this.fetchTickers([symbol], params);
-            const ticker = this.safeValue(tickers, symbol);
+            const ticker = this.safeDict(tickers, symbol);
             if (ticker === undefined) {
                 throw new errors.NullResponse(this.id + ' fetchTickers() could not find a ticker for ' + symbol);
             }
@@ -3944,7 +3956,7 @@ class Exchange {
         return order['status'];
     }
     async fetchUnifiedOrder(order, params = {}) {
-        return await this.fetchOrder(this.safeValue(order, 'id'), this.safeValue(order, 'symbol'), params);
+        return await this.fetchOrder(this.safeString(order, 'id'), this.safeString(order, 'symbol'), params);
     }
     async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
         throw new errors.NotSupported(this.id + ' createOrder() is not supported yet');
@@ -4214,7 +4226,7 @@ class Exchange {
         throw new errors.NotSupported(this.id + ' cancelAllOrdersWs() is not supported yet');
     }
     async cancelUnifiedOrder(order, params = {}) {
-        return this.cancelOrder(this.safeValue(order, 'id'), this.safeValue(order, 'symbol'), params);
+        return this.cancelOrder(this.safeString(order, 'id'), this.safeString(order, 'symbol'), params);
     }
     async fetchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         if (this.has['fetchOpenOrders'] && this.has['fetchClosedOrders']) {
@@ -4706,7 +4718,7 @@ class Exchange {
         return result;
     }
     isTriggerOrder(params) {
-        const isTrigger = this.safeValue2(params, 'trigger', 'stop');
+        const isTrigger = this.safeBool2(params, 'trigger', 'stop');
         if (isTrigger) {
             params = this.omit(params, ['trigger', 'stop']);
         }
@@ -4722,7 +4734,7 @@ class Exchange {
          * @returns {boolean} true if a post only order, false otherwise
          */
         const timeInForce = this.safeStringUpper(params, 'timeInForce');
-        let postOnly = this.safeValue2(params, 'postOnly', 'post_only', false);
+        let postOnly = this.safeBool2(params, 'postOnly', 'post_only', false);
         // we assume timeInForce is uppercase from safeStringUpper (params, 'timeInForce')
         const ioc = timeInForce === 'IOC';
         const fok = timeInForce === 'FOK';
@@ -4916,7 +4928,7 @@ class Exchange {
          * @param {string} account key for account name in this.options['accountsByType']
          * @returns the exchange specific account name or the isolated margin id for transfers
          */
-        const accountsByType = this.safeValue(this.options, 'accountsByType', {});
+        const accountsByType = this.safeDict(this.options, 'accountsByType', {});
         const lowercaseAccount = account.toLowerCase();
         if (lowercaseAccount in accountsByType) {
             return accountsByType[lowercaseAccount];
@@ -5393,7 +5405,7 @@ class Exchange {
         return input;
     }
     handleUntilOption(key, request, params, multiplier = 1) {
-        const until = this.safeValue2(params, 'until', 'till');
+        const until = this.safeInteger2(params, 'until', 'till');
         if (until !== undefined) {
             request[key] = this.parseToInt(until * multiplier);
             params = this.omit(params, ['until', 'till']);