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

ccxt/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
 
     def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:

ccxt/delta.py

@@ -509,31 +509,49 @@ class delta(Exchange, ImplicitAPI):
         """
         response = 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
 
     def load_markets(self, reload=False, params={}):

ccxt/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/derive.py

@@ -460,14 +460,50 @@ class derive(Exchange, ImplicitAPI):
         result: dict = {}
         tokenResponse = 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"
         # }
         #
@@ -476,7 +512,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,
@@ -497,7 +533,7 @@ class derive(Exchange, ImplicitAPI):
                     },
                 },
                 'info': currency,
-            }
+            })
         return result
 
     def fetch_markets(self, params={}) -> List[Market]: