ccxt 4.4.80__py2.py3-none-any.whl → 4.4.85__py2.py3-none-any.whl

ccxt/async_support/coinone.py

@@ -303,18 +303,16 @@ class coinone(Exchange, ImplicitAPI):
         for i in range(0, len(currencies)):
             entry = currencies[i]
             id = self.safe_string(entry, 'symbol')
-            name = self.safe_string(entry, 'name')
             code = self.safe_currency_code(id)
-            withdrawStatus = self.safe_string(entry, 'withdraw_status', '')
-            depositStatus = self.safe_string(entry, 'deposit_status', '')
-            isWithdrawEnabled = withdrawStatus == 'normal'
-            isDepositEnabled = depositStatus == 'normal'
-            result[code] = {
+            isWithdrawEnabled = self.safe_string(entry, 'withdraw_status', '') == 'normal'
+            isDepositEnabled = self.safe_string(entry, 'deposit_status', '') == 'normal'
+            type = 'crypto' if (code != 'KRW') else 'fiat'
+            result[code] = self.safe_currency_structure({
                 'id': id,
                 'code': code,
                 'info': entry,
-                'name': name,
-                'active': isWithdrawEnabled and isDepositEnabled,
+                'name': self.safe_string(entry, 'name'),
+                'active': None,
                 'deposit': isDepositEnabled,
                 'withdraw': isWithdrawEnabled,
                 'fee': self.safe_number(entry, 'withdrawal_fee'),
@@ -330,8 +328,8 @@ class coinone(Exchange, ImplicitAPI):
                     },
                 },
                 'networks': {},
-                'type': 'crypto',
-            }
+                'type': type,
+            })
         return result
 
     async def fetch_markets(self, params={}) -> List[Market]:

ccxt/async_support/coinsph.py

@@ -6,7 +6,7 @@
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.coinsph import ImplicitAPI
 import hashlib
-from ccxt.base.types import Any, Balances, Currency, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface, TradingFees, Transaction
+from ccxt.base.types import Any, Balances, Currencies, Currency, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface, TradingFees, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -75,7 +75,7 @@ class coinsph(Exchange, ImplicitAPI):
                 'fetchClosedOrders': True,
                 'fetchCrossBorrowRate': False,
                 'fetchCrossBorrowRates': False,
-                'fetchCurrencies': False,
+                'fetchCurrencies': True,
                 'fetchDeposit': None,
                 'fetchDepositAddress': True,
                 'fetchDepositAddresses': False,
@@ -501,6 +501,128 @@ class coinsph(Exchange, ImplicitAPI):
             },
         })
 
+    async def fetch_currencies(self, params={}) -> Currencies:
+        """
+        fetches all available currencies on an exchange
+
+        https://docs.coins.ph/rest-api/#all-coins-information-user_data
+
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an associative dictionary of currencies
+        """
+        if not self.check_required_credentials(False):
+            return None
+        response = await self.privateGetOpenapiWalletV1ConfigGetall(params)
+        #
+        #    [
+        #        {
+        #            "coin": "PHP",
+        #            "name": "PHP",
+        #            "depositAllEnable": False,
+        #            "withdrawAllEnable": False,
+        #            "free": "0",
+        #            "locked": "0",
+        #            "transferPrecision": "2",
+        #            "transferMinQuantity": "0",
+        #            "networkList": [],
+        #            "legalMoney": True
+        #        },
+        #        {
+        #            "coin": "USDT",
+        #            "name": "USDT",
+        #            "depositAllEnable": True,
+        #            "withdrawAllEnable": True,
+        #            "free": "0",
+        #            "locked": "0",
+        #            "transferPrecision": "8",
+        #            "transferMinQuantity": "0",
+        #            "networkList": [
+        #                {
+        #                    "addressRegex": "^0x[0-9a-fA-F]{40}$",
+        #                    "memoRegex": " ",
+        #                    "network": "ETH",
+        #                    "name": "Ethereum(ERC20)",
+        #                    "depositEnable": True,
+        #                    "minConfirm": "12",
+        #                    "unLockConfirm": "-1",
+        #                    "withdrawDesc": "",
+        #                    "withdrawEnable": True,
+        #                    "withdrawFee": "6",
+        #                    "withdrawIntegerMultiple": "0.000001",
+        #                    "withdrawMax": "500000",
+        #                    "withdrawMin": "10",
+        #                    "sameAddress": False
+        #                },
+        #                {
+        #                    "addressRegex": "^T[0-9a-zA-Z]{33}$",
+        #                    "memoRegex": "",
+        #                    "network": "TRX",
+        #                    "name": "TRON",
+        #                    "depositEnable": True,
+        #                    "minConfirm": "19",
+        #                    "unLockConfirm": "-1",
+        #                    "withdrawDesc": "",
+        #                    "withdrawEnable": True,
+        #                    "withdrawFee": "3",
+        #                    "withdrawIntegerMultiple": "0.000001",
+        #                    "withdrawMax": "1000000",
+        #                    "withdrawMin": "20",
+        #                    "sameAddress": False
+        #                }
+        #            ],
+        #            "legalMoney": False
+        #        }
+        #    ]
+        #
+        result: dict = {}
+        for i in range(0, len(response)):
+            entry = response[i]
+            id = self.safe_string(entry, 'coin')
+            code = self.safe_currency_code(id)
+            isFiat = self.safe_bool(entry, 'isLegalMoney')
+            networkList = self.safe_list(entry, 'networkList', [])
+            networks: dict = {}
+            for j in range(0, len(networkList)):
+                networkItem = networkList[j]
+                network = self.safe_string(networkItem, 'network')
+                networkCode = self.network_id_to_code(network)
+                networks[networkCode] = {
+                    'info': networkItem,
+                    'id': network,
+                    'network': networkCode,
+                    'active': None,
+                    'deposit': self.safe_bool(networkItem, 'depositEnable'),
+                    'withdraw': self.safe_bool(networkItem, 'withdrawEnable'),
+                    'fee': self.safe_number(networkItem, 'withdrawFee'),
+                    'precision': self.safe_number(networkItem, 'withdrawIntegerMultiple'),
+                    'limits': {
+                        'withdraw': {
+                            'min': self.safe_number(networkItem, 'withdrawMin'),
+                            'max': self.safe_number(networkItem, 'withdrawMax'),
+                        },
+                        'deposit': {
+                            'min': None,
+                            'max': None,
+                        },
+                    },
+                }
+            result[code] = self.safe_currency_structure({
+                'id': id,
+                'name': self.safe_string(entry, 'name'),
+                'code': code,
+                'type': 'fiat' if isFiat else 'crypto',
+                'precision': self.parse_number(self.parse_precision(self.safe_string(entry, 'transferPrecision'))),
+                'info': entry,
+                'active': None,
+                'deposit': self.safe_bool(entry, 'depositAllEnable'),
+                'withdraw': self.safe_bool(entry, 'withdrawAllEnable'),
+                'networks': networks,
+                'fee': None,
+                'fees': None,
+                'limits': {},
+            })
+        return result
+
     def calculate_rate_limiter_cost(self, api, method, path, params, config={}):
         if ('noSymbol' in config) and not ('symbol' in params):
             return config['noSymbol']

ccxt/async_support/cryptocom.py

@@ -6,7 +6,7 @@
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.cryptocom import ImplicitAPI
 import hashlib
-from ccxt.base.types import Account, Any, Balances, Currency, DepositAddress, Int, LedgerEntry, Market, Num, Order, OrderBook, OrderRequest, CancellationRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface, TradingFees, Transaction
+from ccxt.base.types import Account, Any, Balances, Currencies, Currency, DepositAddress, Int, LedgerEntry, Market, Num, Order, OrderBook, OrderRequest, CancellationRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface, TradingFees, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -69,7 +69,7 @@ class cryptocom(Exchange, ImplicitAPI):
                 'fetchClosedOrders': 'emulated',
                 'fetchCrossBorrowRate': False,
                 'fetchCrossBorrowRates': False,
-                'fetchCurrencies': False,
+                'fetchCurrencies': True,
                 'fetchDepositAddress': True,
                 'fetchDepositAddresses': False,
                 'fetchDepositAddressesByNetwork': True,
@@ -526,6 +526,113 @@ class cryptocom(Exchange, ImplicitAPI):
             },
         })
 
+    async def fetch_currencies(self, params={}) -> Currencies:
+        """
+        fetches all available currencies on an exchange
+
+        https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#private-get-currency-networks
+
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an associative dictionary of currencies
+        """
+        # self endpoint requires authentication
+        if not self.check_required_credentials(False):
+            return None
+        response = await self.v1PrivatePostPrivateGetCurrencyNetworks(params)
+        #
+        #    {
+        #        "id": "1747502328559",
+        #        "method": "private/get-currency-networks",
+        #        "code": "0",
+        #        "result": {
+        #            "update_time": "1747502281000",
+        #            "currency_map": {
+        #                "USDT": {
+        #                    "full_name": "Tether USD",
+        #                    "default_network": "ETH",
+        #                    "network_list": [
+        #                        {
+        #                            "network_id": "ETH",
+        #                            "withdrawal_fee": "10.00000000",
+        #                            "withdraw_enabled": True,
+        #                            "min_withdrawal_amount": "20.0",
+        #                            "deposit_enabled": True,
+        #                            "confirmation_required": "32"
+        #                        },
+        #                        {
+        #                            "network_id": "CRONOS",
+        #                            "withdrawal_fee": "0.18000000",
+        #                            "withdraw_enabled": True,
+        #                            "min_withdrawal_amount": "0.36",
+        #                            "deposit_enabled": True,
+        #                            "confirmation_required": "15"
+        #                        },
+        #                        {
+        #                            "network_id": "SOL",
+        #                            "withdrawal_fee": "5.31000000",
+        #                            "withdraw_enabled": True,
+        #                            "min_withdrawal_amount": "10.62",
+        #                            "deposit_enabled": True,
+        #                            "confirmation_required": "1"
+        #                        }
+        #                    ]
+        #                }
+        #            }
+        #        }
+        #    }
+        #
+        resultData = self.safe_dict(response, 'result', {})
+        currencyMap = self.safe_dict(resultData, 'currency_map', {})
+        keys = list(currencyMap.keys())
+        result: dict = {}
+        for i in range(0, len(keys)):
+            key = keys[i]
+            currency = currencyMap[key]
+            id = key
+            code = self.safe_currency_code(id)
+            networks: dict = {}
+            chains = self.safe_list(currency, 'network_list', [])
+            for j in range(0, len(chains)):
+                chain = chains[j]
+                networkId = self.safe_string(chain, 'network_id')
+                network = self.network_id_to_code(networkId)
+                networks[network] = {
+                    'info': chain,
+                    'id': networkId,
+                    'network': network,
+                    'active': None,
+                    'deposit': self.safe_bool(chain, 'deposit_enabled', False),
+                    'withdraw': self.safe_bool(chain, 'withdraw_enabled', False),
+                    'fee': self.safe_number(chain, 'withdrawal_fee'),
+                    'precision': None,
+                    'limits': {
+                        'withdraw': {
+                            'min': self.safe_number(chain, 'min_withdrawal_amount'),
+                            'max': None,
+                        },
+                    },
+                }
+            result[code] = self.safe_currency_structure({
+                'info': currency,
+                'id': id,
+                'code': code,
+                'name': self.safe_string(currency, 'full_name'),
+                'active': None,
+                'deposit': None,
+                'withdraw': None,
+                'fee': None,
+                'precision': None,
+                'limits': {
+                    'amount': {
+                        'min': None,
+                        'max': None,
+                    },
+                },
+                'type': 'crypto',  # only crypto now
+                'networks': networks,
+            })
+        return result
+
     async def fetch_markets(self, params={}) -> List[Market]:
         """
 

ccxt/async_support/cryptomus.py

@@ -369,41 +369,9 @@ class cryptomus(Exchange, ImplicitAPI):
         coins = self.safe_list(response, 'result')
         result: dict = {}
         for i in range(0, len(coins)):
-            currency = coins[i]
-            currencyId = self.safe_string(currency, 'currency_code')
+            networkEntry = coins[i]
+            currencyId = self.safe_string(networkEntry, 'currency_code')
             code = self.safe_currency_code(currencyId)
-            allowWithdraw = self.safe_bool(currency, 'can_withdraw')
-            allowDeposit = self.safe_bool(currency, 'can_deposit')
-            isActive = allowWithdraw and allowDeposit
-            networkId = self.safe_string(currency, 'network_code')
-            networksById = self.safe_dict(self.options, 'networksById')
-            networkName = self.safe_string(networksById, networkId, networkId)
-            minWithdraw = self.safe_number(currency, 'min_withdraw')
-            maxWithdraw = self.safe_number(currency, 'max_withdraw')
-            minDeposit = self.safe_number(currency, 'min_deposit')
-            maxDeposit = self.safe_number(currency, 'max_deposit')
-            network = {
-                'id': networkId,
-                'network': networkName,
-                'limits': {
-                    'withdraw': {
-                        'min': minWithdraw,
-                        'max': maxWithdraw,
-                    },
-                    'deposit': {
-                        'min': minDeposit,
-                        'max': maxDeposit,
-                    },
-                },
-                'active': isActive,
-                'deposit': allowDeposit,
-                'withdraw': allowWithdraw,
-                'fee': None,
-                'precision': None,
-                'info': currency,
-            }
-            networks = {}
-            networks[networkName] = network
             if not (code in result):
                 result[code] = {
                     'id': currencyId,
@@ -411,60 +379,54 @@ class cryptomus(Exchange, ImplicitAPI):
                     'precision': None,
                     'type': None,
                     'name': None,
-                    'active': isActive,
-                    'deposit': allowDeposit,
-                    'withdraw': allowWithdraw,
+                    'active': None,
+                    'deposit': None,
+                    'withdraw': None,
                     'fee': None,
                     'limits': {
                         'withdraw': {
-                            'min': minWithdraw,
-                            'max': maxWithdraw,
+                            'min': None,
+                            'max': None,
                         },
                         'deposit': {
-                            'min': minDeposit,
-                            'max': maxDeposit,
+                            'min': None,
+                            'max': None,
                         },
                     },
-                    'networks': networks,
-                    'info': currency,
-                }
-            else:
-                parsed = result[code]
-                parsedNetworks = self.safe_dict(parsed, 'networks')
-                parsed['networks'] = self.extend(parsedNetworks, networks)
-                if isActive:
-                    parsed['active'] = True
-                    parsed['deposit'] = True
-                    parsed['withdraw'] = True
-                else:
-                    if allowWithdraw:
-                        parsed['withdraw'] = True
-                    if allowDeposit:
-                        parsed['deposit'] = True
-                parsedLimits = self.safe_dict(parsed, 'limits')
-                withdrawLimits = {
-                    'min': None,
-                    'max': None,
+                    'networks': {},
+                    'info': {},
                 }
-                parsedWithdrawLimits = self.safe_dict(parsedLimits, 'withdraw', withdrawLimits)
-                depositLimits = {
-                    'min': None,
-                    'max': None,
-                }
-                parsedDepositLimits = self.safe_dict(parsedLimits, 'deposit', depositLimits)
-                if minWithdraw:
-                    withdrawLimits['min'] = min(parsedWithdrawLimits['min'], minWithdraw) if parsedWithdrawLimits['min'] else minWithdraw
-                if maxWithdraw:
-                    withdrawLimits['max'] = max(parsedWithdrawLimits['max'], maxWithdraw) if parsedWithdrawLimits['max'] else maxWithdraw
-                if minDeposit:
-                    depositLimits['min'] = min(parsedDepositLimits['min'], minDeposit) if parsedDepositLimits['min'] else minDeposit
-                if maxDeposit:
-                    depositLimits['max'] = max(parsedDepositLimits['max'], maxDeposit) if parsedDepositLimits['max'] else maxDeposit
-                limits = {
-                    'withdraw': withdrawLimits,
-                    'deposit': depositLimits,
-                }
-                parsed['limits'] = limits
+            networkId = self.safe_string(networkEntry, 'network_code')
+            networkCode = self.network_id_to_code(networkId)
+            result[code]['networks'][networkCode] = {
+                'id': networkId,
+                'network': networkCode,
+                'limits': {
+                    'withdraw': {
+                        'min': self.safe_number(networkEntry, 'min_withdraw'),
+                        'max': self.safe_number(networkEntry, 'max_withdraw'),
+                    },
+                    'deposit': {
+                        'min': self.safe_number(networkEntry, 'min_deposit'),
+                        'max': self.safe_number(networkEntry, 'max_deposit'),
+                    },
+                },
+                'active': None,
+                'deposit': self.safe_bool(networkEntry, 'can_withdraw'),
+                'withdraw': self.safe_bool(networkEntry, 'can_deposit'),
+                'fee': None,
+                'precision': None,
+                'info': networkEntry,
+            }
+            # add entry in info
+            info = self.safe_list(result[code], 'info', [])
+            info.append(networkEntry)
+            result[code]['info'] = info
+        # only after all entries are formed in currencies, restructure each entry
+        allKeys = list(result.keys())
+        for i in range(0, len(allKeys)):
+            code = allKeys[i]
+            result[code] = self.safe_currency_structure(result[code])  # self is needed after adding network entry
         return result
 
     async def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:

ccxt/async_support/delta.py

@@ -509,31 +509,49 @@ class delta(Exchange, ImplicitAPI):
         """
         response = await self.publicGetAssets(params)
         #
-        #     {
-        #         "result":[
-        #             {
-        #                 "base_withdrawal_fee":"0.0005",
-        #                 "deposit_status":"enabled",
-        #                 "id":2,
-        #                 "interest_credit":true,
-        #                 "interest_slabs":[
-        #                     {"limit":"0.1","rate":"0"},
-        #                     {"limit":"1","rate":"0.05"},
-        #                     {"limit":"5","rate":"0.075"},
-        #                     {"limit":"10","rate":"0.1"},
-        #                     {"limit":"9999999999999999","rate":"0"}
-        #                 ],
-        #                 "kyc_deposit_limit":"10",
-        #                 "kyc_withdrawal_limit":"2",
-        #                 "min_withdrawal_amount":"0.001",
-        #                 "minimum_precision":4,
-        #                 "name":"Bitcoin",
-        #                 "precision":8,
-        #                 "sort_priority":1,
-        #                 "symbol":"BTC",
-        #                 "variable_withdrawal_fee":"0",
-        #                 "withdrawal_status":"enabled"
-        #             },
+        #    {
+        #        "result": [
+        #            {
+        #                "base_withdrawal_fee": "0.005000000000000000",
+        #                "id": "1",
+        #                "interest_credit": False,
+        #                "interest_slabs": null,
+        #                "kyc_deposit_limit": "0.000000000000000000",
+        #                "kyc_withdrawal_limit": "0.000000000000000000",
+        #                "min_withdrawal_amount": "0.010000000000000000",
+        #                "minimum_precision": "4",
+        #                "name": "Ethereum",
+        #                "networks": [
+        #                    {
+        #                        "allowed_deposit_groups": null,
+        #                        "base_withdrawal_fee": "0.0025",
+        #                        "deposit_status": "enabled",
+        #                        "memo_required": False,
+        #                        "min_deposit_amount": "0.000050000000000000",
+        #                        "min_withdrawal_amount": "0.010000000000000000",
+        #                        "minimum_deposit_confirmations": "12",
+        #                        "network": "ERC20",
+        #                        "variable_withdrawal_fee": "0",
+        #                        "withdrawal_status": "enabled"
+        #                    },
+        #                    {
+        #                        "allowed_deposit_groups": null,
+        #                        "base_withdrawal_fee": "0.0001",
+        #                        "deposit_status": "enabled",
+        #                        "memo_required": False,
+        #                        "min_deposit_amount": "0.000050000000000000",
+        #                        "min_withdrawal_amount": "0.000300000000000000",
+        #                        "minimum_deposit_confirmations": "15",
+        #                        "network": "BEP20(BSC)",
+        #                        "variable_withdrawal_fee": "0",
+        #                        "withdrawal_status": "enabled"
+        #                    }
+        #                ],
+        #                "precision": "18",
+        #                "sort_priority": "3",
+        #                "symbol": "ETH",
+        #                "variable_withdrawal_fee": "0.000000000000000000"
+        #            },
         #         ],
         #         "success":true
         #     }
@@ -545,20 +563,41 @@ class delta(Exchange, ImplicitAPI):
             id = self.safe_string(currency, 'symbol')
             numericId = self.safe_integer(currency, 'id')
             code = self.safe_currency_code(id)
-            depositStatus = self.safe_string(currency, 'deposit_status')
-            withdrawalStatus = self.safe_string(currency, 'withdrawal_status')
-            depositsEnabled = (depositStatus == 'enabled')
-            withdrawalsEnabled = (withdrawalStatus == 'enabled')
-            active = depositsEnabled and withdrawalsEnabled
-            result[code] = {
+            chains = self.safe_list(currency, 'networks', [])
+            networks = {}
+            for j in range(0, len(chains)):
+                chain = chains[j]
+                networkId = self.safe_string(chain, 'network')
+                networkCode = self.network_id_to_code(networkId)
+                networks[networkCode] = {
+                    'id': networkId,
+                    'network': networkCode,
+                    'name': self.safe_string(chain, 'name'),
+                    'info': chain,
+                    'active': self.safe_string(chain, 'status') == 'enabled',
+                    'deposit': self.safe_string(chain, 'deposit_status') == 'enabled',
+                    'withdraw': self.safe_string(chain, 'withdrawal_status') == 'enabled',
+                    'fee': self.safe_number(chain, 'base_withdrawal_fee'),
+                    'limits': {
+                        'deposit': {
+                            'min': self.safe_number(chain, 'min_deposit_amount'),
+                            'max': None,
+                        },
+                        'withdraw': {
+                            'min': self.safe_number(chain, 'min_withdrawal_amount'),
+                            'max': None,
+                        },
+                    },
+                }
+            result[code] = self.safe_currency_structure({
                 'id': id,
                 'numericId': numericId,
                 'code': code,
                 'name': self.safe_string(currency, 'name'),
                 'info': currency,  # the original payload
-                'active': active,
-                'deposit': depositsEnabled,
-                'withdraw': withdrawalsEnabled,
+                'active': None,
+                'deposit': self.safe_string(currency, 'deposit_status') == 'enabled',
+                'withdraw': self.safe_string(currency, 'withdrawal_status') == 'enabled',
                 'fee': self.safe_number(currency, 'base_withdrawal_fee'),
                 'precision': self.parse_number(self.parse_precision(self.safe_string(currency, 'precision'))),
                 'limits': {
@@ -568,9 +607,9 @@ class delta(Exchange, ImplicitAPI):
                         'max': None,
                     },
                 },
-                'networks': {},
+                'networks': networks,
                 'type': 'crypto',
-            }
+            })
         return result
 
     async def load_markets(self, reload=False, params={}):