ccxt 4.4.88__py2.py3-none-any.whl → 4.4.90__py2.py3-none-any.whl

ccxt/kraken.py

@@ -569,9 +569,12 @@ class kraken(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: an array of objects representing market data
         """
+        promises = []
+        promises.append(self.publicGetAssetPairs(params))
         if self.options['adjustForTimeDifference']:
-            self.load_time_difference()
-        response = self.publicGetAssetPairs(params)
+            promises.append(self.load_time_difference())
+        responses = promises
+        assetsResponse = responses[0]
         #
         #     {
         #         "error": [],
@@ -619,7 +622,8 @@ class kraken(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        markets = self.safe_value(response, 'result', {})
+        markets = self.safe_dict(assetsResponse, 'result', {})
+        cachedCurrencies = self.safe_dict(self.options, 'cachedCurrencies', {})
         keys = list(markets.keys())
         result = []
         for i in range(0, len(keys)):
@@ -629,39 +633,45 @@ class kraken(Exchange, ImplicitAPI):
             quoteId = self.safe_string(market, 'quote')
             base = self.safe_currency_code(baseId)
             quote = self.safe_currency_code(quoteId)
-            darkpool = id.find('.d') >= 0
-            altname = self.safe_string(market, 'altname')
-            makerFees = self.safe_value(market, 'fees_maker', [])
-            firstMakerFee = self.safe_value(makerFees, 0, [])
+            makerFees = self.safe_list(market, 'fees_maker', [])
+            firstMakerFee = self.safe_list(makerFees, 0, [])
             firstMakerFeeRate = self.safe_string(firstMakerFee, 1)
             maker = None
             if firstMakerFeeRate is not None:
                 maker = self.parse_number(Precise.string_div(firstMakerFeeRate, '100'))
-            takerFees = self.safe_value(market, 'fees', [])
-            firstTakerFee = self.safe_value(takerFees, 0, [])
+            takerFees = self.safe_list(market, 'fees', [])
+            firstTakerFee = self.safe_list(takerFees, 0, [])
             firstTakerFeeRate = self.safe_string(firstTakerFee, 1)
             taker = None
             if firstTakerFeeRate is not None:
                 taker = self.parse_number(Precise.string_div(firstTakerFeeRate, '100'))
-            leverageBuy = self.safe_value(market, 'leverage_buy', [])
+            leverageBuy = self.safe_list(market, 'leverage_buy', [])
             leverageBuyLength = len(leverageBuy)
             precisionPrice = self.parse_number(self.parse_precision(self.safe_string(market, 'pair_decimals')))
+            precisionAmount = self.parse_number(self.parse_precision(self.safe_string(market, 'lot_decimals')))
+            spot = True
+            # fix https://github.com/freqtrade/freqtrade/issues/11765#issuecomment-2894224103
+            if spot and (base in cachedCurrencies):
+                currency = cachedCurrencies[base]
+                currencyPrecision = self.safe_number(currency, 'precision')
+                # if currency precision is greater(e.g. 0.01) than market precision(e.g. 0.001)
+                if currencyPrecision > precisionAmount:
+                    precisionAmount = currencyPrecision
             status = self.safe_string(market, 'status')
             isActive = status == 'online'
             result.append({
                 'id': id,
                 'wsId': self.safe_string(market, 'wsname'),
-                'symbol': altname if darkpool else (base + '/' + quote),
+                'symbol': base + '/' + quote,
                 'base': base,
                 'quote': quote,
                 'settle': None,
                 'baseId': baseId,
                 'quoteId': quoteId,
                 'settleId': None,
-                'darkpool': darkpool,
                 'altname': market['altname'],
                 'type': 'spot',
-                'spot': True,
+                'spot': spot,
                 'margin': (leverageBuyLength > 0),
                 'swap': False,
                 'future': False,
@@ -678,7 +688,7 @@ class kraken(Exchange, ImplicitAPI):
                 'strike': None,
                 'optionType': None,
                 'precision': {
-                    'amount': self.parse_number(self.parse_precision(self.safe_string(market, 'lot_decimals'))),
+                    'amount': precisionAmount,
                     'price': precisionPrice,
                 },
                 'limits': {
@@ -691,7 +701,7 @@ class kraken(Exchange, ImplicitAPI):
                         'max': None,
                     },
                     'price': {
-                        'min': precisionPrice,
+                        'min': None,
                         'max': None,
                     },
                     'cost': {
@@ -702,7 +712,6 @@ class kraken(Exchange, ImplicitAPI):
                 'created': None,
                 'info': market,
             })
-        result = self.append_inactive_markets(result)
         self.options['marketsByAltname'] = self.index_by(result, 'altname')
         return result
 
@@ -714,32 +723,6 @@ class kraken(Exchange, ImplicitAPI):
                         currencyId = currencyId[1:]
         return super(kraken, self).safe_currency(currencyId, currency)
 
-    def append_inactive_markets(self, result):
-        # result should be an array to append to
-        precision: dict = {
-            'amount': self.parse_number('1e-8'),
-            'price': self.parse_number('1e-8'),
-        }
-        costLimits: dict = {'min': None, 'max': None}
-        priceLimits: dict = {'min': precision['price'], 'max': None}
-        amountLimits: dict = {'min': precision['amount'], 'max': None}
-        limits: dict = {'amount': amountLimits, 'price': priceLimits, 'cost': costLimits}
-        defaults: dict = {
-            'darkpool': False,
-            'info': None,
-            'maker': None,
-            'taker': None,
-            'active': False,
-            'precision': precision,
-            'limits': limits,
-        }
-        markets = [
-            # {'id': 'XXLMZEUR', 'symbol': 'XLM/EUR', 'base': 'XLM', 'quote': 'EUR', 'altname': 'XLMEUR'},
-        ]
-        for i in range(0, len(markets)):
-            result.append(self.extend(defaults, markets[i]))
-        return result
-
     def fetch_status(self, params={}):
         """
         the latest known information on the availability of the exchange API
@@ -980,8 +963,6 @@ class kraken(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        if market['darkpool']:
-            raise ExchangeError(self.id + ' fetchOrderBook() does not provide an order book for darkpool symbol ' + symbol)
         request: dict = {
             'pair': market['id'],
         }
@@ -1084,7 +1065,7 @@ class kraken(Exchange, ImplicitAPI):
             for i in range(0, len(symbols)):
                 symbol = symbols[i]
                 market = self.markets[symbol]
-                if market['active'] and not market['darkpool']:
+                if market['active']:
                     marketIds.append(market['id'])
             request['pair'] = ','.join(marketIds)
         response = self.publicGetTicker(self.extend(request, params))
@@ -1110,9 +1091,6 @@ class kraken(Exchange, ImplicitAPI):
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
         self.load_markets()
-        darkpool = symbol.find('.d') >= 0
-        if darkpool:
-            raise ExchangeError(self.id + ' fetchTicker() does not provide a ticker for darkpool symbol ' + symbol)
         market = self.market(symbol)
         request: dict = {
             'pair': market['id'],
@@ -3329,6 +3307,6 @@ class kraken(Exchange, ImplicitAPI):
                         for i in range(0, len(response['error'])):
                             error = response['error'][i]
                             self.throw_exactly_matched_exception(self.exceptions['exact'], error, message)
-                            self.throw_exactly_matched_exception(self.exceptions['broad'], error, message)
+                            self.throw_broadly_matched_exception(self.exceptions['broad'], error, message)
                         raise ExchangeError(message)
         return None

ccxt/luno.py

@@ -5,7 +5,7 @@
 
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.luno import ImplicitAPI
-from ccxt.base.types import Account, Any, Balances, Currency, DepositAddress, Int, LedgerEntry, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface
+from ccxt.base.types import Account, Any, Balances, Currencies, Currency, DepositAddress, Int, LedgerEntry, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ArgumentsRequired
@@ -44,6 +44,7 @@ class luno(Exchange, ImplicitAPI):
                 'fetchClosedOrders': True,
                 'fetchCrossBorrowRate': False,
                 'fetchCrossBorrowRates': False,
+                'fetchCurrencies': True,
                 'fetchDepositAddress': True,
                 'fetchFundingHistory': False,
                 'fetchFundingRate': False,
@@ -125,6 +126,7 @@ class luno(Exchange, ImplicitAPI):
                         'accounts/{id}/transactions': 1,
                         'balance': 1,
                         'beneficiaries': 1,
+                        'send/networks': 1,
                         'fee_info': 1,
                         'funding_address': 1,
                         'listorders': 1,
@@ -265,6 +267,90 @@ class luno(Exchange, ImplicitAPI):
             },
         })
 
+    def fetch_currencies(self, params={}) -> Currencies:
+        """
+        fetches all available currencies on an exchange
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an associative dictionary of currencies
+        """
+        if not self.check_required_credentials(False):
+            return None
+        response = self.privateGetSendNetworks(params)
+        #
+        #     {
+        #         "networks": [
+        #           {
+        #             "id": 0,
+        #             "name": "Ethereum",
+        #             "native_currency": "ETH"
+        #           },
+        #           ...
+        #         ]
+        #     }
+        #
+        currenciesData = self.safe_list(response, 'data', [])
+        result: dict = {}
+        for i in range(0, len(currenciesData)):
+            networkEntry = currenciesData[i]
+            id = self.safe_string(networkEntry, 'native_currency')
+            code = self.safe_currency_code(id)
+            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': {},
+                }
+            networkId = self.safe_string(networkEntry, 'name')
+            networkCode = self.network_id_to_code(networkId)
+            result[code]['networks'][networkCode] = {
+                'id': networkId,
+                'network': networkCode,
+                'limits': {
+                    'withdraw': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'deposit': {
+                        'min': None,
+                        'max': None,
+                    },
+                },
+                'active': None,
+                'deposit': None,
+                'withdraw': None,
+                'fee': None,
+                'precision': None,
+                'info': networkEntry,
+            }
+            # add entry in info
+            info = self.safe_list(result[code], 'info', [])
+            info.append(networkEntry)
+            result[code]['info'] = info
+        # only after all entries are formed in currencies, restructure each entry
+        allKeys = list(result.keys())
+        for i in range(0, len(allKeys)):
+            code = allKeys[i]
+            result[code] = self.safe_currency_structure(result[code])  # self is needed after adding network entry
+        return result
+
     def fetch_markets(self, params={}) -> List[Market]:
         """
         retrieves data on all markets for luno

ccxt/okx.py

@@ -1606,6 +1606,7 @@ class okx(Exchange, ImplicitAPI):
         #         "instType": "OPTION",
         #         "lever": "",
         #         "listTime": "1631262612280",
+        #         "contTdSwTime": "1631262812280",
         #         "lotSz": "1",
         #         "minSz": "1",
         #         "optType": "P",
@@ -1685,7 +1686,7 @@ class okx(Exchange, ImplicitAPI):
             'expiryDatetime': self.iso8601(expiry),
             'strike': self.parse_number(strikePrice),
             'optionType': optionType,
-            'created': self.safe_integer(market, 'listTime'),
+            'created': self.safe_integer_2(market, 'contTdSwTime', 'listTime'),  # contTdSwTime is public trading start time, while listTime considers pre-trading too
             'precision': {
                 'amount': self.safe_number(market, 'lotSz'),
                 'price': self.safe_number(market, 'tickSz'),

ccxt/phemex.py

@@ -597,6 +597,7 @@ class phemex(Exchange, ImplicitAPI):
                 },
                 'defaultNetworks': {
                     'USDT': 'ETH',
+                    'MKR': 'ETH',
                 },
                 'defaultSubType': 'linear',
                 'accountsByType': {
@@ -3321,6 +3322,7 @@ class phemex(Exchange, ImplicitAPI):
         fetch the deposit address for a currency associated with self account
         :param str code: unified currency code
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.network]: the chain name to fetch the deposit address e.g. ETH, TRX, EOS, SOL, etc.
         :returns dict: an `address structure <https://docs.ccxt.com/#/?id=address-structure>`
         """
         self.load_markets()
@@ -3331,20 +3333,26 @@ class phemex(Exchange, ImplicitAPI):
         defaultNetworks = self.safe_dict(self.options, 'defaultNetworks')
         defaultNetwork = self.safe_string_upper(defaultNetworks, code)
         networks = self.safe_dict(self.options, 'networks', {})
-        network = self.safe_string_upper(params, 'network', defaultNetwork)
+        network = self.safe_string_upper_2(params, 'network', 'chainName', defaultNetwork)
         network = self.safe_string(networks, network, network)
         if network is None:
-            request['chainName'] = currency['id']
+            raise ArgumentsRequired(self.id + ' fetchDepositAddress() requires a network parameter')
         else:
             request['chainName'] = network
             params = self.omit(params, 'network')
-        response = self.privateGetPhemexUserWalletsV2DepositAddress(self.extend(request, params))
+        response = self.privateGetExchangeWalletsV2DepositAddress(self.extend(request, params))
+        #
         #     {
-        #         "code":0,
-        #         "msg":"OK",
-        #         "data":{
-        #             "address":"0x5bfbf60e0fa7f63598e6cfd8a7fd3ffac4ccc6ad",
-        #             "tag":null
+        #         "code": 0,
+        #         "msg": "OK",
+        #         "data": {
+        #             "address": "tb1qxel5wq5gumt",
+        #             "tag": "",
+        #             "notice": False,
+        #             "accountType": 1,
+        #             "contractName": null,
+        #             "chainTokenUrl": null,
+        #             "sign": null
         #         }
         #     }
         #

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.88'
+__version__ = '4.4.90'
 
 # ----------------------------------------------------------------------------
 
@@ -56,132 +56,6 @@ from ccxt.base.errors import UnsubscribeError                         # noqa: F4
 from ccxt.base.errors import error_hierarchy                          # noqa: F401
 # DO_NOT_REMOVE__ERROR_IMPORTS_END
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 from ccxt.pro.alpaca import alpaca                                        # noqa: F401
 from ccxt.pro.apex import apex                                            # noqa: F401
 from ccxt.pro.ascendex import ascendex                                    # noqa: F401

ccxt/pro/coinbase.py

@@ -160,6 +160,7 @@ class coinbase(ccxt.async_support.coinbase):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
+        await self.load_markets()
         name = 'ticker'
         return await self.subscribe(name, False, symbol, params)
 
@@ -173,6 +174,7 @@ class coinbase(ccxt.async_support.coinbase):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
+        await self.load_markets()
         if symbols is None:
             symbols = self.symbols
         name = 'ticker_batch'

ccxt/pro/cryptocom.py

@@ -36,6 +36,7 @@ class cryptocom(ccxt.async_support.cryptocom):
                 'createOrderWs': True,
                 'cancelOrderWs': True,
                 'cancelAllOrders': True,
+                'editOrderWs': True,
             },
             'urls': {
                 'api': {
@@ -1019,6 +1020,31 @@ class cryptocom(ccxt.async_support.cryptocom):
         messageHash = self.nonce()
         return await self.watch_private_request(messageHash, request)
 
+    async def edit_order_ws(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: Num = None, price: Num = None, params={}) -> Order:
+        """
+        edit a trade order
+
+        https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#private-amend-order
+
+        :param str id: order id
+        :param str symbol: unified market symbol of the order to edit
+        :param str [type]: not used by cryptocom editOrder
+        :param str [side]: not used by cryptocom editOrder
+        :param float amount:(mandatory) how much of the currency you want to trade in units of the base currency
+        :param float price:(mandatory) the price for the order, in units of the quote currency, ignored in market orders
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.clientOrderId]: the original client order id of the order to edit, required if id is not provided
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        params = self.edit_order_request(id, symbol, amount, price, params)
+        request: dict = {
+            'method': 'private/amend-order',
+            'params': params,
+        }
+        messageHash = self.nonce()
+        return await self.watch_private_request(messageHash, request)
+
     def handle_order(self, client: Client, message):
         #
         #    {
@@ -1258,6 +1284,7 @@ class cryptocom(ccxt.async_support.cryptocom):
             'public/heartbeat': self.handle_ping,
             'public/auth': self.handle_authenticate,
             'private/create-order': self.handle_order,
+            'private/amend-order': self.handle_order,
             'private/cancel-order': self.handle_order,
             'private/cancel-all-orders': self.handle_cancel_all_orders,
             'private/close-position': self.handle_order,

ccxt/pro/kraken.py

@@ -825,15 +825,9 @@ class kraken(ccxt.async_support.kraken):
             for i in range(0, len(self.symbols)):
                 symbol = self.symbols[i]
                 market = self.markets[symbol]
-                if market['darkpool']:
-                    info = self.safe_value(market, 'info', {})
-                    altname = self.safe_string(info, 'altname')
-                    wsName = altname[0:3] + '/' + altname[3:]
-                    marketsByWsName[wsName] = market
-                else:
-                    info = self.safe_value(market, 'info', {})
-                    wsName = self.safe_string(info, 'wsname')
-                    marketsByWsName[wsName] = market
+                info = self.safe_value(market, 'info', {})
+                wsName = self.safe_string(info, 'wsname')
+                marketsByWsName[wsName] = market
             self.options['marketsByWsName'] = marketsByWsName
         return markets
 

ccxt/tradeogre.py

@@ -425,13 +425,13 @@ class tradeogre(Exchange, ImplicitAPI):
             'vwap': None,
             'open': self.safe_string(ticker, 'initialprice'),
             'close': self.safe_string(ticker, 'price'),
-            'last': None,
+            'last': self.safe_string(ticker, 'price'),
             'previousClose': None,
             'change': None,
             'percentage': None,
             'average': None,
-            'baseVolume': None,
-            'quoteVolume': self.safe_string(ticker, 'volume'),
+            'baseVolume': self.safe_string(ticker, 'volume'),
+            'quoteVolume': None,
             'info': ticker,
         }, market)
 

ccxt/xt.py

@@ -2846,7 +2846,7 @@ class xt(Exchange, ImplicitAPI):
             if trigger or stopLossTakeProfit:
                 request['state'] = 'NOT_TRIGGERED'
             elif type == 'swap':
-                request['state'] = 'NEW'
+                request['state'] = 'UNFINISHED'  # NEW & PARTIALLY_FILLED
         elif status == 'closed':
             if trigger or stopLossTakeProfit:
                 request['state'] = 'TRIGGERED'