ccxt 4.4.85 → 4.4.87

package/js/src/gate.js

@@ -111,7 +111,7 @@ export default class gate extends Exchange {
                 'fetchCurrencies': true,
                 'fetchDepositAddress': true,
                 'fetchDepositAddresses': false,
-                'fetchDepositAddressesByNetwork': false,
+                'fetchDepositAddressesByNetwork': true,
                 'fetchDeposits': true,
                 'fetchDepositWithdrawFee': 'emulated',
                 'fetchDepositWithdrawFees': true,
@@ -720,6 +720,16 @@ export default class gate extends Exchange {
                 },
                 'networksById': {
                     'OPETH': 'OP',
+                    'ETH': 'ERC20',
+                    'ERC20': 'ERC20',
+                    'TRX': 'TRC20',
+                    'TRC20': 'TRC20',
+                    'HT': 'HRC20',
+                    'HECO': 'HRC20',
+                    'BSC': 'BEP20',
+                    'BEP20': 'BEP20',
+                    'POLYGON': 'MATIC',
+                    'POL': 'MATIC',
                 },
                 'timeInForce': {
                     'GTC': 'gtc',
@@ -1216,6 +1226,9 @@ export default class gate extends Exchange {
         if (this.options['adjustForTimeDifference']) {
             await this.loadTimeDifference();
         }
+        if (this.checkRequiredCredentials(false)) {
+            await this.loadUnifiedStatus();
+        }
         const sandboxMode = this.safeBool(this.options, 'sandboxMode', false);
         let rawPromises = [
             this.fetchContractMarkets(params),
@@ -1829,88 +1842,93 @@ export default class gate extends Exchange {
         if (apiBackup !== undefined) {
             return undefined;
         }
-        if (this.checkRequiredCredentials(false)) {
-            await this.loadUnifiedStatus();
-        }
         const response = await this.publicSpotGetCurrencies(params);
         //
-        //  [
-        //   {
-        //       "currency": "USDT_ETH",
-        //       "name": "Tether",
-        //       "delisted": false,
-        //       "withdraw_disabled": false,
-        //       "withdraw_delayed": false,
-        //       "deposit_disabled": false,
-        //       "trade_disabled": true,
-        //       "chain": "ETH"
-        //    },
-        //  ]
+        //    [
+        //      {
+        //         "currency": "USDT",
+        //         "name": "Tether",
+        //         "delisted": false,
+        //         "withdraw_disabled": false,
+        //         "withdraw_delayed": false,
+        //         "deposit_disabled": false,
+        //         "trade_disabled": false,
+        //         "fixed_rate": "",
+        //         "chain": "ETH",
+        //         "chains": [
+        //           {
+        //             "name": "ETH",
+        //             "addr": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+        //             "withdraw_disabled": false,
+        //             "withdraw_delayed": false,
+        //             "deposit_disabled": false
+        //           },
+        //           {
+        //             "name": "ARBEVM",
+        //             "addr": "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+        //             "withdraw_disabled": false,
+        //             "withdraw_delayed": false,
+        //             "deposit_disabled": false
+        //           },
+        //           {
+        //             "name": "BSC",
+        //             "addr": "0x55d398326f99059fF775485246999027B3197955",
+        //             "withdraw_disabled": false,
+        //             "withdraw_delayed": false,
+        //             "deposit_disabled": false
+        //           },
+        //         ]
+        //       },
+        //    ]
         //
         const indexedCurrencies = this.indexBy(response, 'currency');
         const result = {};
         for (let i = 0; i < response.length; i++) {
             const entry = response[i];
             const currencyId = this.safeString(entry, 'currency');
-            const parts = currencyId.split('_');
-            const partFirst = this.safeString(parts, 0);
-            // if there's an underscore then the second part is always the chain name (except the _OLD suffix)
-            const currencyName = currencyId.endsWith('_OLD') ? currencyId : partFirst;
-            const withdrawDisabled = this.safeBool(entry, 'withdraw_disabled', false);
-            const depositDisabled = this.safeBool(entry, 'deposit_disabled', false);
-            const tradeDisabled = this.safeBool(entry, 'trade_disabled', false);
-            const precision = this.parseNumber('0.0001'); // temporary safe default, because no value provided from API
-            const code = this.safeCurrencyCode(currencyName);
+            const code = this.safeCurrencyCode(currencyId);
             // check leveraged tokens (e.g. BTC3S, ETH5L)
-            let isLeveragedToken = false;
-            if (currencyId.endsWith('3S') || currencyId.endsWith('3L') || currencyId.endsWith('5S') || currencyId.endsWith('5L')) {
-                const realCurrencyId = currencyId.slice(0, -2);
-                if (realCurrencyId in indexedCurrencies) {
-                    isLeveragedToken = true;
-                }
-            }
-            const type = isLeveragedToken ? 'leveraged' : 'crypto';
-            // some networks are null, they are mostly obsolete & unsupported dead tokens, so we can default their networkId to their tokenname
-            const networkId = this.safeString(entry, 'chain', currencyId);
-            const networkCode = this.networkIdToCode(networkId, code);
-            const networkEntry = {
-                'info': entry,
-                'id': networkId,
-                'network': networkCode,
-                'limits': {
-                    'deposit': {
-                        'min': undefined,
-                        'max': undefined,
-                    },
-                    'withdraw': {
-                        'min': undefined,
-                        'max': undefined,
+            const type = this.isLeveragedCurrency(currencyId, true, indexedCurrencies) ? 'leveraged' : 'crypto';
+            const chains = this.safeList(entry, 'chains', []);
+            const networks = {};
+            for (let j = 0; j < chains.length; j++) {
+                const chain = chains[j];
+                const networkId = this.safeString(chain, 'name');
+                const networkCode = this.networkIdToCode(networkId);
+                networks[networkCode] = {
+                    'info': chain,
+                    'id': networkId,
+                    'network': networkCode,
+                    'active': undefined,
+                    'deposit': !this.safeBool(chain, 'deposit_disabled'),
+                    'withdraw': !this.safeBool(chain, 'withdraw_disabled'),
+                    'fee': undefined,
+                    'precision': this.parseNumber('0.0001'),
+                    'limits': {
+                        'deposit': {
+                            'min': undefined,
+                            'max': undefined,
+                        },
+                        'withdraw': {
+                            'min': undefined,
+                            'max': undefined,
+                        },
                     },
-                },
-                'active': !tradeDisabled,
-                'deposit': !depositDisabled,
-                'withdraw': !withdrawDisabled,
-                'fee': undefined,
-                'precision': precision,
-            };
-            // check if first entry for the specific currency
-            if (!(code in result)) {
-                result[code] = {
-                    'id': currencyName,
-                    'lowerCaseId': currencyName.toLowerCase(),
-                    'code': code,
-                    'type': type,
-                    'precision': precision,
-                    'limits': undefined,
-                    'networks': {},
-                    'info': [], // will be filled below
                 };
             }
-            result[code]['networks'][networkCode] = networkEntry;
-            const info = this.safeList(result[code], 'info', []);
-            info.push(entry);
-            result[code]['info'] = info;
-            result[code] = this.safeCurrencyStructure(result[code]); // this is needed after adding network entry
+            result[code] = this.safeCurrencyStructure({
+                'id': currencyId,
+                'code': code,
+                'name': this.safeString(entry, 'name'),
+                'type': type,
+                'active': !this.safeBool(entry, 'delisted'),
+                'deposit': !this.safeBool(entry, 'deposit_disabled'),
+                'withdraw': !this.safeBool(entry, 'withdraw_disabled'),
+                'fee': undefined,
+                'networks': networks,
+                'precision': this.parseNumber('0.0001'),
+                'info': entry,
+            });
         }
         return result;
     }
@@ -2182,9 +2200,7 @@ export default class gate extends Exchange {
         const chains = this.safeValue(response, 'multichain_addresses', []);
         const currencyId = this.safeString(response, 'currency');
         currency = this.safeCurrency(currencyId, currency);
-        const parsed = this.parseDepositAddresses(chains, [currency['code']], false, {
-            'currency': currency['id'],
-        });
+        const parsed = this.parseDepositAddresses(chains, undefined, false);
         return this.indexBy(parsed, 'network');
     }
     /**
@@ -2202,8 +2218,8 @@ export default class gate extends Exchange {
         let networkCode = undefined;
         [networkCode, params] = this.handleNetworkCodeAndParams(params);
         const chainsIndexedById = await this.fetchDepositAddressesByNetwork(code, params);
-        const selectedNetworkId = this.selectNetworkCodeFromUnifiedNetworks(code, networkCode, chainsIndexedById);
-        return chainsIndexedById[selectedNetworkId];
+        const selectedNetworkIdOrCode = this.selectNetworkCodeFromUnifiedNetworks(code, networkCode, chainsIndexedById);
+        return chainsIndexedById[selectedNetworkIdOrCode];
     }
     parseDepositAddress(depositAddress, currency = undefined) {
         //

package/js/src/hollaex.js

@@ -287,6 +287,14 @@ export default class hollaex extends Exchange {
                     'BNB': 'bnb',
                     'MATIC': 'matic',
                 },
+                'networksById': {
+                    'eth': 'ERC20',
+                    'ETH': 'ERC20',
+                    'ERC20': 'ERC20',
+                    'trx': 'TRC20',
+                    'TRX': 'TRC20',
+                    'TRC20': 'TRC20',
+                },
             },
         });
     }
@@ -417,66 +425,116 @@ export default class hollaex extends Exchange {
     async fetchCurrencies(params = {}) {
         const response = await this.publicGetConstants(params);
         //
-        //     {
-        //         "coins":{
-        //             "bch":{
-        //                 "id":4,
-        //                 "fullname":"Bitcoin Cash",
-        //                 "symbol":"bch",
-        //                 "active":true,
-        //                 "verified":true,
-        //                 "allow_deposit":true,
-        //                 "allow_withdrawal":true,
-        //                 "withdrawal_fee":0.0002,
-        //                 "min":0.001,
-        //                 "max":100000,
-        //                 "increment_unit":0.001,
-        //                 "logo":"https://bitholla.s3.ap-northeast-2.amazonaws.com/icon/BCH-hollaex-asset-01.svg",
-        //                 "code":"bch",
-        //                 "is_public":true,
-        //                 "meta":{},
-        //                 "estimated_price":null,
-        //                 "description":null,
-        //                 "type":"blockchain",
-        //                 "network":null,
-        //                 "standard":null,
-        //                 "issuer":"HollaEx",
-        //                 "withdrawal_fees":null,
-        //                 "created_at":"2019-08-09T10:45:43.367Z",
-        //                 "updated_at":"2021-12-13T03:08:32.372Z",
-        //                 "created_by":1,
-        //                 "owner_id":1
-        //             },
+        //    {
+        //        "coins": {
+        //            "usdt": {
+        //                "id": "6",
+        //                "fullname": "USD Tether",
+        //                "symbol": "usdt",
+        //                "active": true,
+        //                "verified": true,
+        //                "allow_deposit": true,
+        //                "allow_withdrawal": true,
+        //                "withdrawal_fee": "20",
+        //                "min": "1",
+        //                "max": "10000000",
+        //                "increment_unit": "0.0001",
+        //                "logo": "https://hollaex-resources.s3.ap-southeast-1.amazonaws.com/icons/usdt.svg",
+        //                "code": "usdt",
+        //                "is_public": true,
+        //                "meta": {
+        //                    "color": "#27a17a",
+        //                    "website": "https://tether.to",
+        //                    "explorer": "https://blockchair.com/tether",
+        //                    "decimal_points": "6"
+        //                },
+        //                "estimated_price": "1",
+        //                "description": "<p>Tether (USDT) is a stablecoin pegged 1:1 to the US dollar. It is a digital currency that aims to maintain its value while allowing for fast and secure transfer of funds. It was the first stablecoin, and is the most widely used due stablecoin due to its stability and low volatility compared to other cryptocurrencies. It was launched in 2014 by Tether Limited.</p>",
+        //                "type": "blockchain",
+        //                "network": "eth,trx,bnb,matic",
+        //                "standard": "",
+        //                "issuer": "HollaEx",
+        //                "withdrawal_fees": {
+        //                    "bnb": {
+        //                        "value": "0.8",
+        //                        "active": true,
+        //                        "symbol": "usdt"
+        //                    },
+        //                    "eth": {
+        //                        "value": "1.5",
+        //                        "active": true,
+        //                        "symbol": "usdt"
+        //                    },
+        //                    "trx": {
+        //                        "value": "4",
+        //                        "active": true,
+        //                        "symbol": "usdt"
+        //                    },
+        //                    "matic": {
+        //                        "value": "0.3",
+        //                        "active": true,
+        //                        "symbol": "usdt"
+        //                    }
+        //                },
+        //                "display_name": null,
+        //                "deposit_fees": null,
+        //                "is_risky": false,
+        //                "market_cap": "144568098696.29",
+        //                "category": "stable",
+        //                "created_at": "2019-08-09T10:45:43.367Z",
+        //                "updated_at": "2025-03-25T17:12:37.970Z",
+        //                "created_by": "168",
+        //                "owner_id": "1"
+        //            },
         //         },
         //         "network":"https://api.hollaex.network"
         //     }
         //
-        const coins = this.safeValue(response, 'coins', {});
+        const coins = this.safeDict(response, 'coins', {});
         const keys = Object.keys(coins);
         const result = {};
         for (let i = 0; i < keys.length; i++) {
             const key = keys[i];
             const currency = coins[key];
             const id = this.safeString(currency, 'symbol');
-            const numericId = this.safeInteger(currency, 'id');
             const code = this.safeCurrencyCode(id);
-            const name = this.safeString(currency, 'fullname');
-            const depositEnabled = this.safeValue(currency, 'allow_deposit');
-            const withdrawEnabled = this.safeValue(currency, 'allow_withdrawal');
-            const isActive = this.safeValue(currency, 'active');
-            const active = isActive && depositEnabled && withdrawEnabled;
-            const fee = this.safeNumber(currency, 'withdrawal_fee');
-            const withdrawalLimits = this.safeValue(currency, 'withdrawal_limits', []);
-            result[code] = {
+            const withdrawalLimits = this.safeList(currency, 'withdrawal_limits', []);
+            const rawType = this.safeString(currency, 'type');
+            const type = (rawType === 'blockchain') ? 'crypto' : 'other';
+            const rawNetworks = this.safeDict(currency, 'withdrawal_fees', {});
+            const networks = {};
+            const networkIds = Object.keys(rawNetworks);
+            for (let j = 0; j < networkIds.length; j++) {
+                const networkId = networkIds[j];
+                const networkEntry = this.safeDict(rawNetworks, networkId);
+                const networkCode = this.networkIdToCode(networkId);
+                networks[networkCode] = {
+                    'id': networkId,
+                    'network': networkCode,
+                    'active': this.safeBool(networkEntry, 'active'),
+                    'deposit': undefined,
+                    'withdraw': undefined,
+                    'fee': this.safeNumber(networkEntry, 'value'),
+                    'precision': undefined,
+                    'limits': {
+                        'withdraw': {
+                            'min': undefined,
+                            'max': undefined,
+                        },
+                    },
+                    'info': networkEntry,
+                };
+            }
+            result[code] = this.safeCurrencyStructure({
                 'id': id,
-                'numericId': numericId,
+                'numericId': this.safeInteger(currency, 'id'),
                 'code': code,
                 'info': currency,
-                'name': name,
-                'active': active,
-                'deposit': depositEnabled,
-                'withdraw': withdrawEnabled,
-                'fee': fee,
+                'name': this.safeString(currency, 'fullname'),
+                'active': this.safeBool(currency, 'active'),
+                'deposit': this.safeBool(currency, 'allow_deposit'),
+                'withdraw': this.safeBool(currency, 'allow_withdrawal'),
+                'fee': this.safeNumber(currency, 'withdrawal_fee'),
                 'precision': this.safeNumber(currency, 'increment_unit'),
                 'limits': {
                     'amount': {
@@ -488,9 +546,9 @@ export default class hollaex extends Exchange {
                         'max': this.safeValue(withdrawalLimits, 0),
                     },
                 },
-                'networks': {},
-                'type': 'crypto',
-            };
+                'networks': networks,
+                'type': type,
+            });
         }
         return result;
     }

package/js/src/htx.js

@@ -3436,9 +3436,8 @@ export default class htx extends Exchange {
         //            }
         //        ]
         //    }
-        //    }
         //
-        const data = this.safeValue(response, 'data', []);
+        const data = this.safeList(response, 'data', []);
         const result = {};
         this.options['networkChainIdsByNames'] = {};
         this.options['networkNamesByChainIds'] = {};
@@ -3446,19 +3445,11 @@ export default class htx extends Exchange {
             const entry = data[i];
             const currencyId = this.safeString(entry, 'currency');
             const code = this.safeCurrencyCode(currencyId);
-            this.options['networkChainIdsByNames'][code] = {};
-            const chains = this.safeValue(entry, 'chains', []);
-            const networks = {};
-            const instStatus = this.safeString(entry, 'instStatus');
             const assetType = this.safeString(entry, 'assetType');
             const type = assetType === '1' ? 'crypto' : 'fiat';
-            const currencyActive = instStatus === 'normal';
-            let minPrecision = undefined;
-            let minDeposit = undefined;
-            let minWithdraw = undefined;
-            let maxWithdraw = undefined;
-            let deposit = false;
-            let withdraw = false;
+            this.options['networkChainIdsByNames'][code] = {};
+            const chains = this.safeList(entry, 'chains', []);
+            const networks = {};
             for (let j = 0; j < chains.length; j++) {
                 const chainEntry = chains[j];
                 const uniqueChainId = this.safeString(chainEntry, 'chain'); // i.e. usdterc20, trc20usdt ...
@@ -3466,49 +3457,34 @@ export default class htx extends Exchange {
                 this.options['networkChainIdsByNames'][code][title] = uniqueChainId;
                 this.options['networkNamesByChainIds'][uniqueChainId] = title;
                 const networkCode = this.networkIdToCode(uniqueChainId);
-                minDeposit = this.safeNumber(chainEntry, 'minDepositAmt');
-                minWithdraw = this.safeNumber(chainEntry, 'minWithdrawAmt');
-                maxWithdraw = this.safeNumber(chainEntry, 'maxWithdrawAmt');
-                const withdrawStatus = this.safeString(chainEntry, 'withdrawStatus');
-                const depositStatus = this.safeString(chainEntry, 'depositStatus');
-                const withdrawEnabled = (withdrawStatus === 'allowed');
-                const depositEnabled = (depositStatus === 'allowed');
-                withdraw = (withdrawEnabled) ? withdrawEnabled : withdraw;
-                deposit = (depositEnabled) ? depositEnabled : deposit;
-                const active = withdrawEnabled && depositEnabled;
-                const precision = this.parsePrecision(this.safeString(chainEntry, 'withdrawPrecision'));
-                if (precision !== undefined) {
-                    minPrecision = (minPrecision === undefined) ? precision : Precise.stringMin(precision, minPrecision);
-                }
-                const fee = this.safeNumber(chainEntry, 'transactFeeWithdraw');
                 networks[networkCode] = {
                     'info': chainEntry,
                     'id': uniqueChainId,
                     'network': networkCode,
                     'limits': {
                         'deposit': {
-                            'min': minDeposit,
+                            'min': this.safeNumber(chainEntry, 'minDepositAmt'),
                             'max': undefined,
                         },
                         'withdraw': {
-                            'min': minWithdraw,
-                            'max': maxWithdraw,
+                            'min': this.safeNumber(chainEntry, 'minWithdrawAmt'),
+                            'max': this.safeNumber(chainEntry, 'maxWithdrawAmt'),
                         },
                     },
-                    'active': active,
-                    'deposit': depositEnabled,
-                    'withdraw': withdrawEnabled,
-                    'fee': fee,
-                    'precision': this.parseNumber(precision),
+                    'active': undefined,
+                    'deposit': this.safeString(chainEntry, 'depositStatus') === 'allowed',
+                    'withdraw': this.safeString(chainEntry, 'withdrawStatus') === 'allowed',
+                    'fee': this.safeNumber(chainEntry, 'transactFeeWithdraw'),
+                    'precision': this.parseNumber(this.parsePrecision(this.safeString(chainEntry, 'withdrawPrecision'))),
                 };
             }
-            result[code] = {
+            result[code] = this.safeCurrencyStructure({
                 'info': entry,
                 'code': code,
                 'id': currencyId,
-                'active': currencyActive,
-                'deposit': deposit,
-                'withdraw': withdraw,
+                'active': this.safeString(entry, 'instStatus') === 'normal',
+                'deposit': undefined,
+                'withdraw': undefined,
                 'fee': undefined,
                 'name': undefined,
                 'type': type,
@@ -3518,17 +3494,17 @@ export default class htx extends Exchange {
                         'max': undefined,
                     },
                     'withdraw': {
-                        'min': minWithdraw,
-                        'max': maxWithdraw,
+                        'min': undefined,
+                        'max': undefined,
                     },
                     'deposit': {
                         'min': undefined,
                         'max': undefined,
                     },
                 },
-                'precision': this.parseNumber(minPrecision),
+                'precision': undefined,
                 'networks': networks,
-            };
+            });
         }
         return result;
     }
@@ -4567,6 +4543,8 @@ export default class htx extends Exchange {
         const request = {};
         let marketType = undefined;
         [marketType, params] = this.handleMarketTypeAndParams('fetchOpenOrders', market, params);
+        let subType = undefined;
+        [subType, params] = this.handleSubTypeAndParams('fetchOpenOrders', market, params, 'linear');
         let response = undefined;
         if (marketType === 'spot') {
             if (symbol !== undefined) {
@@ -4595,18 +4573,18 @@ export default class htx extends Exchange {
             response = await this.spotPrivateGetV1OrderOpenOrders(this.extend(request, params));
         }
         else {
-            if (symbol === undefined) {
-                throw new ArgumentsRequired(this.id + ' fetchOpenOrders() requires a symbol argument');
+            if (symbol !== undefined) {
+                // throw new ArgumentsRequired (this.id + ' fetchOpenOrders() requires a symbol argument');
+                request['contract_code'] = market['id'];
             }
             if (limit !== undefined) {
                 request['page_size'] = limit;
             }
-            request['contract_code'] = market['id'];
             const trigger = this.safeBool2(params, 'stop', 'trigger');
             const stopLossTakeProfit = this.safeValue(params, 'stopLossTakeProfit');
             const trailing = this.safeBool(params, 'trailing', false);
             params = this.omit(params, ['stop', 'stopLossTakeProfit', 'trailing', 'trigger']);
-            if (market['linear']) {
+            if (subType === 'linear') {
                 let marginMode = undefined;
                 [marginMode, params] = this.handleMarginModeAndParams('fetchOpenOrders', params);
                 marginMode = (marginMode === undefined) ? 'cross' : marginMode;
@@ -4639,8 +4617,8 @@ export default class htx extends Exchange {
                     }
                 }
             }
-            else if (market['inverse']) {
-                if (market['swap']) {
+            else if (subType === 'inverse') {
+                if (marketType === 'swap') {
                     if (trigger) {
                         response = await this.contractPrivatePostSwapApiV1SwapTriggerOpenorders(this.extend(request, params));
                     }
@@ -4654,8 +4632,8 @@ export default class htx extends Exchange {
                         response = await this.contractPrivatePostSwapApiV1SwapOpenorders(this.extend(request, params));
                     }
                 }
-                else if (market['future']) {
-                    request['symbol'] = market['settleId'];
+                else if (marketType === 'future') {
+                    request['symbol'] = this.safeString(market, 'settleId', 'usdt');
                     if (trigger) {
                         response = await this.contractPrivatePostApiV1ContractTriggerOpenorders(this.extend(request, params));
                     }