ccxt 4.4.85 → 4.4.87

package/dist/cjs/src/pro/okxus.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var okx = require('./okx.js');
+
+// ----------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+class okxus extends okx {
+    describe() {
+        return this.deepExtend(super.describe(), {
+            'id': 'okxus',
+            'name': 'OKX (US)',
+            'hostname': 'us.okx.com',
+            'urls': {
+                'api': {
+                    'rest': 'https://{hostname}',
+                    'ws': 'wss://wsus.okx.com:8443/ws/v5',
+                },
+                'www': 'https://app.okx.com',
+                'doc': 'https://app.okx.com/docs-v5/en/#overview',
+                'fees': 'https://app.okx.com/pages/products/fees.html',
+                'referral': {
+                    'url': 'https://www.app.okx.com/join/CCXT2023',
+                    'discount': 0.2,
+                },
+                'test': {
+                    'ws': 'wss://wsuspap.okx.com:8443/ws/v5',
+                },
+            },
+            'has': {
+                'swap': false,
+                'future': false,
+                'option': false,
+            },
+        });
+    }
+}
+
+module.exports = okxus;

package/dist/cjs/src/probit.js

@@ -467,33 +467,23 @@ class probit extends probit$1 {
         //         ]
         //     }
         //
-        const currencies = this.safeValue(response, 'data', []);
+        const currencies = this.safeList(response, 'data', []);
         const result = {};
         for (let i = 0; i < currencies.length; i++) {
             const currency = currencies[i];
             const id = this.safeString(currency, 'id');
             const code = this.safeCurrencyCode(id);
-            const displayName = this.safeValue(currency, 'display_name');
+            const displayName = this.safeDict(currency, 'display_name');
             const name = this.safeString(displayName, 'en-us');
-            const platforms = this.safeValue(currency, 'platform', []);
+            const platforms = this.safeList(currency, 'platform', []);
             const platformsByPriority = this.sortBy(platforms, 'priority');
-            let platform = undefined;
             const networkList = {};
             for (let j = 0; j < platformsByPriority.length; j++) {
                 const network = platformsByPriority[j];
                 const idInner = this.safeString(network, 'id');
                 const networkCode = this.networkIdToCode(idInner);
-                const currentDepositSuspended = this.safeValue(network, 'deposit_suspended');
-                const currentWithdrawalSuspended = this.safeValue(network, 'withdrawal_suspended');
-                const currentDeposit = !currentDepositSuspended;
-                const currentWithdraw = !currentWithdrawalSuspended;
-                const currentActive = currentDeposit && currentWithdraw;
-                if (currentActive) {
-                    platform = network;
-                }
-                const precision = this.parsePrecision(this.safeString(network, 'precision'));
-                const withdrawFee = this.safeValue(network, 'withdrawal_fee', []);
-                let networkFee = this.safeValue(withdrawFee, 0, {});
+                const withdrawFee = this.safeList(network, 'withdrawal_fee', []);
+                let networkFee = this.safeDict(withdrawFee, 0, {});
                 for (let k = 0; k < withdrawFee.length; k++) {
                     const withdrawPlatform = withdrawFee[k];
                     const feeCurrencyId = this.safeString(withdrawPlatform, 'currency_id');
@@ -505,11 +495,11 @@ class probit extends probit$1 {
                 networkList[networkCode] = {
                     'id': idInner,
                     'network': networkCode,
-                    'active': currentActive,
-                    'deposit': currentDeposit,
-                    'withdraw': currentWithdraw,
+                    'active': undefined,
+                    'deposit': !this.safeBool(network, 'deposit_suspended'),
+                    'withdraw': !this.safeBool(network, 'withdrawal_suspended'),
                     'fee': this.safeNumber(networkFee, 'amount'),
-                    'precision': this.parseNumber(precision),
+                    'precision': this.parseNumber(this.parsePrecision(this.safeString(network, 'precision'))),
                     'limits': {
                         'withdraw': {
                             'min': this.safeNumber(network, 'min_withdrawal_amount'),
@@ -523,56 +513,33 @@ class probit extends probit$1 {
                     'info': network,
                 };
             }
-            if (platform === undefined) {
-                platform = this.safeValue(platformsByPriority, 0, {});
-            }
-            const depositSuspended = this.safeValue(platform, 'deposit_suspended');
-            const withdrawalSuspended = this.safeValue(platform, 'withdrawal_suspended');
-            const deposit = !depositSuspended;
-            const withdraw = !withdrawalSuspended;
-            const active = deposit && withdraw;
-            const withdrawalFees = this.safeValue(platform, 'withdrawal_fee', {});
-            const fees = [];
-            // sometimes the withdrawal fee is an empty object
-            // [ { 'amount': '0.015', 'priority': 1, 'currency_id': 'ETH' }, {} ]
-            for (let j = 0; j < withdrawalFees.length; j++) {
-                const withdrawalFeeInner = withdrawalFees[j];
-                const amount = this.safeNumber(withdrawalFeeInner, 'amount');
-                const priority = this.safeInteger(withdrawalFeeInner, 'priority');
-                if ((amount !== undefined) && (priority !== undefined)) {
-                    fees.push(withdrawalFeeInner);
-                }
-            }
-            const withdrawalFeesByPriority = this.sortBy(fees, 'priority');
-            const withdrawalFee = this.safeValue(withdrawalFeesByPriority, 0, {});
-            const fee = this.safeNumber(withdrawalFee, 'amount');
-            result[code] = {
+            result[code] = this.safeCurrencyStructure({
                 'id': id,
                 'code': code,
                 'info': currency,
                 'name': name,
-                'active': active,
-                'deposit': deposit,
-                'withdraw': withdraw,
+                'active': undefined,
+                'deposit': undefined,
+                'withdraw': undefined,
                 'type': 'crypto',
-                'fee': fee,
-                'precision': this.parseNumber(this.parsePrecision(this.safeString(platform, 'precision'))),
+                'fee': undefined,
+                'precision': undefined,
                 'limits': {
                     'amount': {
                         'min': undefined,
                         'max': undefined,
                     },
                     'deposit': {
-                        'min': this.safeNumber(platform, 'min_deposit_amount'),
+                        'min': undefined,
                         'max': undefined,
                     },
                     'withdraw': {
-                        'min': this.safeNumber(platform, 'min_withdrawal_amount'),
+                        'min': undefined,
                         'max': undefined,
                     },
                 },
                 'networks': networkList,
-            };
+            });
         }
         return result;
     }

package/dist/cjs/src/timex.js

@@ -1415,11 +1415,6 @@ class timex extends timex$1 {
         //
         const id = this.safeString(currency, 'symbol');
         const code = this.safeCurrencyCode(id);
-        const name = this.safeString(currency, 'name');
-        const depositEnabled = this.safeValue(currency, 'depositEnabled');
-        const withdrawEnabled = this.safeValue(currency, 'withdrawalEnabled');
-        const isActive = this.safeValue(currency, 'active');
-        const active = depositEnabled && withdrawEnabled && isActive;
         // const fee = this.safeNumber (currency, 'withdrawalFee');
         const feeString = this.safeString(currency, 'withdrawalFee');
         const tradeDecimals = this.safeInteger(currency, 'tradeDecimals');
@@ -1445,14 +1440,14 @@ class timex extends timex$1 {
             'code': code,
             'info': currency,
             'type': undefined,
-            'name': name,
-            'active': active,
-            'deposit': depositEnabled,
-            'withdraw': withdrawEnabled,
+            'name': this.safeString(currency, 'name'),
+            'active': this.safeBool(currency, 'active'),
+            'deposit': this.safeBool(currency, 'depositEnabled'),
+            'withdraw': this.safeBool(currency, 'withdrawalEnabled'),
             'fee': fee,
             'precision': this.parseNumber(this.parsePrecision(this.safeString(currency, 'decimals'))),
             'limits': {
-                'withdraw': { 'min': fee, 'max': undefined },
+                'withdraw': { 'min': undefined, 'max': undefined },
                 'amount': { 'min': undefined, 'max': undefined },
             },
             'networks': {},

package/dist/cjs/src/vertex.js

@@ -451,11 +451,10 @@ class vertex extends vertex$1 {
             if ((tickerId !== undefined) && (tickerId.indexOf('PERP') > 0)) {
                 continue;
             }
-            const id = this.safeString(data, 'product_id');
             const name = this.safeString(data, 'symbol');
             const code = this.safeCurrencyCode(name);
-            result[code] = {
-                'id': id,
+            result[code] = this.safeCurrencyStructure({
+                'id': this.safeString(data, 'product_id'),
                 'name': name,
                 'code': code,
                 'precision': undefined,
@@ -475,7 +474,7 @@ class vertex extends vertex$1 {
                         'max': undefined,
                     },
                 },
-            };
+            });
         }
         return result;
     }

package/dist/cjs/src/whitebit.js

@@ -613,25 +613,51 @@ class whitebit extends whitebit$1 {
         for (let i = 0; i < ids.length; i++) {
             const id = ids[i];
             const currency = response[id];
-            // breaks down in Python due to utf8 encoding issues on the exchange side
-            // const name = this.safeString (currency, 'name');
-            const canDeposit = this.safeBool(currency, 'can_deposit', true);
-            const canWithdraw = this.safeBool(currency, 'can_withdraw', true);
-            const active = canDeposit && canWithdraw;
+            // const name = this.safeString (currency, 'name'); // breaks down in Python due to utf8 encoding issues on the exchange side
             const code = this.safeCurrencyCode(id);
             const hasProvider = ('providers' in currency);
-            result[code] = {
+            const rawNetworks = this.safeDict(currency, 'networks', {});
+            const depositsNetworks = this.safeList(rawNetworks, 'deposits', []);
+            const withdrawsNetworks = this.safeList(rawNetworks, 'withdraws', []);
+            const networkLimits = this.safeDict(currency, 'limits', {});
+            const depositLimits = this.safeDict(networkLimits, 'deposit', {});
+            const withdrawLimits = this.safeDict(networkLimits, 'withdraw', {});
+            const allNetworks = this.arrayConcat(depositsNetworks, withdrawsNetworks);
+            for (let j = 0; j < allNetworks.length; j++) {
+                const networkId = allNetworks[j];
+                const networkCode = this.networkIdToCode(networkId);
+                ({
+                    'id': networkId,
+                    'network': networkCode,
+                    'active': undefined,
+                    'deposit': this.inArray(networkId, depositsNetworks),
+                    'withdraw': this.inArray(networkId, withdrawsNetworks),
+                    'fee': undefined,
+                    'precision': undefined,
+                    'limits': {
+                        'deposit': {
+                            'min': this.safeNumber(depositLimits, 'min', undefined),
+                            'max': this.safeNumber(depositLimits, 'max', undefined),
+                        },
+                        'withdraw': {
+                            'min': this.safeNumber(withdrawLimits, 'min', undefined),
+                            'max': this.safeNumber(withdrawLimits, 'max', undefined),
+                        },
+                    },
+                });
+            }
+            result[code] = this.safeCurrencyStructure({
                 'id': id,
                 'code': code,
                 'info': currency,
                 'name': undefined,
-                'active': active,
-                'deposit': canDeposit,
-                'withdraw': canWithdraw,
+                'active': undefined,
+                'deposit': this.safeBool(currency, 'can_deposit'),
+                'withdraw': this.safeBool(currency, 'can_withdraw'),
                 'fee': undefined,
                 'networks': undefined,
                 'type': hasProvider ? 'fiat' : 'crypto',
-                'precision': undefined,
+                'precision': this.parseNumber(this.parsePrecision(this.safeString(currency, 'currency_precision'))),
                 'limits': {
                     'amount': {
                         'min': undefined,
@@ -641,8 +667,12 @@ class whitebit extends whitebit$1 {
                         'min': this.safeNumber(currency, 'min_withdraw'),
                         'max': this.safeNumber(currency, 'max_withdraw'),
                     },
+                    'deposit': {
+                        'min': this.safeNumber(currency, 'min_deposit'),
+                        'max': this.safeNumber(currency, 'max_deposit'),
+                    },
                 },
-            };
+            });
         }
         return result;
     }

package/dist/cjs/src/woo.js

@@ -301,6 +301,11 @@ class woo extends woo$1 {
                     'TRC20': 'TRON',
                     'ERC20': 'ETH',
                     'BEP20': 'BSC',
+                    'ARB': 'Arbitrum',
+                },
+                'networksById': {
+                    'TRX': 'TRC20',
+                    'TRON': 'TRC20',
                 },
                 // override defaultNetworkCodePriorities for a specific currency
                 'defaultNetworkCodeForCurrencies': {
@@ -819,33 +824,45 @@ class woo extends woo$1 {
      */
     async fetchCurrencies(params = {}) {
         const result = {};
-        const tokenResponse = await this.v1PublicGetToken(params);
+        const tokenResponsePromise = this.v1PublicGetToken(params);
         //
-        // {
-        //     "rows": [
+        //    {
+        //      "rows": [
         //         {
         //             "token": "ETH_USDT",
         //             "fullname": "Tether",
-        //             "decimals": 6,
+        //             "network": "ETH",
+        //             "decimals": "6",
+        //             "delisted": false,
         //             "balance_token": "USDT",
-        //             "created_time": "0",
-        //             "updated_time": "0"
+        //             "created_time": "1710123398",
+        //             "updated_time": "1746528481",
+        //             "can_collateral": true,
+        //             "can_short": true
         //         },
         //         {
         //             "token": "BSC_USDT",
         //             "fullname": "Tether",
-        //             "decimals": 18,
+        //             "network": "BSC",
+        //             "decimals": "18",
+        //             "delisted": false,
         //             "balance_token": "USDT",
-        //             "created_time": "0",
-        //             "updated_time": "0"
+        //             "created_time": "1710123395",
+        //             "updated_time": "1746528601",
+        //             "can_collateral": true,
+        //             "can_short": true
         //         },
         //         {
-        //             "token": "ZEC",
-        //             "fullname": "ZCash",
-        //             "decimals": 8,
-        //             "balance_token": "ZEC",
-        //             "created_time": "0",
-        //             "updated_time": "0"
+        //             "token": "ALGO",
+        //             "fullname": "Algorand",
+        //             "network": "ALGO",
+        //             "decimals": "6",
+        //             "delisted": false,
+        //             "balance_token": "ALGO",
+        //             "created_time": "1710123394",
+        //             "updated_time": "1723087518",
+        //             "can_collateral": true,
+        //             "can_short": true
         //         },
         //         ...
         //     ],
@@ -853,59 +870,66 @@ class woo extends woo$1 {
         // }
         //
         // only make one request for currrencies...
-        // const tokenNetworkResponse = await this.v1PublicGetTokenNetwork (params);
+        const tokenNetworkResponsePromise = this.v1PublicGetTokenNetwork(params);
         //
         // {
         //     "rows": [
         //         {
         //             "protocol": "ERC20",
+        //             "network": "ETH",
         //             "token": "USDT",
-        //             "name": "Ethereum",
-        //             "minimum_withdrawal": 30,
-        //             "withdrawal_fee": 25,
-        //             "allow_deposit": 1,
-        //             "allow_withdraw": 1
+        //             "name": "Ethereum (ERC20)",
+        //             "minimum_withdrawal": "10.00000000",
+        //             "withdrawal_fee": "2.00000000",
+        //             "allow_deposit": "1",
+        //             "allow_withdraw": "1"
         //         },
         //         {
         //             "protocol": "TRC20",
+        //             "network": "TRX",
         //             "token": "USDT",
-        //             "name": "Tron",
-        //             "minimum_withdrawal": 30,
-        //             "withdrawal_fee": 1,
-        //             "allow_deposit": 1,
-        //             "allow_withdraw": 1
+        //             "name": "Tron (TRC20)",
+        //             "minimum_withdrawal": "10.00000000",
+        //             "withdrawal_fee": "4.50000000",
+        //             "allow_deposit": "1",
+        //             "allow_withdraw": "1"
         //         },
         //         ...
         //     ],
         //     "success": true
         // }
         //
+        const [tokenResponse, tokenNetworkResponse] = await Promise.all([tokenResponsePromise, tokenNetworkResponsePromise]);
         const tokenRows = this.safeList(tokenResponse, 'rows', []);
-        const networksByCurrencyId = this.groupBy(tokenRows, 'balance_token');
-        const currencyIds = Object.keys(networksByCurrencyId);
+        const tokenNetworkRows = this.safeList(tokenNetworkResponse, 'rows', []);
+        const networksById = this.groupBy(tokenNetworkRows, 'token');
+        const tokensById = this.groupBy(tokenRows, 'balance_token');
+        const currencyIds = Object.keys(tokensById);
         for (let i = 0; i < currencyIds.length; i++) {
             const currencyId = currencyIds[i];
-            const networks = networksByCurrencyId[currencyId];
             const code = this.safeCurrencyCode(currencyId);
-            let name = undefined;
-            let minPrecision = undefined;
+            const tokensByNetworkId = this.indexBy(tokensById[currencyId], 'network');
+            const chainsByNetworkId = this.indexBy(networksById[currencyId], 'network');
+            const keys = Object.keys(chainsByNetworkId);
             const resultingNetworks = {};
-            for (let j = 0; j < networks.length; j++) {
-                const network = networks[j];
-                name = this.safeString(network, 'fullname');
-                const networkId = this.safeString(network, 'token');
-                const splitted = networkId.split('_');
-                const unifiedNetwork = splitted[0];
-                const precision = this.parsePrecision(this.safeString(network, 'decimals'));
-                if (precision !== undefined) {
-                    minPrecision = (minPrecision === undefined) ? precision : Precise["default"].stringMin(precision, minPrecision);
-                }
-                resultingNetworks[unifiedNetwork] = {
+            for (let j = 0; j < keys.length; j++) {
+                const networkId = keys[j];
+                const tokenEntry = this.safeDict(tokensByNetworkId, networkId, {});
+                const networkEntry = this.safeDict(chainsByNetworkId, networkId, {});
+                const networkCode = this.networkIdToCode(networkId, code);
+                const specialNetworkId = this.safeString(tokenEntry, 'token');
+                resultingNetworks[networkCode] = {
                     'id': networkId,
-                    'network': unifiedNetwork,
+                    'currencyNetworkId': specialNetworkId,
+                    'network': networkCode,
+                    'active': undefined,
+                    'deposit': this.safeString(networkEntry, 'allow_deposit') === '1',
+                    'withdraw': this.safeString(networkEntry, 'allow_withdraw') === '1',
+                    'fee': this.safeNumber(networkEntry, 'withdrawal_fee'),
+                    'precision': this.parseNumber(this.parsePrecision(this.safeString(tokenEntry, 'decimals'))),
                     'limits': {
                         'withdraw': {
-                            'min': undefined,
+                            'min': this.safeNumber(networkEntry, 'minimum_withdrawal'),
                             'max': undefined,
                         },
                         'deposit': {
@@ -913,19 +937,14 @@ class woo extends woo$1 {
                             'max': undefined,
                         },
                     },
-                    'active': undefined,
-                    'deposit': undefined,
-                    'withdraw': undefined,
-                    'fee': undefined,
-                    'precision': this.parseNumber(precision),
-                    'info': network,
+                    'info': [networkEntry, tokenEntry],
                 };
             }
-            result[code] = {
+            result[code] = this.safeCurrencyStructure({
                 'id': currencyId,
-                'name': name,
+                'name': undefined,
                 'code': code,
-                'precision': this.parseNumber(minPrecision),
+                'precision': undefined,
                 'active': undefined,
                 'fee': undefined,
                 'networks': resultingNetworks,
@@ -942,8 +961,8 @@ class woo extends woo$1 {
                         'max': undefined,
                     },
                 },
-                'info': networks,
-            };
+                'info': [tokensByNetworkId, chainsByNetworkId],
+            });
         }
         return result;
     }
@@ -1580,7 +1599,7 @@ class woo extends woo$1 {
             request['size'] = limit;
         }
         else {
-            request['size'] = 500;
+            request['size'] = trailing ? 50 : 500;
         }
         if (trigger) {
             request['algoType'] = 'stop';
@@ -2161,12 +2180,10 @@ class woo extends woo$1 {
         // this method is TODO because of networks unification
         await this.loadMarkets();
         const currency = this.currency(code);
-        const networkCodeDefault = this.defaultNetworkCodeForCurrency(code);
-        const networkCode = this.safeString(params, 'network', networkCodeDefault);
-        params = this.omit(params, 'network');
-        const codeForExchange = networkCode + '_' + currency['code'];
+        let specialNetworkId = undefined;
+        [specialNetworkId, params] = this.getDedicatedNetworkId(currency, params);
         const request = {
-            'token': codeForExchange,
+            'token': specialNetworkId,
         };
         const response = await this.v1PrivateGetAssetDeposit(this.extend(request, params));
         // {
@@ -2174,15 +2191,29 @@ class woo extends woo$1 {
         //     "address": "3Jmtjx5544T4smrit9Eroe4PCrRkpDeKjP",
         //     "extra": ''
         // }
-        const tag = this.safeString(response, 'extra');
-        const address = this.safeString(response, 'address');
+        return this.parseDepositAddress(response, currency);
+    }
+    getDedicatedNetworkId(currency, params) {
+        let networkCode = undefined;
+        [networkCode, params] = this.handleNetworkCodeAndParams(params);
+        networkCode = this.networkIdToCode(networkCode, currency['code']);
+        const networkEntry = this.safeDict(currency['networks'], networkCode);
+        if (networkEntry === undefined) {
+            const supportedNetworks = Object.keys(currency['networks']);
+            throw new errors.BadRequest(this.id + '  can not determine a network code, please provide unified "network" param, one from the following: ' + this.json(supportedNetworks));
+        }
+        const currentyNetworkId = this.safeString(networkEntry, 'currencyNetworkId');
+        return [currentyNetworkId, params];
+    }
+    parseDepositAddress(depositEntry, currency = undefined) {
+        const address = this.safeString(depositEntry, 'address');
         this.checkAddress(address);
         return {
-            'info': response,
-            'currency': code,
-            'network': networkCode,
+            'info': depositEntry,
+            'currency': this.safeString(currency, 'code'),
+            'network': undefined,
             'address': address,
-            'tag': tag,
+            'tag': this.safeString(depositEntry, 'extra'),
         };
     }
     async getAssetHistoryRows(code = undefined, since = undefined, limit = undefined, params = {}) {
@@ -2588,16 +2619,9 @@ class woo extends woo$1 {
         if (tag !== undefined) {
             request['extra'] = tag;
         }
-        const networks = this.safeDict(this.options, 'networks', {});
-        const currencyNetworks = this.safeDict(currency, 'networks', {});
-        const network = this.safeStringUpper(params, 'network');
-        const networkId = this.safeString(networks, network, network);
-        const coinNetwork = this.safeDict(currencyNetworks, networkId, {});
-        const coinNetworkId = this.safeString(coinNetwork, 'id');
-        if (coinNetworkId === undefined) {
-            throw new errors.BadRequest(this.id + ' withdraw() require network parameter');
-        }
-        request['token'] = coinNetworkId;
+        let specialNetworkId = undefined;
+        [specialNetworkId, params] = this.getDedicatedNetworkId(currency, params);
+        request['token'] = specialNetworkId;
         const response = await this.v1PrivatePostAssetWithdraw(this.extend(request, params));
         //
         //     {