ccxt 4.4.82__py2.py3-none-any.whl → 4.4.86__py2.py3-none-any.whl

ccxt/async_support/deribit.py

@@ -640,18 +640,17 @@ class deribit(Exchange, ImplicitAPI):
         #      "testnet": True
         #    }
         #
-        data = self.safe_value(response, 'result', {})
+        data = self.safe_list(response, 'result', [])
         result: dict = {}
         for i in range(0, len(data)):
             currency = data[i]
             currencyId = self.safe_string(currency, 'currency')
             code = self.safe_currency_code(currencyId)
-            name = self.safe_string(currency, 'currency_long')
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'info': currency,
                 'code': code,
                 'id': currencyId,
-                'name': name,
+                'name': self.safe_string(currency, 'currency_long'),
                 'active': None,
                 'deposit': None,
                 'withdraw': None,
@@ -673,7 +672,7 @@ class deribit(Exchange, ImplicitAPI):
                     },
                 },
                 'networks': None,
-            }
+            })
         return result
 
     def code_from_options(self, methodName, params={}):

ccxt/async_support/derive.py

@@ -461,14 +461,50 @@ class derive(Exchange, ImplicitAPI):
         result: dict = {}
         tokenResponse = await self.publicGetGetAllCurrencies(params)
         #
-        # {
-        #     "result": [
-        #         {
-        #             "currency": "USDC",
-        #             "spot_price": "1.000066413299999872",
-        #             "spot_price_24h": "1.000327785299999872"
-        #         }
-        #     ],
+        #    {
+        #        "result": [
+        #            {
+        #                "currency": "SEI",
+        #                "instrument_types": [
+        #                    "perp"
+        #                ],
+        #                "protocol_asset_addresses": {
+        #                    "perp": "0x7225889B75fd34C68eA3098dAE04D50553C09840",
+        #                    "option": null,
+        #                    "spot": null,
+        #                    "underlying_erc20": null
+        #                },
+        #                "managers": [
+        #                    {
+        #                        "address": "0x28c9ddF9A3B29c2E6a561c1BC520954e5A33de5D",
+        #                        "margin_type": "SM",
+        #                        "currency": null
+        #                    }
+        #                ],
+        #                "srm_im_discount": "0",
+        #                "srm_mm_discount": "0",
+        #                "pm2_collateral_discounts": [],
+        #                "borrow_apy": "0",
+        #                "supply_apy": "0",
+        #                "total_borrow": "0",
+        #                "total_supply": "0",
+        #                "asset_cap_and_supply_per_manager": {
+        #                    "perp": {
+        #                        "SM": [
+        #                            {
+        #                                "current_open_interest": "0",
+        #                                "interest_cap": "2000000",
+        #                                "manager_currency": null
+        #                            }
+        #                        ]
+        #                    },
+        #                    "option": {},
+        #                    "erc20": {}
+        #                },
+        #                "market_type": "SRM_PERP_ONLY",
+        #                "spot_price": "0.2193542905042081",
+        #                "spot_price_24h": "0.238381655533635830"
+        #            },
         #     "id": "7e07fe1d-0ab4-4d2b-9e22-b65ce9e232dc"
         # }
         #
@@ -477,7 +513,7 @@ class derive(Exchange, ImplicitAPI):
             currency = currencies[i]
             currencyId = self.safe_string(currency, 'currency')
             code = self.safe_currency_code(currencyId)
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'id': currencyId,
                 'name': None,
                 'code': code,
@@ -498,7 +534,7 @@ class derive(Exchange, ImplicitAPI):
                     },
                 },
                 'info': currency,
-            }
+            })
         return result
 
     async def fetch_markets(self, params={}) -> List[Market]:

ccxt/async_support/ellipx.py

@@ -6,7 +6,7 @@
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.ellipx import ImplicitAPI
 import math
-from ccxt.base.types import Any, Balances, Currencies, Currency, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Ticker, Trade, TradingFeeInterface, Transaction
+from ccxt.base.types import Any, Balances, Currencies, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Ticker, Trade, TradingFeeInterface, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -799,80 +799,178 @@ class ellipx(Exchange, ImplicitAPI):
             'results_per_page': 100,
             '_expand': '/Crypto_Token,/Crypto_Chain',
         }, params))
-        currencies = {}
-        data = self.safe_value(response, 'data', [])
+        result = {}
+        data = self.safe_list(response, 'data', [])
         for i in range(0, len(data)):
-            currency = self.parse_currency(data[i])
-            code = self.safe_string(currency, 'code')
-            if code is not None:
-                currencies[code] = currency
-        return currencies
-
-    def parse_currency(self, currency) -> Currency:
-        id = self.safe_string(currency, 'Crypto_Token__')
-        token = self.safe_value(currency, 'Crypto_Token', {})
-        code = self.safe_currency_code(self.safe_string(token, 'Symbol'))
-        name = self.safe_string(token, 'Name')
-        active = self.safe_string(currency, 'Status') == 'valid'
-        deposit = self.safe_string(currency, 'Can_Deposit') == 'Y'
-        withdraw = self.safe_string(currency, 'Status') == 'valid'
-        fee = None
-        if currency['Withdraw_Fee'] is not None:
-            fee = self.parse_number(self.parse_amount(currency['Withdraw_Fee']))
-        precision = self.parse_number(self.parse_precision(self.safe_string(token, 'Decimals')))
-        minDeposit = None
-        if currency['Minimum_Deposit'] is not None:
-            minDeposit = self.parse_amount(currency['Minimum_Deposit'])
-        minWithdraw = None
-        if currency['Minimum_Withdraw'] is not None:
-            minWithdraw = self.parse_amount(currency['Minimum_Withdraw'])
-        networkId = self.safe_string(currency, 'Crypto_Chain__')
-        networkData = self.safe_value(currency, 'Crypto_Chain', {})
-        networkCode = self.safe_string(networkData, 'Type', 'default')
-        networks = {
-            'string': None,
-            'info': networkCode == {} if 'default' else networkData,
-            'id': networkId or id or '',
-            'network': networkCode,
-            'active': active,
-            'deposit': deposit,
-            'withdraw': withdraw,
-            'fee': fee,
-            'precision': precision,
-            'limits': {
-                'deposit': {
-                    'min': minDeposit,
-                    'max': None,
-                },
-                'withdraw': {
-                    'min': minWithdraw,
-                    'max': None,
-                },
-            },
-        }
-        result: Currency = {
-            'info': currency,
-            'id': id,
-            'code': code,
-            'name': name,
-            'active': active,
-            'deposit': deposit,
-            'withdraw': withdraw,
-            'fee': fee,
-            'precision': precision,
-            'type': None,
-            'limits': {
-                'amount': {
-                    'min': None,
-                    'max': None,
-                },
-                'withdraw': {
-                    'min': minWithdraw,
-                    'max': None,
+            networkEntry = data[i]
+            #
+            #    {
+            #        "Crypto_Token_Info__": "crtev-5nsn35-f4ir-g5hp-iaft-i4ztx6zu",
+            #        "Crypto_Token__": "crtok-c5v3mh-grfn-hl5d-lmel-fvggbf4i",
+            #        "Crypto_Chain__": "chain-xjbini-7wlz-dmzf-gm7z-zf7ei6fq",
+            #        "Type": "native",
+            #        "Symbol": null,
+            #        "Name": null,
+            #        "Contract_Address": null,
+            #        "Minimum_Deposit": {
+            #            "v": "6",
+            #            "e": "6",
+            #            "f": "6.0e-6"
+            #        },
+            #        "Minimum_Withdraw": {
+            #            "v": "15",
+            #            "e": "5",
+            #            "f": "0.00015"
+            #        },
+            #        "Withdraw_Fee": {
+            #            "v": "1",
+            #            "e": "4",
+            #            "f": "0.0001"
+            #        },
+            #        "Minimum_Collect": null,
+            #        "Status": "valid",
+            #        "Can_Deposit": "Y",
+            #        "Decimals": null,
+            #        "Priority": "100",
+            #        "Created": {
+            #            "unix": "1727552199",
+            #            "us": "0",
+            #            "iso": "2024-09-28 19:36:39.000000",
+            #            "tz": "UTC",
+            #            "full": "1727552199000000",
+            #            "unixms": "1727552199000"
+            #        },
+            #        "Crypto_Token": {
+            #            "Crypto_Token__": "crtok-c5v3mh-grfn-hl5d-lmel-fvggbf4i",
+            #            "Name": "Bitcoin",
+            #            "Symbol": "BTC",
+            #            "Decimals": "8",
+            #            "CMC_Id": "1",
+            #            "Priority": "100",
+            #            "Can_Deposit": "Y",
+            #            "Category": "token",
+            #            "Testnet": "N",
+            #            "Created": {
+            #                "unix": "1727552113",
+            #                "us": "0",
+            #                "iso": "2024-09-28 19:35:13.000000",
+            #                "tz": "UTC",
+            #                "full": "1727552113000000",
+            #                "unixms": "1727552113000"
+            #            },
+            #            "Logo": [
+            #                {
+            #                    "Crypto_Token_Logo__": "ctklg-aoozyr-rzm5-fphf-dhm7-5wbtetha",
+            #                    "Crypto_Token__": "crtok-c5v3mh-grfn-hl5d-lmel-fvggbf4i",
+            #                    "Blob__": "blob-d6hvgx-37s5-dh5h-ogj5-qxqvnaoy",
+            #                    "Default": "Y",
+            #                    "Format": "png",
+            #                    "Priority": "0",
+            #                    "Created": {
+            #                        "unix": "1730196627",
+            #                        "us": "929660",
+            #                        "iso": "2024-10-29 10:10:27.929660",
+            #                        "tz": "UTC",
+            #                        "full": "1730196627929660",
+            #                        "unixms": "1730196627929"
+            #                    },
+            #                    "Source": {
+            #                        "Media_Image__": "blob-d6hvgx-37s5-dh5h-ogj5-qxqvnaoy",
+            #                        "Url": "https://static.atonline.net/image/m_X7_tnmIYFCwn6EUVQuMKqrCuPB3CMl4ONTegeYpC0wIg68YZM0CuBpbjspnYwz/1a942eab068a2173e66d08c736283cfe22e1c1ed"
+            #                    }
+            #                }
+            #            ]
+            #        },
+            #        "Crypto_Chain": {
+            #            "Crypto_Chain__": "chain-xjbini-7wlz-dmzf-gm7z-zf7ei6fq",
+            #            "EVM_Chain__": null,
+            #            "Crypto_Token__": "crtok-c5v3mh-grfn-hl5d-lmel-fvggbf4i",
+            #            "Name": "Bitcoin",
+            #            "Key": "bitcoin",
+            #            "Type": "Bitcoin",
+            #            "Curve": "secp256k1",
+            #            "Backend_Url": null,
+            #            "Wallet_Verification_Methods": {
+            #                "signature": True
+            #            },
+            #            "Block_Margin": "3",
+            #            "Created": {
+            #                "unix": "1725340084",
+            #                "us": "0",
+            #                "iso": "2024-09-03 05:08:04.000000",
+            #                "tz": "UTC",
+            #                "full": "1725340084000000",
+            #                "unixms": "1725340084000"
+            #            }
+            #        }
+            #    }
+            #
+            id = self.safe_string(networkEntry, 'Crypto_Token__')
+            token = self.safe_dict(networkEntry, 'Crypto_Token', {})
+            code = self.safe_currency_code(self.safe_string(token, 'Symbol'))
+            if not (code in result):
+                result[code] = {
+                    'id': id,
+                    'code': code,
+                    'info': [],
+                    'type': None,
+                    'name': self.safe_string(token, 'Name'),
+                    'active': None,
+                    'deposit': None,
+                    'withdraw': None,
+                    'fee': None,
+                    'precision': None,
+                    'limits': {
+                        'amount': {
+                            'min': None,
+                            'max': None,
+                        },
+                        'withdraw': {
+                            'min': None,
+                            'max': None,
+                        },
+                        'deposit': {
+                            'min': None,
+                            'max': None,
+                        },
+                    },
+                    'networks': {},
+                }
+            networkId = self.safe_string(networkEntry, 'Crypto_Chain__')
+            cryptoChainDict = self.safe_string(networkEntry, 'Crypto_Chain')
+            networkName = self.safe_string(cryptoChainDict, 'Type', 'default')
+            networkCode = self.network_id_to_code(networkName)
+            result[code]['networks'][networkCode] = {
+                'id': networkId,
+                'network': networkCode,
+                'active': self.safe_string(networkEntry, 'Status') == 'valid',
+                'deposit': self.safe_string(networkEntry, 'Can_Deposit') == 'Y',
+                'withdraw': None,
+                'fee': self.parse_number(self.parse_amount(networkEntry['Withdraw_Fee'])),
+                'precision': self.parse_number(self.parse_precision(self.safe_string(token, 'Decimals'))),
+                'limits': {
+                    'amount': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'withdraw': {
+                        'min': self.parse_amount(networkEntry['Minimum_Withdraw']),
+                        'max': None,
+                    },
+                    'deposit': {
+                        'min': self.parse_amount(networkEntry['Minimum_Deposit']),
+                        'max': None,
+                    },
                 },
-            },
-            'networks': networks,
-        }
+            }
+            infos = self.safe_list(result[code], 'info', [])
+            infos.append(networkEntry)
+            result[code]['info'] = infos
+        # 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_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
@@ -1065,14 +1163,14 @@ class ellipx(Exchange, ImplicitAPI):
         for i in range(0, len(dataArray)):
             entry = dataArray[i]
             balance = self.safe_dict(entry, 'Balance', {})
-            currency = self.safe_string(balance, 'currency')
-            if currency is not None:
+            code = self.safe_string(balance, 'currency')
+            if code is not None:
                 account = {
                     'free': self.parse_amount(entry['Unencumbered_Balance']['value_xint']),
                     'used': self.parse_amount(entry['Liabilities']['value_xint']),
                     'total': self.parse_amount(balance['value_xint']),
                 }
-                result[currency] = account
+                result[code] = account
         return self.safe_balance(result)
 
     async def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
@@ -1678,7 +1776,7 @@ class ellipx(Exchange, ImplicitAPI):
 
         https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.zegupoa8g4t9
 
-        :param str code: Currency code
+        :param str code: unified currency code
         :param number amount: Amount to withdraw
         :param str address: Destination wallet address
         :param str [tag]: Additional tag/memo for currencies that require it

ccxt/async_support/gate.py

@@ -1866,7 +1866,7 @@ class gate(Exchange, ImplicitAPI):
                     'code': code,
                     'type': type,
                     'precision': precision,
-                    'limits': self.limits,
+                    'limits': None,
                     'networks': {},
                     'info': [],  # will be filled below
                 }

ccxt/async_support/gemini.py

@@ -276,7 +276,7 @@ class gemini(Exchange, ImplicitAPI):
                 'fetchMarketFromWebRetries': 10,
                 'fetchMarketsFromAPI': {
                     'fetchDetailsForAllSymbols': False,
-                    'quoteCurrencies': ['USDT', 'GUSD', 'USD', 'DAI', 'EUR', 'GBP', 'SGD', 'BTC', 'ETH', 'LTC', 'BCH'],
+                    'quoteCurrencies': ['USDT', 'GUSD', 'USD', 'DAI', 'EUR', 'GBP', 'SGD', 'BTC', 'ETH', 'LTC', 'BCH', 'SOL'],
                 },
                 'fetchMarkets': {
                     'webApiEnable': True,  # fetches from WEB
@@ -431,7 +431,6 @@ class gemini(Exchange, ImplicitAPI):
             networkCode = None
             if networkId is not None:
                 networkCode = self.network_id_to_code(networkId)
-            if networkCode is not None:
                 networks[networkCode] = {
                     'info': currency,
                     'id': networkId,
@@ -452,7 +451,7 @@ class gemini(Exchange, ImplicitAPI):
                         },
                     },
                 }
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'info': currency,
                 'id': id,
                 'code': code,
@@ -474,7 +473,7 @@ class gemini(Exchange, ImplicitAPI):
                     },
                 },
                 'networks': networks,
-            }
+            })
         return result
 
     async def fetch_markets(self, params={}) -> List[Market]:

ccxt/async_support/hitbtc.py

@@ -929,29 +929,46 @@ class hitbtc(Exchange, ImplicitAPI):
         """
         response = await self.publicGetPublicCurrency(params)
         #
-        #     {
-        #       "WEALTH": {
-        #         "full_name": "ConnectWealth",
-        #         "payin_enabled": False,
-        #         "payout_enabled": False,
-        #         "transfer_enabled": True,
-        #         "precision_transfer": "0.001",
-        #         "networks": [
-        #           {
-        #             "network": "ETH",
-        #             "protocol": "ERC20",
-        #             "default": True,
-        #             "payin_enabled": False,
-        #             "payout_enabled": False,
-        #             "precision_payout": "0.001",
-        #             "payout_fee": "0.016800000000",
-        #             "payout_is_payment_id": False,
-        #             "payin_payment_id": False,
-        #             "payin_confirmations": "2"
-        #           }
-        #         ]
-        #       }
-        #     }
+        #    {
+        #        "DFC": {
+        #            "full_name": "DeFiScale",
+        #            "crypto": True,
+        #            "payin_enabled": False,
+        #            "payout_enabled": True,
+        #            "transfer_enabled": False,
+        #            "transfer_to_wallet_enabled": True,
+        #            "transfer_to_exchange_enabled": False,
+        #            "sign": "D",
+        #            "crypto_payment_id_name": "",
+        #            "crypto_explorer": "https://etherscan.io/tx/{tx}",
+        #            "precision_transfer": "0.00000001",
+        #            "delisted": False,
+        #            "networks": [
+        #                {
+        #                    "code": "ETH",
+        #                    "network_name": "Ethereum",
+        #                    "network": "ETH",
+        #                    "protocol": "ERC-20",
+        #                    "default": True,
+        #                    "is_ens_available": True,
+        #                    "payin_enabled": True,
+        #                    "payout_enabled": True,
+        #                    "precision_payout": "0.000000000000000001",
+        #                    "payout_fee": "277000.0000000000",
+        #                    "payout_is_payment_id": False,
+        #                    "payin_payment_id": False,
+        #                    "payin_confirmations": "2",
+        #                    "contract_address": "0x1b2a76da77d03b7fc21189d9838f55bd849014af",
+        #                    "crypto_payment_id_name": "",
+        #                    "crypto_explorer": "https://etherscan.io/tx/{tx}",
+        #                    "is_multichain": True,
+        #                    "asset_id": {
+        #                        "contract_address": "0x1b2a76da77d03b7fc21189d9838f55bd849014af"
+        #                    }
+        #                }
+        #            ]
+        #        },
+        #    }
         #
         result: dict = {}
         currencies = list(response.keys())
@@ -959,46 +976,22 @@ class hitbtc(Exchange, ImplicitAPI):
             currencyId = currencies[i]
             code = self.safe_currency_code(currencyId)
             entry = response[currencyId]
-            name = self.safe_string(entry, 'full_name')
-            precision = self.safe_number(entry, 'precision_transfer')
-            payinEnabled = self.safe_bool(entry, 'payin_enabled', False)
-            payoutEnabled = self.safe_bool(entry, 'payout_enabled', False)
-            transferEnabled = self.safe_bool(entry, 'transfer_enabled', False)
-            active = payinEnabled and payoutEnabled and transferEnabled
-            rawNetworks = self.safe_value(entry, 'networks', [])
-            isCrypto = self.safe_bool(entry, 'crypto')
-            type = 'crypto' if isCrypto else 'fiat'
+            rawNetworks = self.safe_list(entry, 'networks', [])
             networks: dict = {}
-            fee = None
-            depositEnabled = None
-            withdrawEnabled = None
             for j in range(0, len(rawNetworks)):
                 rawNetwork = rawNetworks[j]
                 networkId = self.safe_string_2(rawNetwork, 'protocol', 'network')
                 networkCode = self.network_id_to_code(networkId)
-                networkCode = networkCode.upper() if (networkCode is not None) else None
-                fee = self.safe_number(rawNetwork, 'payout_fee')
-                networkPrecision = self.safe_number(rawNetwork, 'precision_payout')
-                payinEnabledNetwork = self.safe_bool(rawNetwork, 'payin_enabled', False)
-                payoutEnabledNetwork = self.safe_bool(rawNetwork, 'payout_enabled', False)
-                activeNetwork = payinEnabledNetwork and payoutEnabledNetwork
-                if payinEnabledNetwork and not depositEnabled:
-                    depositEnabled = True
-                elif not payinEnabledNetwork:
-                    depositEnabled = False
-                if payoutEnabledNetwork and not withdrawEnabled:
-                    withdrawEnabled = True
-                elif not payoutEnabledNetwork:
-                    withdrawEnabled = False
+                networkCode = networkCode.upper() if (networkCode is not None) else code  # is white label, ensure we safeguard from possible bugs
                 networks[networkCode] = {
                     'info': rawNetwork,
                     'id': networkId,
                     'network': networkCode,
-                    'fee': fee,
-                    'active': activeNetwork,
-                    'deposit': payinEnabledNetwork,
-                    'withdraw': payoutEnabledNetwork,
-                    'precision': networkPrecision,
+                    'active': None,
+                    'fee': self.safe_number(rawNetwork, 'payout_fee'),
+                    'deposit': self.safe_bool(rawNetwork, 'payin_enabled'),
+                    'withdraw': self.safe_bool(rawNetwork, 'payout_enabled'),
+                    'precision': self.safe_number(rawNetwork, 'precision_payout'),
                     'limits': {
                         'withdraw': {
                             'min': None,
@@ -1006,27 +999,25 @@ class hitbtc(Exchange, ImplicitAPI):
                         },
                     },
                 }
-            networksKeys = list(networks.keys())
-            networksLength = len(networksKeys)
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'info': entry,
                 'code': code,
                 'id': currencyId,
-                'precision': precision,
-                'name': name,
-                'active': active,
-                'deposit': depositEnabled,
-                'withdraw': withdrawEnabled,
+                'precision': self.safe_number(entry, 'precision_transfer'),
+                'name': self.safe_string(entry, 'full_name'),
+                'active': not self.safe_bool(entry, 'delisted'),
+                'deposit': self.safe_bool(entry, 'payin_enabled'),
+                'withdraw': self.safe_bool(entry, 'payout_enabled'),
                 'networks': networks,
-                'fee': fee if (networksLength <= 1) else None,
+                'fee': None,
                 'limits': {
                     'amount': {
                         'min': None,
                         'max': None,
                     },
                 },
-                'type': type,
-            }
+                'type': None,  # 'crypto' field emits incorrect values
+            })
         return result
 
     async def create_deposit_address(self, code: str, params={}) -> DepositAddress: