ccxt 4.4.85__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/hollaex.py

@@ -292,6 +292,14 @@ class hollaex(Exchange, ImplicitAPI):
                     'BNB': 'bnb',
                     'MATIC': 'matic',
                 },
+                'networksById': {
+                    'eth': 'ERC20',
+                    'ETH': 'ERC20',
+                    'ERC20': 'ERC20',
+                    'trx': 'TRC20',
+                    'TRX': 'TRC20',
+                    'TRC20': 'TRC20',
+                },
             },
         })
 
@@ -421,66 +429,115 @@ class hollaex(Exchange, ImplicitAPI):
         """
         response = await self.publicGetConstants(params)
         #
-        #     {
-        #         "coins":{
-        #             "bch":{
-        #                 "id":4,
-        #                 "fullname":"Bitcoin Cash",
-        #                 "symbol":"bch",
-        #                 "active":true,
-        #                 "verified":true,
-        #                 "allow_deposit":true,
-        #                 "allow_withdrawal":true,
-        #                 "withdrawal_fee":0.0002,
-        #                 "min":0.001,
-        #                 "max":100000,
-        #                 "increment_unit":0.001,
-        #                 "logo":"https://bitholla.s3.ap-northeast-2.amazonaws.com/icon/BCH-hollaex-asset-01.svg",
-        #                 "code":"bch",
-        #                 "is_public":true,
-        #                 "meta":{},
-        #                 "estimated_price":null,
-        #                 "description":null,
-        #                 "type":"blockchain",
-        #                 "network":null,
-        #                 "standard":null,
-        #                 "issuer":"HollaEx",
-        #                 "withdrawal_fees":null,
-        #                 "created_at":"2019-08-09T10:45:43.367Z",
-        #                 "updated_at":"2021-12-13T03:08:32.372Z",
-        #                 "created_by":1,
-        #                 "owner_id":1
-        #             },
+        #    {
+        #        "coins": {
+        #            "usdt": {
+        #                "id": "6",
+        #                "fullname": "USD Tether",
+        #                "symbol": "usdt",
+        #                "active": True,
+        #                "verified": True,
+        #                "allow_deposit": True,
+        #                "allow_withdrawal": True,
+        #                "withdrawal_fee": "20",
+        #                "min": "1",
+        #                "max": "10000000",
+        #                "increment_unit": "0.0001",
+        #                "logo": "https://hollaex-resources.s3.ap-southeast-1.amazonaws.com/icons/usdt.svg",
+        #                "code": "usdt",
+        #                "is_public": True,
+        #                "meta": {
+        #                    "color": "#27a17a",
+        #                    "website": "https://tether.to",
+        #                    "explorer": "https://blockchair.com/tether",
+        #                    "decimal_points": "6"
+        #                },
+        #                "estimated_price": "1",
+        #                "description": "<p>Tether(USDT) is a stablecoin pegged 1:1 to the US dollar. It is a digital currency that aims to maintain its value while allowing for fast and secure transfer of funds. It was the first stablecoin, and is the most widely used due stablecoin due to its stability and low volatility compared to other cryptocurrencies. It was launched in 2014 by Tether Limited.</p>",
+        #                "type": "blockchain",
+        #                "network": "eth,trx,bnb,matic",
+        #                "standard": "",
+        #                "issuer": "HollaEx",
+        #                "withdrawal_fees": {
+        #                    "bnb": {
+        #                        "value": "0.8",
+        #                        "active": True,
+        #                        "symbol": "usdt"
+        #                    },
+        #                    "eth": {
+        #                        "value": "1.5",
+        #                        "active": True,
+        #                        "symbol": "usdt"
+        #                    },
+        #                    "trx": {
+        #                        "value": "4",
+        #                        "active": True,
+        #                        "symbol": "usdt"
+        #                    },
+        #                    "matic": {
+        #                        "value": "0.3",
+        #                        "active": True,
+        #                        "symbol": "usdt"
+        #                    }
+        #                },
+        #                "display_name": null,
+        #                "deposit_fees": null,
+        #                "is_risky": False,
+        #                "market_cap": "144568098696.29",
+        #                "category": "stable",
+        #                "created_at": "2019-08-09T10:45:43.367Z",
+        #                "updated_at": "2025-03-25T17:12:37.970Z",
+        #                "created_by": "168",
+        #                "owner_id": "1"
+        #            },
         #         },
         #         "network":"https://api.hollaex.network"
         #     }
         #
-        coins = self.safe_value(response, 'coins', {})
+        coins = self.safe_dict(response, 'coins', {})
         keys = list(coins.keys())
         result: dict = {}
         for i in range(0, len(keys)):
             key = keys[i]
             currency = coins[key]
             id = self.safe_string(currency, 'symbol')
-            numericId = self.safe_integer(currency, 'id')
             code = self.safe_currency_code(id)
-            name = self.safe_string(currency, 'fullname')
-            depositEnabled = self.safe_value(currency, 'allow_deposit')
-            withdrawEnabled = self.safe_value(currency, 'allow_withdrawal')
-            isActive = self.safe_value(currency, 'active')
-            active = isActive and depositEnabled and withdrawEnabled
-            fee = self.safe_number(currency, 'withdrawal_fee')
-            withdrawalLimits = self.safe_value(currency, 'withdrawal_limits', [])
-            result[code] = {
+            withdrawalLimits = self.safe_list(currency, 'withdrawal_limits', [])
+            rawType = self.safe_string(currency, 'type')
+            type = 'crypto' if (rawType == 'blockchain') else 'other'
+            rawNetworks = self.safe_dict(currency, 'withdrawal_fees', {})
+            networks = {}
+            networkIds = list(rawNetworks.keys())
+            for j in range(0, len(networkIds)):
+                networkId = networkIds[j]
+                networkEntry = self.safe_dict(rawNetworks, networkId)
+                networkCode = self.network_id_to_code(networkId)
+                networks[networkCode] = {
+                    'id': networkId,
+                    'network': networkCode,
+                    'active': self.safe_bool(networkEntry, 'active'),
+                    'deposit': None,
+                    'withdraw': None,
+                    'fee': self.safe_number(networkEntry, 'value'),
+                    'precision': None,
+                    'limits': {
+                        'withdraw': {
+                            'min': None,
+                            'max': None,
+                        },
+                    },
+                    'info': networkEntry,
+                }
+            result[code] = self.safe_currency_structure({
                 'id': id,
-                'numericId': numericId,
+                'numericId': self.safe_integer(currency, 'id'),
                 'code': code,
                 'info': currency,
-                'name': name,
-                'active': active,
-                'deposit': depositEnabled,
-                'withdraw': withdrawEnabled,
-                'fee': fee,
+                'name': self.safe_string(currency, 'fullname'),
+                'active': self.safe_bool(currency, 'active'),
+                'deposit': self.safe_bool(currency, 'allow_deposit'),
+                'withdraw': self.safe_bool(currency, 'allow_withdrawal'),
+                'fee': self.safe_number(currency, 'withdrawal_fee'),
                 'precision': self.safe_number(currency, 'increment_unit'),
                 'limits': {
                     'amount': {
@@ -492,9 +549,9 @@ class hollaex(Exchange, ImplicitAPI):
                         'max': self.safe_value(withdrawalLimits, 0),
                     },
                 },
-                'networks': {},
-                'type': 'crypto',
-            }
+                'networks': networks,
+                'type': type,
+            })
         return result
 
     async def fetch_order_books(self, symbols: Strings = None, limit: Int = None, params={}) -> OrderBooks:

ccxt/async_support/htx.py

@@ -3281,9 +3281,8 @@ class htx(Exchange, ImplicitAPI):
         #            }
         #        ]
         #    }
-        #    }
         #
-        data = self.safe_value(response, 'data', [])
+        data = self.safe_list(response, 'data', [])
         result: dict = {}
         self.options['networkChainIdsByNames'] = {}
         self.options['networkNamesByChainIds'] = {}
@@ -3291,19 +3290,11 @@ class htx(Exchange, ImplicitAPI):
             entry = data[i]
             currencyId = self.safe_string(entry, 'currency')
             code = self.safe_currency_code(currencyId)
-            self.options['networkChainIdsByNames'][code] = {}
-            chains = self.safe_value(entry, 'chains', [])
-            networks: dict = {}
-            instStatus = self.safe_string(entry, 'instStatus')
             assetType = self.safe_string(entry, 'assetType')
             type = assetType == 'crypto' if '1' else 'fiat'
-            currencyActive = instStatus == 'normal'
-            minPrecision = None
-            minDeposit = None
-            minWithdraw = None
-            maxWithdraw = None
-            deposit = False
-            withdraw = False
+            self.options['networkChainIdsByNames'][code] = {}
+            chains = self.safe_list(entry, 'chains', [])
+            networks: dict = {}
             for j in range(0, len(chains)):
                 chainEntry = chains[j]
                 uniqueChainId = self.safe_string(chainEntry, 'chain')  # i.e. usdterc20, trc20usdt ...
@@ -3311,47 +3302,33 @@ class htx(Exchange, ImplicitAPI):
                 self.options['networkChainIdsByNames'][code][title] = uniqueChainId
                 self.options['networkNamesByChainIds'][uniqueChainId] = title
                 networkCode = self.network_id_to_code(uniqueChainId)
-                minDeposit = self.safe_number(chainEntry, 'minDepositAmt')
-                minWithdraw = self.safe_number(chainEntry, 'minWithdrawAmt')
-                maxWithdraw = self.safe_number(chainEntry, 'maxWithdrawAmt')
-                withdrawStatus = self.safe_string(chainEntry, 'withdrawStatus')
-                depositStatus = self.safe_string(chainEntry, 'depositStatus')
-                withdrawEnabled = (withdrawStatus == 'allowed')
-                depositEnabled = (depositStatus == 'allowed')
-                withdraw = withdrawEnabled if (withdrawEnabled) else withdraw
-                deposit = depositEnabled if (depositEnabled) else deposit
-                active = withdrawEnabled and depositEnabled
-                precision = self.parse_precision(self.safe_string(chainEntry, 'withdrawPrecision'))
-                if precision is not None:
-                    minPrecision = precision if (minPrecision is None) else Precise.string_min(precision, minPrecision)
-                fee = self.safe_number(chainEntry, 'transactFeeWithdraw')
                 networks[networkCode] = {
                     'info': chainEntry,
                     'id': uniqueChainId,
                     'network': networkCode,
                     'limits': {
                         'deposit': {
-                            'min': minDeposit,
+                            'min': self.safe_number(chainEntry, 'minDepositAmt'),
                             'max': None,
                         },
                         'withdraw': {
-                            'min': minWithdraw,
-                            'max': maxWithdraw,
+                            'min': self.safe_number(chainEntry, 'minWithdrawAmt'),
+                            'max': self.safe_number(chainEntry, 'maxWithdrawAmt'),
                         },
                     },
-                    'active': active,
-                    'deposit': depositEnabled,
-                    'withdraw': withdrawEnabled,
-                    'fee': fee,
-                    'precision': self.parse_number(precision),
+                    'active': None,
+                    'deposit': self.safe_string(chainEntry, 'depositStatus') == 'allowed',
+                    'withdraw': self.safe_string(chainEntry, 'withdrawStatus') == 'allowed',
+                    'fee': self.safe_number(chainEntry, 'transactFeeWithdraw'),
+                    'precision': self.parse_number(self.parse_precision(self.safe_string(chainEntry, 'withdrawPrecision'))),
                 }
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'info': entry,
                 'code': code,
                 'id': currencyId,
-                'active': currencyActive,
-                'deposit': deposit,
-                'withdraw': withdraw,
+                'active': self.safe_string(entry, 'instStatus') == 'normal',
+                'deposit': None,
+                'withdraw': None,
                 'fee': None,
                 'name': None,
                 'type': type,
@@ -3361,17 +3338,17 @@ class htx(Exchange, ImplicitAPI):
                         'max': None,
                     },
                     'withdraw': {
-                        'min': minWithdraw,
-                        'max': maxWithdraw,
+                        'min': None,
+                        'max': None,
                     },
                     'deposit': {
                         'min': None,
                         'max': None,
                     },
                 },
-                'precision': self.parse_number(minPrecision),
+                'precision': None,
                 'networks': networks,
-            }
+            })
         return result
 
     def network_id_to_code(self, networkId: Str = None, currencyCode: Str = None):

ccxt/async_support/hyperliquid.py

@@ -185,12 +185,12 @@ class hyperliquid(Exchange, ImplicitAPI):
             },
             'fees': {
                 'swap': {
-                    'taker': self.parse_number('0.00035'),
-                    'maker': self.parse_number('0.0001'),
+                    'taker': self.parse_number('0.00045'),
+                    'maker': self.parse_number('0.00015'),
                 },
                 'spot': {
-                    'taker': self.parse_number('0.00035'),
-                    'maker': self.parse_number('0.0001'),
+                    'taker': self.parse_number('0.0007'),
+                    'maker': self.parse_number('0.0004'),
                 },
             },
             'requiredCredentials': {

ccxt/async_support/mexc.py

@@ -1097,7 +1097,6 @@ class mexc(Exchange, ImplicitAPI):
             currency = response[i]
             id = self.safe_string(currency, 'coin')
             code = self.safe_currency_code(id)
-            name = self.safe_string(currency, 'name')
             networks: dict = {}
             chains = self.safe_value(currency, 'networkList', [])
             for j in range(0, len(chains)):
@@ -1119,12 +1118,13 @@ class mexc(Exchange, ImplicitAPI):
                             'max': self.safe_string(chain, 'withdrawMax'),
                         },
                     },
+                    'contract': self.safe_string(chain, 'contract'),
                 }
             result[code] = self.safe_currency_structure({
                 'info': currency,
                 'id': id,
                 'code': code,
-                'name': name,
+                'name': self.safe_string(currency, 'name'),
                 'active': None,
                 'deposit': None,
                 'withdraw': None,

ccxt/async_support/ndax.py

@@ -454,44 +454,44 @@ class ndax(Exchange, ImplicitAPI):
         }
         response = await self.publicGetGetProducts(self.extend(request, params))
         #
-        #     [
-        #         {
-        #             "OMSId":1,
-        #             "ProductId":1,
-        #             "Product":"BTC",
-        #             "ProductFullName":"Bitcoin",
-        #             "ProductType":"CryptoCurrency",
-        #             "DecimalPlaces":8,
-        #             "TickSize":0.0000000100000000000000000000,
-        #             "NoFees":false,
-        #             "IsDisabled":false,
-        #             "MarginEnabled":false
-        #         },
-        #     ]
+        #    [
+        #        {
+        #            "OMSId": "1",
+        #            "ProductId": "1",
+        #            "Product": "BTC",
+        #            "ProductFullName": "Bitcoin",
+        #            "MasterDataUniqueProductSymbol": "",
+        #            "ProductType": "CryptoCurrency",
+        #            "DecimalPlaces": "8",
+        #            "TickSize": "0.0000000100000000000000000000",
+        #            "DepositEnabled": True,
+        #            "WithdrawEnabled": True,
+        #            "NoFees": False,
+        #            "IsDisabled": False,
+        #            "MarginEnabled": False
+        #        },
+        #        ...
         #
         result: dict = {}
         for i in range(0, len(response)):
             currency = response[i]
             id = self.safe_string(currency, 'ProductId')
-            name = self.safe_string(currency, 'ProductFullName')
+            code = self.safe_currency_code(self.safe_string(currency, 'Product'))
             ProductType = self.safe_string(currency, 'ProductType')
             type = 'fiat' if (ProductType == 'NationalCurrency') else 'crypto'
             if ProductType == 'Unknown':
                 # such currency is just a blanket entry
                 type = 'other'
-            code = self.safe_currency_code(self.safe_string(currency, 'Product'))
-            isDisabled = self.safe_value(currency, 'IsDisabled')
-            active = not isDisabled
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'id': id,
-                'name': name,
+                'name': self.safe_string(currency, 'ProductFullName'),
                 'code': code,
                 'type': type,
                 'precision': self.safe_number(currency, 'TickSize'),
                 'info': currency,
-                'active': active,
-                'deposit': None,
-                'withdraw': None,
+                'active': not self.safe_bool(currency, 'IsDisabled'),
+                'deposit': self.safe_bool(currency, 'DepositEnabled'),
+                'withdraw': self.safe_bool(currency, 'WithdrawEnabled'),
                 'fee': None,
                 'limits': {
                     'amount': {
@@ -504,7 +504,8 @@ class ndax(Exchange, ImplicitAPI):
                     },
                 },
                 'networks': {},
-            }
+                'margin': self.safe_bool(currency, 'MarginEnabled'),
+            })
         return result
 
     async def fetch_markets(self, params={}) -> List[Market]:

ccxt/async_support/okcoin.py

@@ -840,47 +840,30 @@ class okcoin(Exchange, ImplicitAPI):
             return None
         else:
             response = await self.privateGetAssetCurrencies(params)
-            data = self.safe_value(response, 'data', [])
+            data = self.safe_list(response, 'data', [])
             result: dict = {}
             dataByCurrencyId = self.group_by(data, 'ccy')
             currencyIds = list(dataByCurrencyId.keys())
             for i in range(0, len(currencyIds)):
                 currencyId = currencyIds[i]
-                currency = self.safe_currency(currencyId)
-                code = currency['code']
+                code = self.safe_currency_code(currencyId)
                 chains = dataByCurrencyId[currencyId]
                 networks: dict = {}
-                currencyActive = False
-                depositEnabled = False
-                withdrawEnabled = False
-                maxPrecision = None
                 for j in range(0, len(chains)):
                     chain = chains[j]
-                    canDeposit = self.safe_value(chain, 'canDep')
-                    depositEnabled = canDeposit if (canDeposit) else depositEnabled
-                    canWithdraw = self.safe_value(chain, 'canWd')
-                    withdrawEnabled = canWithdraw if (canWithdraw) else withdrawEnabled
-                    canInternal = self.safe_value(chain, 'canInternal')
-                    active = True if (canDeposit and canWithdraw and canInternal) else False
-                    currencyActive = active if (active) else currencyActive
                     networkId = self.safe_string(chain, 'chain')
                     if (networkId is not None) and (networkId.find('-') >= 0):
                         parts = networkId.split('-')
                         chainPart = self.safe_string(parts, 1, networkId)
                         networkCode = self.network_id_to_code(chainPart)
-                        precision = self.parse_precision(self.safe_string(chain, 'wdTickSz'))
-                        if maxPrecision is None:
-                            maxPrecision = precision
-                        else:
-                            maxPrecision = Precise.string_min(maxPrecision, precision)
                         networks[networkCode] = {
                             'id': networkId,
                             'network': networkCode,
-                            'active': active,
-                            'deposit': canDeposit,
-                            'withdraw': canWithdraw,
+                            'active': None,
+                            'deposit': self.safe_bool(chain, 'canDep'),
+                            'withdraw': self.safe_bool(chain, 'canWd'),
                             'fee': self.safe_number(chain, 'minFee'),
-                            'precision': self.parse_number(precision),
+                            'precision': self.parse_number(self.parse_precision(self.safe_string(chain, 'wdTickSz'))),
                             'limits': {
                                 'withdraw': {
                                     'min': self.safe_number(chain, 'minWd'),
@@ -890,16 +873,16 @@ class okcoin(Exchange, ImplicitAPI):
                             'info': chain,
                         }
                 firstChain = self.safe_value(chains, 0)
-                result[code] = {
+                result[code] = self.safe_currency_structure({
                     'info': chains,
                     'code': code,
                     'id': currencyId,
                     'name': self.safe_string(firstChain, 'name'),
-                    'active': currencyActive,
-                    'deposit': depositEnabled,
-                    'withdraw': withdrawEnabled,
+                    'active': None,
+                    'deposit': None,
+                    'withdraw': None,
                     'fee': None,
-                    'precision': self.parse_number(maxPrecision),
+                    'precision': None,
                     'limits': {
                         'amount': {
                             'min': None,
@@ -907,7 +890,7 @@ class okcoin(Exchange, ImplicitAPI):
                         },
                     },
                     'networks': networks,
-                }
+                })
             return result
 
     async def fetch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:

ccxt/async_support/okx.py

@@ -389,6 +389,7 @@ class okx(Exchange, ImplicitAPI):
                         'account/spot-manual-borrow-repay': 10,
                         'account/set-auto-repay': 4,
                         'account/spot-borrow-repay-history': 4,
+                        'account/move-positions-history': 10,
                         # subaccount
                         'users/subaccount/list': 10,
                         'account/subaccount/balances': 10 / 3,
@@ -526,6 +527,7 @@ class okx(Exchange, ImplicitAPI):
                         'account/fixed-loan/manual-reborrow': 5,
                         'account/fixed-loan/repay-borrowing-order': 5,
                         'account/bills-history-archive': 72000,  # 12 req/day
+                        'account/move-positions': 10,
                         # subaccount
                         'users/subaccount/modify-apikey': 10,
                         'asset/subaccount/transfer': 10,
@@ -992,6 +994,13 @@ class okx(Exchange, ImplicitAPI):
                     '70010': BadRequest,  # Timestamp parameters need to be in Unix timestamp format in milliseconds.
                     '70013': BadRequest,  # endTs needs to be bigger than or equal to beginTs.
                     '70016': BadRequest,  # Please specify your instrument settings for at least one instType.
+                    '70060': BadRequest,  # The account doesn’t exist or the position side is incorrect. To and from accounts must be under the same main account.
+                    '70061': BadRequest,  # To move position, please enter a position that’s opposite to your current side and is smaller than or equal to your current size.
+                    '70062': BadRequest,  # account has reached the maximum number of position transfers allowed per day.
+                    '70064': BadRequest,  # Position does not exist.
+                    '70065': BadRequest,  # Couldn’t move position. Execution price cannot be determined
+                    '70066': BadRequest,  # Moving positions isn't supported in spot mode. Switch to any other account mode and try again.
+                    '70067': BadRequest,  # Moving positions isn't supported in margin trading.
                     '1009': BadRequest,  # Request message exceeds the maximum frame length
                     '4001': AuthenticationError,  # Login Failed
                     '4002': BadRequest,  # Invalid Request

ccxt/async_support/onetrading.py

@@ -405,9 +405,12 @@ class onetrading(Exchange, ImplicitAPI):
         #
         #     [
         #         {
-        #             "code":"BEST",
-        #             "precision":8
-        #         }
+        #             "code": "USDT",
+        #             "precision": 6,
+        #             "unified_cryptoasset_id": 825,
+        #             "name": "Tether USDt",
+        #             "collateral_percentage": 0
+        #         },
         #     ]
         #
         result: dict = {}
@@ -415,11 +418,11 @@ class onetrading(Exchange, ImplicitAPI):
             currency = response[i]
             id = self.safe_string(currency, 'code')
             code = self.safe_currency_code(id)
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'id': id,
                 'code': code,
-                'name': None,
-                'info': currency,  # the original payload
+                'name': self.safe_string(currency, 'name'),
+                'info': currency,
                 'active': None,
                 'fee': None,
                 'precision': self.parse_number(self.parse_precision(self.safe_string(currency, 'precision'))),
@@ -430,7 +433,7 @@ class onetrading(Exchange, ImplicitAPI):
                     'withdraw': {'min': None, 'max': None},
                 },
                 'networks': {},
-            }
+            })
         return result
 
     async def fetch_markets(self, params={}) -> List[Market]: