ccxt 4.3.44__py2.py3-none-any.whl → 4.3.46__py2.py3-none-any.whl

ccxt/bitteam.py

@@ -15,7 +15,7 @@ from ccxt.base.errors import BadSymbol
 from ccxt.base.errors import InsufficientFunds
 from ccxt.base.errors import OrderNotFound
 from ccxt.base.errors import ExchangeNotAvailable
-from ccxt.base.decimal_to_precision import DECIMAL_PLACES
+from ccxt.base.decimal_to_precision import TICK_SIZE
 from ccxt.base.precise import Precise
 
 
@@ -199,7 +199,7 @@ class bitteam(Exchange, ImplicitAPI):
                     'maker': self.parse_number('0.002'),
                 },
             },
-            'precisionMode': DECIMAL_PLACES,
+            'precisionMode': TICK_SIZE,
             # exchange-specific options
             'options': {
                 'networksById': {
@@ -358,8 +358,6 @@ class bitteam(Exchange, ImplicitAPI):
         base = self.safe_currency_code(baseId)
         quote = self.safe_currency_code(quoteId)
         active = self.safe_value(market, 'active')
-        amountPrecision = self.safe_integer(market, 'baseStep')
-        pricePrecision = self.safe_integer(market, 'quoteStep')
         timeStart = self.safe_string(market, 'timeStart')
         created = self.parse8601(timeStart)
         minCost = None
@@ -394,8 +392,8 @@ class bitteam(Exchange, ImplicitAPI):
             'strike': None,
             'optionType': None,
             'precision': {
-                'amount': amountPrecision,
-                'price': pricePrecision,
+                'amount': self.parse_number(self.parse_precision(self.safe_string(market, 'baseStep'))),
+                'price': self.parse_number(self.parse_precision(self.safe_string(market, 'quoteStep'))),
             },
             'limits': {
                 'leverage': {
@@ -549,7 +547,7 @@ class bitteam(Exchange, ImplicitAPI):
             numericId = self.safe_integer(currency, 'id')
             code = self.safe_currency_code(id)
             active = self.safe_bool(currency, 'active', False)
-            precision = self.safe_integer(currency, 'precision')
+            precision = self.parse_number(self.parse_precision(self.safe_string(currency, 'precision')))
             txLimits = self.safe_value(currency, 'txLimits', {})
             minWithdraw = self.safe_string(txLimits, 'minWithdraw')
             maxWithdraw = self.safe_string(txLimits, 'maxWithdraw')
@@ -569,7 +567,7 @@ class bitteam(Exchange, ImplicitAPI):
             withdraw = self.safe_value(statuses, 'withdrawStatus')
             networkIds = list(feesByNetworkId.keys())
             networks: dict = {}
-            networkPrecision = self.safe_integer(currency, 'decimals')
+            networkPrecision = self.parse_number(self.parse_precision(self.safe_string(currency, 'decimals')))
             for j in range(0, len(networkIds)):
                 networkId = networkIds[j]
                 networkCode = self.network_id_to_code(networkId, code)

ccxt/coinmetro.py

@@ -16,7 +16,7 @@ from ccxt.base.errors import InsufficientFunds
 from ccxt.base.errors import InvalidOrder
 from ccxt.base.errors import OrderNotFound
 from ccxt.base.errors import RateLimitExceeded
-from ccxt.base.decimal_to_precision import DECIMAL_PLACES
+from ccxt.base.decimal_to_precision import TICK_SIZE
 from ccxt.base.precise import Precise
 
 
@@ -215,7 +215,7 @@ class coinmetro(Exchange, ImplicitAPI):
                     'maker': self.parse_number('0'),
                 },
             },
-            'precisionMode': DECIMAL_PLACES,
+            'precisionMode': TICK_SIZE,
             # exchange-specific options
             'options': {
                 'currenciesByIdForParseMarket': None,
@@ -317,7 +317,6 @@ class coinmetro(Exchange, ImplicitAPI):
             deposit = self.safe_value(currency, 'canDeposit')
             canTrade = self.safe_value(currency, 'canTrade')
             active = withdraw if canTrade else True
-            precision = self.safe_integer(currency, 'digits')
             minAmount = self.safe_number(currency, 'minQty')
             result[code] = self.safe_currency_structure({
                 'id': id,
@@ -328,7 +327,7 @@ class coinmetro(Exchange, ImplicitAPI):
                 'deposit': deposit,
                 'withdraw': withdraw,
                 'fee': None,
-                'precision': precision,
+                'precision': self.parse_number(self.parse_precision(self.safe_string(currency, 'digits'))),
                 'limits': {
                     'amount': {'min': minAmount, 'max': None},
                     'withdraw': {'min': None, 'max': None},
@@ -354,19 +353,14 @@ class coinmetro(Exchange, ImplicitAPI):
         #
         #     [
         #         {
-        #             "pair": "PERPEUR",
-        #             "precision": 5,
-        #             "margin": False
-        #         },
-        #         {
-        #             "pair": "PERPUSD",
+        #             "pair": "YFIEUR",
         #             "precision": 5,
         #             "margin": False
         #         },
         #         {
-        #             "pair": "YFIEUR",
-        #             "precision": 5,
-        #             "margin": False
+        #             "pair": "BTCEUR",
+        #             "precision": 2,
+        #             "margin": True
         #         },
         #         ...
         #     ]
@@ -412,9 +406,7 @@ class coinmetro(Exchange, ImplicitAPI):
             'optionType': None,
             'precision': {
                 'amount': basePrecisionAndLimits['precision'],
-                'price': quotePrecisionAndLimits['precision'],
-                'base': basePrecisionAndLimits['precision'],
-                'quote': quotePrecisionAndLimits['precision'],
+                'price': self.parse_number(self.parse_precision(self.safe_string(market, 'precision'))),
             },
             'limits': {
                 'leverage': {
@@ -464,12 +456,11 @@ class coinmetro(Exchange, ImplicitAPI):
     def parse_market_precision_and_limits(self, currencyId):
         currencies = self.safe_value(self.options, 'currenciesByIdForParseMarket', {})
         currency = self.safe_value(currencies, currencyId, {})
-        precision = self.safe_integer(currency, 'precision')
         limits = self.safe_value(currency, 'limits', {})
         amountLimits = self.safe_value(limits, 'amount', {})
         minLimit = self.safe_number(amountLimits, 'min')
         result: dict = {
-            'precision': precision,
+            'precision': self.safe_number(currency, 'precision'),
             'minLimit': minLimit,
         }
         return result

ccxt/hyperliquid.py

@@ -5,7 +5,7 @@
 
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.hyperliquid import ImplicitAPI
-from ccxt.base.types import Balances, Currencies, Int, MarginModification, Market, Num, Order, OrderBook, OrderRequest, CancellationRequest, OrderSide, OrderType, Str, Strings, Trade, TransferEntry
+from ccxt.base.types import Balances, Currencies, Int, MarginModification, Market, Num, Order, OrderBook, OrderRequest, CancellationRequest, OrderSide, OrderType, Str, Strings, Trade, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ArgumentsRequired
@@ -31,6 +31,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'rateLimit': 50,  # 1200 requests per minute, 20 request per second
             'certified': False,
             'pro': True,
+            'dex': True,
             'has': {
                 'CORS': None,
                 'spot': True,
@@ -948,11 +949,12 @@ class hyperliquid(Exchange, ImplicitAPI):
         signature = self.sign_message(msg, self.privateKey)
         return signature
 
-    def build_sig(self, chainId, messageTypes, message):
+    def sign_user_signed_action(self, messageTypes, message):
         zeroAddress = self.safe_string(self.options, 'zeroAddress')
+        chainId = 421614  # check self out
         domain: dict = {
             'chainId': chainId,
-            'name': 'Exchange',
+            'name': 'HyperliquidSignTransaction',
             'verifyingContract': zeroAddress,
             'version': '1',
         }
@@ -961,28 +963,26 @@ class hyperliquid(Exchange, ImplicitAPI):
         return signature
 
     def build_transfer_sig(self, message):
-        isSandboxMode = self.safe_bool(self.options, 'sandboxMode')
-        chainId = 421614 if (isSandboxMode) else 42161
         messageTypes: dict = {
-            'UsdTransferSignPayload': [
+            'HyperliquidTransaction:UsdSend': [
+                {'name': 'hyperliquidChain', 'type': 'string'},
                 {'name': 'destination', 'type': 'string'},
                 {'name': 'amount', 'type': 'string'},
                 {'name': 'time', 'type': 'uint64'},
             ],
         }
-        return self.build_sig(chainId, messageTypes, message)
+        return self.sign_user_signed_action(messageTypes, message)
 
     def build_withdraw_sig(self, message):
-        isSandboxMode = self.safe_bool(self.options, 'sandboxMode')
-        chainId = 421614 if (isSandboxMode) else 42161
         messageTypes: dict = {
-            'WithdrawFromBridge2SignPayload': [
+            'HyperliquidTransaction:Withdraw': [
+                {'name': 'hyperliquidChain', 'type': 'string'},
                 {'name': 'destination', 'type': 'string'},
-                {'name': 'usd', 'type': 'string'},
+                {'name': 'amount', 'type': 'string'},
                 {'name': 'time', 'type': 'uint64'},
             ],
         }
-        return self.build_sig(chainId, messageTypes, message)
+        return self.sign_user_signed_action(messageTypes, message)
 
     def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
         """
@@ -2276,8 +2276,9 @@ class hyperliquid(Exchange, ImplicitAPI):
         if code is not None:
             code = code.upper()
             if code != 'USDC':
-                raise NotSupported(self.id + 'withdraw() only support USDC')
+                raise NotSupported(self.id + 'transfer() only support USDC')
         payload: dict = {
+            'hyperliquidChain': 'Testnet' if isSandboxMode else 'Mainnet',
             'destination': toAccount,
             'amount': self.number_to_string(amount),
             'time': nonce,
@@ -2285,9 +2286,12 @@ class hyperliquid(Exchange, ImplicitAPI):
         sig = self.build_transfer_sig(payload)
         request: dict = {
             'action': {
-                'chain': 'ArbitrumTestnet' if (isSandboxMode) else 'Arbitrum',
-                'payload': payload,
-                'type': 'usdTransfer',
+                'hyperliquidChain': payload['hyperliquidChain'],
+                'signatureChainId': '0x66eee',  # check self out
+                'destination': toAccount,
+                'amount': str(amount),
+                'time': nonce,
+                'type': 'usdSend',
             },
             'nonce': nonce,
             'signature': sig,
@@ -2295,7 +2299,7 @@ class hyperliquid(Exchange, ImplicitAPI):
         response = self.privatePostExchange(self.extend(request, params))
         return response
 
-    def withdraw(self, code: str, amount, address, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal(only support USDC)
         :see: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#initiate-a-withdrawal-request
@@ -2313,25 +2317,29 @@ class hyperliquid(Exchange, ImplicitAPI):
             code = code.upper()
             if code != 'USDC':
                 raise NotSupported(self.id + 'withdraw() only support USDC')
-        isSandboxMode = self.safe_bool(self.options, 'sandboxMode')
+        isSandboxMode = self.safe_bool(self.options, 'sandboxMode', False)
         nonce = self.milliseconds()
         payload: dict = {
+            'hyperliquidChain': 'Testnet' if isSandboxMode else 'Mainnet',
             'destination': address,
-            'usd': str(amount),
+            'amount': str(amount),
             'time': nonce,
         }
         sig = self.build_withdraw_sig(payload)
         request: dict = {
             'action': {
-                'chain': 'ArbitrumTestnet' if (isSandboxMode) else 'Arbitrum',
-                'payload': payload,
-                'type': 'withdraw2',
+                'hyperliquidChain': payload['hyperliquidChain'],
+                'signatureChainId': '0x66eee',  # check self out
+                'destination': address,
+                'amount': str(amount),
+                'time': nonce,
+                'type': 'withdraw3',
             },
             'nonce': nonce,
             'signature': sig,
         }
         response = self.privatePostExchange(self.extend(request, params))
-        return response
+        return self.parse_transaction(response)
 
     def format_vault_address(self, address: Str = None):
         if address is None:

ccxt/idex.py

@@ -35,6 +35,7 @@ class idex(Exchange, ImplicitAPI):
             'rateLimit': 1000,
             'version': 'v3',
             'pro': True,
+            'dex': True,
             'certified': False,
             'requiresWeb3': True,
             'has': {

ccxt/kucoin.py

@@ -140,6 +140,7 @@ class kucoin(Exchange, ImplicitAPI):
                     'futuresPublic': 'https://api-futures.kucoin.com',
                     'webExchange': 'https://kucoin.com/_api',
                     'broker': 'https://api-broker.kucoin.com',
+                    'earn': 'https://api.kucoin.com',
                 },
                 'www': 'https://www.kucoin.com',
                 'doc': [
@@ -407,6 +408,9 @@ class kucoin(Exchange, ImplicitAPI):
                         'broker/nd/account': 2,
                         'broker/nd/account/apikey': 2,
                         'broker/nd/rebase/download': 3,
+                        'broker/nd/transfer/detail': 1,
+                        'broker/nd/deposit/detail': 1,
+                        'broker/nd/withdraw/detail': 1,
                     },
                     'post': {
                         'broker/nd/transfer': 1,
@@ -418,6 +422,25 @@ class kucoin(Exchange, ImplicitAPI):
                         'broker/nd/account/apikey': 3,
                     },
                 },
+                'earn': {
+                    'get': {
+                        'otc-loan/loan': 1,
+                        'otc-loan/accounts': 1,
+                        'earn/redeem-preview': 7.5,  # 5EW
+                        'earn/saving/products': 7.5,  # 5EW
+                        'earn/hold-assets': 7.5,  # 5EW
+                        'earn/promotion/products': 7.5,  # 5EW
+                        'earn/kcs-staking/products': 7.5,  # 5EW
+                        'earn/staking/products': 7.5,  # 5EW
+                        'earn/eth-staking/products': 7.5,  # 5EW
+                    },
+                    'post': {
+                        'earn/orders': 7.5,  # 5EW
+                    },
+                    'delete': {
+                        'earn/orders': 7.5,  # 5EW
+                    },
+                },
             },
             'timeframes': {
                 '1m': '1min',
@@ -4506,6 +4529,8 @@ class kucoin(Exchange, ImplicitAPI):
         endpoint = '/api/' + version + '/' + self.implode_params(path, params)
         if api == 'webExchange':
             endpoint = '/' + self.implode_params(path, params)
+        if api == 'earn':
+            endpoint = '/api/v1/' + self.implode_params(path, params)
         query = self.omit(params, self.extract_params(path))
         endpart = ''
         headers = headers if (headers is not None) else {}
@@ -4521,7 +4546,8 @@ class kucoin(Exchange, ImplicitAPI):
         isFuturePrivate = (api == 'futuresPrivate')
         isPrivate = (api == 'private')
         isBroker = (api == 'broker')
-        if isPrivate or isFuturePrivate or isBroker:
+        isEarn = (api == 'earn')
+        if isPrivate or isFuturePrivate or isBroker or isEarn:
             self.check_required_credentials()
             timestamp = str(self.nonce())
             headers = self.extend({

ccxt/luno.py

@@ -897,7 +897,15 @@ class luno(Exchange, ImplicitAPI):
         request: dict = {
             'order_id': id,
         }
-        return self.privatePostStoporder(self.extend(request, params))
+        response = self.privatePostStoporder(self.extend(request, params))
+        #
+        #    {
+        #        "success": True
+        #    }
+        #
+        return self.safe_order({
+            'info': response,
+        })
 
     def fetch_ledger_by_entries(self, code: Str = None, entry=None, limit=None, params={}):
         # by default without entry number or limit number, return most recent entry

ccxt/mexc.py

@@ -235,6 +235,7 @@ class mexc(Exchange, ImplicitAPI):
                             'sub-account/margin': 1,
                             'batchOrders': 10,
                             'capital/withdraw/apply': 1,
+                            'capital/withdraw': 1,
                             'capital/transfer': 1,
                             'capital/transfer/internal': 1,
                             'capital/deposit/address': 1,
@@ -253,6 +254,7 @@ class mexc(Exchange, ImplicitAPI):
                             'margin/order': 1,
                             'margin/openOrders': 1,
                             'userDataStream': 1,
+                            'capital/withdraw': 1,
                         },
                     },
                 },
@@ -1069,7 +1071,7 @@ class mexc(Exchange, ImplicitAPI):
             chains = self.safe_value(currency, 'networkList', [])
             for j in range(0, len(chains)):
                 chain = chains[j]
-                networkId = self.safe_string(chain, 'network')
+                networkId = self.safe_string_2(chain, 'network', 'netWork')
                 network = self.network_id_to_code(networkId)
                 isDepositEnabled = self.safe_bool(chain, 'depositEnable', False)
                 isWithdrawEnabled = self.safe_bool(chain, 'withdrawEnable', False)
@@ -4894,7 +4896,7 @@ class mexc(Exchange, ImplicitAPI):
     def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
         """
         make a withdrawal
-        :see: https://mexcdevelop.github.io/apidocs/spot_v3_en/#withdraw
+        :see: https://mexcdevelop.github.io/apidocs/spot_v3_en/#withdraw-new
         :param str code: unified currency code
         :param float amount: the amount to withdraw
         :param str address: the address to withdraw to
@@ -4904,7 +4906,7 @@ class mexc(Exchange, ImplicitAPI):
         """
         tag, params = self.handle_withdraw_tag_and_params(tag, params)
         networks = self.safe_value(self.options, 'networks', {})
-        network = self.safe_string_2(params, 'network', 'chain')  # self line allows the user to specify either ERC20 or ETH
+        network = self.safe_string_2(params, 'network', 'netWork')  # self line allows the user to specify either ERC20 or ETH
         network = self.safe_string(networks, network, network)  # handle ETH > ERC-20 alias
         self.check_address(address)
         self.load_markets()
@@ -4917,9 +4919,9 @@ class mexc(Exchange, ImplicitAPI):
         if tag is not None:
             request['memo'] = tag
         if network is not None:
-            request['network'] = network
-            params = self.omit(params, ['network', 'chain'])
-        response = self.spotPrivatePostCapitalWithdrawApply(self.extend(request, params))
+            request['netWork'] = network
+            params = self.omit(params, ['network', 'netWork'])
+        response = self.spotPrivatePostCapitalWithdraw(self.extend(request, params))
         #
         #     {
         #       "id":"7213fea8e94b4a5593d507237e5a555b"

ccxt/okx.py

@@ -2385,6 +2385,7 @@ class okx(Exchange, ImplicitAPI):
         :see: https://www.okx.com/docs-v5/en/#funding-account-rest-api-get-balance
         :see: https://www.okx.com/docs-v5/en/#trading-account-rest-api-get-balance
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.type]: wallet type, ['funding' or 'trading'] default is 'trading'
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
         """
         self.load_markets()