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

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': {
@@ -369,7 +369,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             id = i
             name = self.safe_string(data, 'name')
             code = self.safe_currency_code(name)
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'id': id,
                 'name': name,
                 'code': code,
@@ -391,7 +391,7 @@ class hyperliquid(Exchange, ImplicitAPI):
                         'max': None,
                     },
                 },
-            }
+            })
         return result
 
     async def fetch_markets(self, params={}) -> List[Market]:

ccxt/async_support/kraken.py

@@ -1616,6 +1616,8 @@ class kraken(Exchange, ImplicitAPI):
             'volume': self.amount_to_precision(symbol, amount),
         }
         orderRequest = self.order_request('createOrder', symbol, type, request, amount, price, params)
+        flags = self.safe_string(orderRequest[0], 'oflags', '')
+        isUsingCost = flags.find('viqc') > -1
         response = await self.privatePostAddOrder(self.extend(orderRequest[0], orderRequest[1]))
         #
         #     {
@@ -1627,6 +1629,10 @@ class kraken(Exchange, ImplicitAPI):
         #     }
         #
         result = self.safe_dict(response, 'result')
+        result['usingCost'] = isUsingCost
+        # it's impossible to know if the order was created using cost or base currency
+        # becuase kraken only returns something like self: {order: 'buy 10.00000000 LTCUSD @ market'}
+        # self usingCost flag is used to help the parsing but omited from the order
         return self.parse_order(result)
 
     def find_market_by_altname_or_id(self, id):
@@ -1713,22 +1719,15 @@ class kraken(Exchange, ImplicitAPI):
         #     }
         #
         #  ws - createOrder
-        #    {
-        #        "descr": 'sell 0.00010000 XBTUSDT @ market',
-        #        "event": 'addOrderStatus',
-        #        "reqid": 1,
-        #        "status": 'ok',
-        #        "txid": 'OAVXZH-XIE54-JCYYDG'
-        #    }
+        #     {
+        #         "order_id": "OXM2QD-EALR2-YBAVEU"
+        #     }
+        #
         #  ws - editOrder
-        #    {
-        #        "descr": "order edited price = 9000.00000000",
-        #        "event": "editOrderStatus",
-        #        "originaltxid": "O65KZW-J4AW3-VFS74A",
-        #        "reqid": 3,
-        #        "status": "ok",
-        #        "txid": "OTI672-HJFAO-XOIPPK"
-        #    }
+        #     {
+        #         "amend_id": "TJSMEH-AA67V-YUSQ6O",
+        #         "order_id": "OXM2QD-EALR2-YBAVEU"
+        #     }
         #
         #  {
         #      "error": [],
@@ -1796,6 +1795,8 @@ class kraken(Exchange, ImplicitAPI):
         #         "oflags": "fciq"
         #     }
         #
+        isUsingCost = self.safe_bool(order, 'usingCost', False)
+        order = self.omit(order, 'usingCost')
         description = self.safe_dict(order, 'descr', {})
         orderDescriptionObj = self.safe_dict(order, 'descr')  # can be null
         orderDescription = None
@@ -1808,11 +1809,15 @@ class kraken(Exchange, ImplicitAPI):
         marketId = None
         price = None
         amount = None
+        cost = None
         triggerPrice = None
         if orderDescription is not None:
             parts = orderDescription.split(' ')
             side = self.safe_string(parts, 0)
-            amount = self.safe_string(parts, 1)
+            if not isUsingCost:
+                amount = self.safe_string(parts, 1)
+            else:
+                cost = self.safe_string(parts, 1)
             marketId = self.safe_string(parts, 2)
             part4 = self.safe_string(parts, 4)
             part5 = self.safe_string(parts, 5)
@@ -1842,13 +1847,12 @@ class kraken(Exchange, ImplicitAPI):
         # kraken truncates the cost in the api response so we will ignore it and calculate it from average & filled
         # cost = self.safe_string(order, 'cost')
         price = self.safe_string(description, 'price', price)
-        # when type = trailling stop returns price = '+50.0000%'
-        if (price is not None) and price.endswith('%'):
+        # when type = trailing stop returns price = '+50.0000%'
+        if (price is not None) and (price.endswith('%') or Precise.string_equals(price, '0.00000') or Precise.string_equals(price, '0')):
             price = None  # self is not the price we want
-        if (price is None) or Precise.string_equals(price, '0'):
+        if price is None:
             price = self.safe_string(description, 'price2')
-        if (price is None) or Precise.string_equals(price, '0'):
-            price = self.safe_string(order, 'price', price)
+            price = self.safe_string_2(order, 'limitprice', 'price', price)
         flags = self.safe_string(order, 'oflags', '')
         isPostOnly = flags.find('post') > -1
         average = self.safe_number(order, 'price')
@@ -1865,7 +1869,7 @@ class kraken(Exchange, ImplicitAPI):
                 elif flags.find('fcib') >= 0:
                     fee['currency'] = market['base']
         status = self.parse_order_status(self.safe_string(order, 'status'))
-        id = self.safe_string_n(order, ['id', 'txid', 'amend_id'])
+        id = self.safe_string_n(order, ['id', 'txid', 'order_id', 'amend_id'])
         if (id is None) or (id.startswith('[')):
             txid = self.safe_list(order, 'txid')
             id = self.safe_string(txid, 0)
@@ -1922,7 +1926,7 @@ class kraken(Exchange, ImplicitAPI):
             'triggerPrice': triggerPrice,
             'takeProfitPrice': takeProfitPrice,
             'stopLossPrice': stopLossPrice,
-            'cost': None,
+            'cost': cost,
             'amount': amount,
             'filled': filled,
             'average': average,

ccxt/async_support/kucoinfutures.py

@@ -1510,6 +1510,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         :param str [params.timeInForce]: GTC, GTT, IOC, or FOK, default is GTC, limit orders only
         :param str [params.postOnly]: Post only flag, invalid when timeInForce is IOC or FOK
         :param float [params.cost]: the cost of the order in units of USDT
+        :param str [params.marginMode]: 'cross' or 'isolated', default is 'isolated'
  ----------------- Exchange Specific Parameters -----------------
         :param float [params.leverage]: Leverage size of the order(mandatory param in request, default is 1)
         :param str [params.clientOid]: client order id, defaults to uuid if not passed
@@ -1607,6 +1608,10 @@ class kucoinfutures(kucoin, ImplicitAPI):
             'type': type,  # limit or market
             'leverage': 1,
         }
+        marginModeUpper = self.safe_string_upper(params, 'marginMode')
+        if marginModeUpper is not None:
+            params = self.omit(params, 'marginMode')
+            request['marginMode'] = marginModeUpper
         cost = self.safe_string(params, 'cost')
         params = self.omit(params, 'cost')
         if cost is not None:

ccxt/async_support/lbank.py

@@ -876,7 +876,7 @@ class lbank(Exchange, ImplicitAPI):
         timestamp = self.milliseconds()
         if market['swap']:
             return self.parse_order_book(orderbook, market['symbol'], timestamp, 'bids', 'asks', 'price', 'volume')
-        return self.parse_order_book(orderbook, market['symbol'], timestamp)
+        return self.parse_order_book(orderbook, market['symbol'], timestamp, 'bids', 'asks', 1, 0)
 
     def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #

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]: