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

ccxt/async_support/oxfun.py

@@ -25,7 +25,6 @@ from ccxt.base.errors import NetworkError
 from ccxt.base.errors import RateLimitExceeded
 from ccxt.base.errors import RequestTimeout
 from ccxt.base.decimal_to_precision import TICK_SIZE
-from ccxt.base.precise import Precise
 
 
 class oxfun(Exchange, ImplicitAPI):
@@ -613,66 +612,7 @@ class oxfun(Exchange, ImplicitAPI):
         #                         "minDeposit": "0.00010",
         #                         "minWithdrawal": "0.00010"
         #                     },
-        #                     {
-        #                         "network": "Arbitrum",
-        #                         "tokenId": "0xba0Dda8762C24dA9487f5FA026a9B64b695A07Ea",
-        #                         "transactionPrecision": "18",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": True,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     },
-        #                     {
-        #                         "network": "Ethereum",
-        #                         "tokenId": "0xba0Dda8762C24dA9487f5FA026a9B64b695A07Ea",
-        #                         "transactionPrecision": "18",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": True,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     },
-        #                     {
-        #                         "network": "Arbitrum",
-        #                         "tokenId": "0x78a0A62Fba6Fb21A83FE8a3433d44C73a4017A6f",
-        #                         "transactionPrecision": "18",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": False,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     },
-        #                     {
-        #                         "network": "Avalanche",
-        #                         "tokenId": "0x78a0A62Fba6Fb21A83FE8a3433d44C73a4017A6f",
-        #                         "transactionPrecision": "18",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": False,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     },
-        #                     {
-        #                         "network": "Solana",
-        #                         "tokenId": "DV3845GEAVXfwpyVGGgWbqBVCtzHdCXNCGfcdboSEuZz",
-        #                         "transactionPrecision": "8",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": True,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     },
-        #                     {
-        #                         "network": "Ethereum",
-        #                         "tokenId": "0x78a0A62Fba6Fb21A83FE8a3433d44C73a4017A6f",
-        #                         "transactionPrecision": "18",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": False,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     }
+        #                     ...
         #                 ]
         #             },
         #             {
@@ -722,74 +662,64 @@ class oxfun(Exchange, ImplicitAPI):
             parts = fullId.split('.')
             id = parts[0]
             code = self.safe_currency_code(id)
-            networks: dict = {}
+            if not (code in result):
+                result[code] = {
+                    'id': id,
+                    'code': code,
+                    'precision': None,
+                    'type': None,
+                    'name': None,
+                    'active': None,
+                    'deposit': None,
+                    'withdraw': None,
+                    'fee': None,
+                    'limits': {
+                        'withdraw': {
+                            'min': None,
+                            'max': None,
+                        },
+                        'deposit': {
+                            'min': None,
+                            'max': None,
+                        },
+                    },
+                    'networks': {},
+                    'info': [],
+                }
             chains = self.safe_list(currency, 'networkList', [])
-            currencyMaxPrecision: Str = None
-            currencyDepositEnabled: Bool = None
-            currencyWithdrawEnabled: Bool = None
             for j in range(0, len(chains)):
                 chain = chains[j]
                 networkId = self.safe_string(chain, 'network')
                 networkCode = self.network_id_to_code(networkId)
-                deposit = self.safe_bool(chain, 'canDeposit')
-                withdraw = self.safe_bool(chain, 'canWithdraw')
-                active = (deposit and withdraw)
-                minDeposit = self.safe_string(chain, 'minDeposit')
-                minWithdrawal = self.safe_string(chain, 'minWithdrawal')
-                precision = self.parse_precision(self.safe_string(chain, 'transactionPrecision'))
-                networks[networkCode] = {
+                result[code]['networks'][networkCode] = {
                     'id': networkId,
                     'network': networkCode,
                     'margin': None,
-                    'deposit': deposit,
-                    'withdraw': withdraw,
-                    'active': active,
+                    'deposit': self.safe_bool(chain, 'canDeposit'),
+                    'withdraw': self.safe_bool(chain, 'canWithdraw'),
+                    'active': None,
                     'fee': None,
-                    'precision': self.parse_number(precision),
+                    'precision': self.parse_number(self.parse_precision(self.safe_string(chain, 'transactionPrecision'))),
                     'limits': {
                         'deposit': {
-                            'min': minDeposit,
+                            'min': self.safe_number(chain, 'minDeposit'),
                             'max': None,
                         },
                         'withdraw': {
-                            'min': minWithdrawal,
+                            'min': self.safe_number(chain, 'minWithdrawal'),
                             'max': None,
                         },
                     },
                     'info': chain,
                 }
-                if (currencyDepositEnabled is None) or deposit:
-                    currencyDepositEnabled = deposit
-                if (currencyWithdrawEnabled is None) or withdraw:
-                    currencyWithdrawEnabled = withdraw
-                if (currencyMaxPrecision is None) or Precise.string_gt(currencyMaxPrecision, precision):
-                    currencyMaxPrecision = precision
-            if code in result:
-                # checking for specific ids.ARB
-                networks = self.extend(result[code]['networks'], networks)
-            result[code] = {
-                'id': id,
-                'code': code,
-                'name': None,
-                'type': None,
-                'active': None,
-                'deposit': currencyDepositEnabled,
-                'withdraw': currencyWithdrawEnabled,
-                'fee': None,
-                'precision': self.parse_number(currencyMaxPrecision),
-                'limits': {
-                    'amount': {
-                        'min': None,
-                        'max': None,
-                    },
-                    'withdraw': {
-                        'min': None,
-                        'max': None,
-                    },
-                },
-                'networks': networks,
-                'info': currency,
-            }
+            infos = self.safe_list(result[code], 'info', [])
+            infos.append(currency)
+            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_tickers(self, symbols: Strings = None, params={}) -> Tickers:

ccxt/async_support/paradex.py

@@ -1245,7 +1245,10 @@ class paradex(Exchange, ImplicitAPI):
         price = self.safe_string(order, 'price')
         amount = self.safe_string(order, 'size')
         orderType = self.safe_string(order, 'type')
+        cancelReason = self.safe_string(order, 'cancel_reason')
         status = self.safe_string(order, 'status')
+        if cancelReason is not None:
+            status = 'canceled'
         side = self.safe_string_lower(order, 'side')
         average = self.omit_zero(self.safe_string(order, 'avg_fill_price'))
         remaining = self.omit_zero(self.safe_string(order, 'remaining_size'))

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.85'
+__version__ = '4.4.86'
 
 # -----------------------------------------------------------------------------
 

ccxt/bequant.py

@@ -14,8 +14,8 @@ class bequant(hitbtc, ImplicitAPI):
         return self.deep_extend(super(bequant, self).describe(), {
             'id': 'bequant',
             'name': 'Bequant',
-            'countries': ['MT'],  # Malta
             'pro': True,
+            'countries': ['MT'],  # Malta
             'urls': {
                 'logo': 'https://github.com/user-attachments/assets/0583ef1f-29fe-4b7c-8189-63565a0e2867',
                 'api': {

ccxt/bitget.py

@@ -2370,7 +2370,7 @@ class bitget(Exchange, ImplicitAPI):
             'coin': currency['id'],
             'address': address,
             'chain': networkId,
-            'size': amount,
+            'size': self.currency_to_precision(code, amount, networkCode),
             'transferType': 'on_chain',
         }
         if tag is not None:
@@ -2394,8 +2394,6 @@ class bitget(Exchange, ImplicitAPI):
         fillResponseFromRequest = self.safe_bool(withdrawOptions, 'fillResponseFromRequest', True)
         if fillResponseFromRequest:
             result['currency'] = code
-            result['timestamp'] = self.milliseconds()
-            result['datetime'] = self.iso8601(self.milliseconds())
             result['amount'] = amount
             result['tag'] = tag
             result['address'] = address
@@ -2513,7 +2511,9 @@ class bitget(Exchange, ImplicitAPI):
         status = self.safe_string(transaction, 'status')
         tag = self.safe_string(transaction, 'tag')
         feeCostString = self.safe_string(transaction, 'fee')
-        feeCostAbsString = Precise.string_abs(feeCostString)
+        feeCostAbsString = None
+        if feeCostString is not None:
+            feeCostAbsString = Precise.string_abs(feeCostString)
         fee = None
         amountString = self.safe_string(transaction, 'size')
         if feeCostAbsString is not None:

ccxt/bitmart.py

@@ -2306,7 +2306,7 @@ class bitmart(Exchange, ImplicitAPI):
                 code = self.safe_currency_code(currencyId)
                 account = self.account()
                 account['free'] = self.safe_string_2(balance, 'available', 'available_balance')
-                account['used'] = self.safe_string_2(balance, 'frozen', 'frozen_balance')
+                account['used'] = self.safe_string_n(balance, ['unAvailable', 'frozen', 'frozen_balance'])
                 result[code] = account
             return self.safe_balance(result)
 

ccxt/{huobijp.py → bittrade.py}

@@ -4,7 +4,7 @@
 # https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
 
 from ccxt.base.exchange import Exchange
-from ccxt.abstract.huobijp import ImplicitAPI
+from ccxt.abstract.bittrade import ImplicitAPI
 import hashlib
 from ccxt.base.types import Account, Any, Balances, Currencies, Currency, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
@@ -27,12 +27,12 @@ from ccxt.base.decimal_to_precision import TICK_SIZE
 from ccxt.base.precise import Precise
 
 
-class huobijp(Exchange, ImplicitAPI):
+class bittrade(Exchange, ImplicitAPI):
 
     def describe(self) -> Any:
-        return self.deep_extend(super(huobijp, self).describe(), {
-            'id': 'huobijp',
-            'name': 'Huobi Japan',
+        return self.deep_extend(super(bittrade, self).describe(), {
+            'id': 'bittrade',
+            'name': 'BitTrade',
             'countries': ['JP'],
             'rateLimit': 100,
             'userAgent': self.userAgents['chrome39'],
@@ -108,10 +108,10 @@ class huobijp(Exchange, ImplicitAPI):
                     'v2Public': 'https://{hostname}',
                     'v2Private': 'https://{hostname}',
                 },
-                'www': 'https://www.huobi.co.jp',
-                'referral': 'https://www.huobi.co.jp/register/?invite_code=znnq3',
-                'doc': 'https://api-doc.huobi.co.jp',
-                'fees': 'https://www.huobi.co.jp/support/fee',
+                'www': 'https://www.bittrade.co.jp',
+                'referral': 'https://www.bittrade.co.jp/register/?invite_code=znnq3',
+                'doc': 'https://api-doc.bittrade.co.jp',
+                'fees': 'https://www.bittrade.co.jp/ja-jp/support/fee',
             },
             'api': {
                 'v2Public': {
@@ -1483,7 +1483,7 @@ class huobijp(Exchange, ImplicitAPI):
         """
         cancels an open order
         :param str id: order id
-        :param str symbol: not used by huobijp cancelOrder()
+        :param str symbol: not used by bittrade cancelOrder()
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
@@ -1503,7 +1503,7 @@ class huobijp(Exchange, ImplicitAPI):
         """
         cancel multiple orders
         :param str[] ids: order ids
-        :param str symbol: not used by huobijp cancelOrders()
+        :param str symbol: not used by bittrade cancelOrders()
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """

ccxt/coinbase.py

@@ -1424,9 +1424,6 @@ class coinbase(Exchange, ImplicitAPI):
                 self.v3PublicGetBrokerageMarketProducts(self.extend(params, {'product_type': 'FUTURE'})),
                 self.v3PublicGetBrokerageMarketProducts(self.extend(params, {'product_type': 'FUTURE', 'contract_expiry_type': 'PERPETUAL'})),
             ]
-            if self.check_required_credentials(False):
-                unresolvedContractPromises.append(self.extend(params, {'product_type': 'FUTURE'}))
-                unresolvedContractPromises.append(self.extend(params, {'product_type': 'FUTURE', 'contract_expiry_type': 'PERPETUAL'}))
         except Exception as e:
             unresolvedContractPromises = []  # the sync version of ccxt won't have the promise.all line so the request is made here. Some users can't access perpetual products
         promises = spotUnresolvedPromises
@@ -1439,8 +1436,8 @@ class coinbase(Exchange, ImplicitAPI):
         fees = self.safe_dict(promises, 1, {})
         expiringFutures = self.safe_dict(contractPromises, 0, {})
         perpetualFutures = self.safe_dict(contractPromises, 1, {})
-        expiringFees = self.safe_dict(contractPromises, 2, {})
-        perpetualFees = self.safe_dict(contractPromises, 3, {})
+        expiringFees = self.safe_dict(contractPromises, 0, {})
+        perpetualFees = self.safe_dict(contractPromises, 1, {})
         #
         #     {
         #         "total_volume": 0,

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/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 = 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
 
     def fetch_order_books(self, symbols: Strings = None, limit: Int = None, params={}) -> OrderBooks: