ccxt 4.2.58__py2.py3-none-any.whl → 4.2.60__py2.py3-none-any.whl

ccxt/async_support/blofin.py

@@ -6,7 +6,7 @@
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.blofin import ImplicitAPI
 import hashlib
-from ccxt.base.types import Balances, Currency, Int, Leverage, Market, Order, TransferEntry, OrderBook, OrderRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Int, Leverage, Leverages, Market, Order, TransferEntry, OrderBook, OrderRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ArgumentsRequired
@@ -89,6 +89,7 @@ class blofin(Exchange, ImplicitAPI):
                 'fetchLedger': True,
                 'fetchLedgerEntry': None,
                 'fetchLeverage': True,
+                'fetchLeverages': True,
                 'fetchLeverageTiers': False,
                 'fetchMarketLeverageTiers': False,
                 'fetchMarkets': True,
@@ -193,6 +194,7 @@ class blofin(Exchange, ImplicitAPI):
                         'account/balance': 1,
                         'account/positions': 1,
                         'account/leverage-info': 1,
+                        'account/batch-leverage-info': 1,
                         'trade/orders-tpsl-pending': 1,
                         'trade/orders-history': 1,
                         'trade/orders-tpsl-history': 1,
@@ -491,7 +493,7 @@ class blofin(Exchange, ImplicitAPI):
         symbol = market['symbol']
         last = self.safe_string(ticker, 'last')
         open = self.safe_string(ticker, 'open24h')
-        spot = self.safe_value(market, 'spot', False)
+        spot = self.safe_bool(market, 'spot', False)
         quoteVolume = self.safe_string(ticker, 'volCurrency24h') if spot else None
         baseVolume = self.safe_string(ticker, 'vol24h')
         high = self.safe_string(ticker, 'high24h')
@@ -1757,10 +1759,58 @@ class blofin(Exchange, ImplicitAPI):
             'takeProfitPrice': None,
         })
 
+    async def fetch_leverages(self, symbols: List[str] = None, params={}) -> Leverages:
+        """
+        fetch the set leverage for all contract markets
+        :see: https://docs.blofin.com/index.html#get-multiple-leverage
+        :param str[] symbols: a list of unified market symbols, required on blofin
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.marginMode]: 'cross' or 'isolated'
+        :returns dict: a list of `leverage structures <https://docs.ccxt.com/#/?id=leverage-structure>`
+        """
+        await self.load_markets()
+        if symbols is None:
+            raise ArgumentsRequired(self.id + ' fetchLeverages() requires a symbols argument')
+        marginMode = None
+        marginMode, params = self.handle_margin_mode_and_params('fetchLeverages', params)
+        if marginMode is None:
+            marginMode = self.safe_string(params, 'marginMode', 'cross')  # cross marginMode
+        if (marginMode != 'cross') and (marginMode != 'isolated'):
+            raise BadRequest(self.id + ' fetchLeverages() requires a marginMode parameter that must be either cross or isolated')
+        symbols = self.market_symbols(symbols)
+        instIds = ''
+        for i in range(0, len(symbols)):
+            entry = symbols[i]
+            entryMarket = self.market(entry)
+            if i > 0:
+                instIds = instIds + ',' + entryMarket['id']
+            else:
+                instIds = instIds + entryMarket['id']
+        request = {
+            'instId': instIds,
+            'marginMode': marginMode,
+        }
+        response = await self.privateGetAccountBatchLeverageInfo(self.extend(request, params))
+        #
+        #     {
+        #         "code": "0",
+        #         "msg": "success",
+        #         "data": [
+        #             {
+        #                 "leverage": "3",
+        #                 "marginMode": "cross",
+        #                 "instId": "BTC-USDT"
+        #             },
+        #         ]
+        #     }
+        #
+        leverages = self.safe_list(response, 'data', [])
+        return self.parse_leverages(leverages, symbols, 'instId')
+
     async def fetch_leverage(self, symbol: str, params={}) -> Leverage:
         """
         fetch the set leverage for a market
-        :see: https://blofin.com/docs#set-leverage
+        :see: https://docs.blofin.com/index.html#get-leverage
         :param str symbol: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.marginMode]: 'cross' or 'isolated'

ccxt/async_support/coinbase.py

@@ -2909,10 +2909,12 @@ class coinbase(Exchange, ImplicitAPI):
         :returns int[][]: A list of candles ordered, open, high, low, close, volume
         """
         await self.load_markets()
+        maxLimit = 300
+        limit = maxLimit if (limit is None) else min(limit, maxLimit)
         paginate = False
         paginate, params = self.handle_option_and_params(params, 'fetchOHLCV', 'paginate', False)
         if paginate:
-            return await self.fetch_paginated_call_deterministic('fetchOHLCV', symbol, since, limit, timeframe, params, 299)
+            return await self.fetch_paginated_call_deterministic('fetchOHLCV', symbol, since, limit, timeframe, params, maxLimit - 1)
         market = self.market(symbol)
         request = {
             'product_id': market['id'],
@@ -2921,18 +2923,18 @@ class coinbase(Exchange, ImplicitAPI):
         until = self.safe_value_n(params, ['until', 'till', 'end'])
         params = self.omit(params, ['until', 'till'])
         duration = self.parse_timeframe(timeframe)
-        candles300 = 300 * duration
+        requestedDuration = limit * duration
         sinceString = None
         if since is not None:
             sinceString = self.number_to_string(self.parse_to_int(since / 1000))
         else:
             now = str(self.seconds())
-            sinceString = Precise.string_sub(now, str(candles300))
+            sinceString = Precise.string_sub(now, str(requestedDuration))
         request['start'] = sinceString
         endString = self.number_to_string(until)
         if until is None:
             # 300 candles max
-            endString = Precise.string_add(sinceString, str(candles300))
+            endString = Precise.string_add(sinceString, str(requestedDuration))
         request['end'] = endString
         response = await self.v3PrivateGetBrokerageProductsProductIdCandles(self.extend(request, params))
         #
@@ -2989,8 +2991,16 @@ class coinbase(Exchange, ImplicitAPI):
         request = {
             'product_id': market['id'],
         }
+        if since is not None:
+            request['start'] = self.number_to_string(self.parse_to_int(since / 1000))
         if limit is not None:
-            request['limit'] = limit
+            request['limit'] = min(limit, 1000)
+        until = None
+        until, params = self.handle_option_and_params(params, 'fetchTrades', 'until')
+        if until is not None:
+            request['end'] = self.number_to_string(self.parse_to_int(until / 1000))
+        elif since is not None:
+            raise ArgumentsRequired(self.id + ' fetchTrades() requires a `until` parameter when you use `since` argument')
         response = await self.v3PrivateGetBrokerageProductsProductIdTicker(self.extend(request, params))
         #
         #     {
@@ -3111,7 +3121,7 @@ class coinbase(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'pricebook', {})
+        data = self.safe_dict(response, 'pricebook', {})
         time = self.safe_string(data, 'time')
         timestamp = self.parse8601(time)
         return self.parse_order_book(data, symbol, timestamp, 'bids', 'asks', 'price', 'size')
@@ -3535,21 +3545,20 @@ class coinbase(Exchange, ImplicitAPI):
                         body = self.json(query)
             else:
                 self.check_required_credentials()
-                nonce = str(self.nonce())
+                timestampString = str(self.seconds())
                 payload = ''
                 if method != 'GET':
                     if query:
                         body = self.json(query)
                         payload = body
-                else:
-                    if query:
-                        payload += '?' + self.urlencode(query)
-                auth = nonce + method + savedPath + payload
+                # 'GET' doesn't need payload in the signature. inside url is enough
+                # https://docs.cloud.coinbase.com/advanced-trade-api/docs/auth#example-request
+                auth = timestampString + method + savedPath + payload
                 signature = self.hmac(self.encode(auth), self.encode(self.secret), hashlib.sha256)
                 headers = {
                     'CB-ACCESS-KEY': self.apiKey,
                     'CB-ACCESS-SIGN': signature,
-                    'CB-ACCESS-TIMESTAMP': nonce,
+                    'CB-ACCESS-TIMESTAMP': timestampString,
                     'Content-Type': 'application/json',
                 }
         return {'url': url, 'method': method, 'body': body, 'headers': headers}

ccxt/async_support/hitbtc.py

@@ -2508,7 +2508,7 @@ class hitbtc(Exchange, ImplicitAPI):
         if (network is not None) and (code == 'USDT'):
             parsedNetwork = self.safe_string(networks, network)
             if parsedNetwork is not None:
-                request['currency'] = parsedNetwork
+                request['network_code'] = parsedNetwork
             params = self.omit(params, 'network')
         withdrawOptions = self.safe_value(self.options, 'withdraw', {})
         includeFee = self.safe_bool(withdrawOptions, 'includeFee', False)

ccxt/async_support/htx.py

@@ -2507,7 +2507,9 @@ class htx(Exchange, ImplicitAPI):
         amountString = self.safe_string(trade, 'trade_volume', amountString)
         costString = self.safe_string(trade, 'trade_turnover')
         fee = None
-        feeCost = self.safe_string_2(trade, 'filled-fees', 'trade_fee')
+        feeCost = self.safe_string(trade, 'filled-fees')
+        if feeCost is None:
+            feeCost = Precise.string_neg(self.safe_string(trade, 'trade_fee'))
         feeCurrencyId = self.safe_string_2(trade, 'fee-currency', 'fee_asset')
         feeCurrency = self.safe_currency_code(feeCurrencyId)
         filledPoints = self.safe_string(trade, 'filled-points')

ccxt/async_support/kraken.py

@@ -39,7 +39,10 @@ class kraken(Exchange, ImplicitAPI):
             'name': 'Kraken',
             'countries': ['US'],
             'version': '0',
-            'rateLimit': 3000,  # bucket fills max 15, but drains 1 every 3s
+            # rate-limits: https://support.kraken.com/hc/en-us/articles/206548367-What-are-the-API-rate-limits-#1
+            # for public: 1 req/s
+            # for private: every second 0.33 weight added to your allowed capacity(some private endpoints need 1 weight, some need 2)
+            'rateLimit': 1000,
             'certified': False,
             'pro': True,
             'has': {
@@ -169,7 +172,7 @@ class kraken(Exchange, ImplicitAPI):
                 },
                 'public': {
                     'get': {
-                        # public endpoint rate-limits are described in article: https://support.kraken.com/hc/en-us/articles/206548367-What-are-the-API-rate-limits-#1
+                        # rate-limits explained in comment in the top of self file
                         'Assets': 1,
                         'AssetPairs': 1,
                         'Depth': 1,
@@ -185,48 +188,48 @@ class kraken(Exchange, ImplicitAPI):
                     'post': {
                         'AddOrder': 0,
                         'AddOrderBatch': 0,
-                        'AddExport': 1,
-                        'Balance': 1,
-                        'CancelAll': 1,
-                        'CancelAllOrdersAfter': 1,
+                        'AddExport': 3,
+                        'Balance': 3,
+                        'CancelAll': 3,
+                        'CancelAllOrdersAfter': 3,
                         'CancelOrder': 0,
                         'CancelOrderBatch': 0,
-                        'ClosedOrders': 1,
-                        'DepositAddresses': 1,
-                        'DepositMethods': 1,
-                        'DepositStatus': 1,
+                        'ClosedOrders': 3,
+                        'DepositAddresses': 3,
+                        'DepositMethods': 3,
+                        'DepositStatus': 3,
                         'EditOrder': 0,
-                        'ExportStatus': 1,
-                        'GetWebSocketsToken': 1,
-                        'Ledgers': 2,
-                        'OpenOrders': 1,
-                        'OpenPositions': 1,
-                        'QueryLedgers': 1,
-                        'QueryOrders': 1,
-                        'QueryTrades': 1,
-                        'RetrieveExport': 1,
-                        'RemoveExport': 1,
-                        'BalanceEx': 1,
-                        'TradeBalance': 1,
-                        'TradesHistory': 2,
-                        'TradeVolume': 1,
-                        'Withdraw': 1,
-                        'WithdrawCancel': 1,
-                        'WithdrawInfo': 1,
-                        'WithdrawMethods': 1,
-                        'WithdrawAddresses': 1,
-                        'WithdrawStatus': 1,
-                        'WalletTransfer': 1,
+                        'ExportStatus': 3,
+                        'GetWebSocketsToken': 3,
+                        'Ledgers': 6,
+                        'OpenOrders': 3,
+                        'OpenPositions': 3,
+                        'QueryLedgers': 3,
+                        'QueryOrders': 3,
+                        'QueryTrades': 3,
+                        'RetrieveExport': 3,
+                        'RemoveExport': 3,
+                        'BalanceEx': 3,
+                        'TradeBalance': 3,
+                        'TradesHistory': 6,
+                        'TradeVolume': 3,
+                        'Withdraw': 3,
+                        'WithdrawCancel': 3,
+                        'WithdrawInfo': 3,
+                        'WithdrawMethods': 3,
+                        'WithdrawAddresses': 3,
+                        'WithdrawStatus': 3,
+                        'WalletTransfer': 3,
                         # sub accounts
-                        'CreateSubaccount': 1,
-                        'AccountTransfer': 1,
+                        'CreateSubaccount': 3,
+                        'AccountTransfer': 3,
                         # earn
-                        'Earn/Allocate': 1,
-                        'Earn/Deallocate': 1,
-                        'Earn/AllocateStatus': 1,
-                        'Earn/DeallocateStatus': 1,
-                        'Earn/Strategies': 1,
-                        'Earn/Allocations': 1,
+                        'Earn/Allocate': 3,
+                        'Earn/Deallocate': 3,
+                        'Earn/AllocateStatus': 3,
+                        'Earn/DeallocateStatus': 3,
+                        'Earn/Strategies': 3,
+                        'Earn/Allocations': 3,
                     },
                 },
             },

ccxt/async_support/kucoinfutures.py

@@ -46,6 +46,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
                 'addMargin': True,
                 'cancelAllOrders': True,
                 'cancelOrder': True,
+                'closeAllPositions': False,
                 'closePosition': True,
                 'closePositions': False,
                 'createDepositAddress': True,

ccxt/async_support/lbank.py

@@ -2530,7 +2530,7 @@ class lbank(Exchange, ImplicitAPI):
             uppercaseHash = hash.upper()
             sign = None
             if signatureMethod == 'RSA':
-                cacheSecretAsPem = self.safe_value(self.options, 'cacheSecretAsPem', True)
+                cacheSecretAsPem = self.safe_bool(self.options, 'cacheSecretAsPem', True)
                 pem = None
                 if cacheSecretAsPem:
                     pem = self.safe_value(self.options, 'pem')

ccxt/async_support/mexc.py

@@ -5148,7 +5148,7 @@ class mexc(Exchange, ImplicitAPI):
                     'X-MEXC-APIKEY': self.apiKey,
                     'source': self.safe_string(self.options, 'broker', 'CCXT'),
                 }
-            if (method == 'POST') or (method == 'PUT'):
+            if (method == 'POST') or (method == 'PUT') or (method == 'DELETE'):
                 headers['Content-Type'] = 'application/json'
         elif section == 'contract' or section == 'spot2':
             url = self.urls['api'][section][access] + '/' + self.implode_params(path, params)

ccxt/async_support/okx.py

@@ -1550,7 +1550,7 @@ class okx(Exchange, ImplicitAPI):
         # while fetchCurrencies is a public API method by design
         # therefore we check the keys here
         # and fallback to generating the currencies from the markets
-        isSandboxMode = self.safe_value(self.options, 'sandboxMode', False)
+        isSandboxMode = self.safe_bool(self.options, 'sandboxMode', False)
         if not self.check_required_credentials(False) or isSandboxMode:
             return None
         #

ccxt/async_support/phemex.py

@@ -2337,7 +2337,7 @@ class phemex(Exchange, ImplicitAPI):
 
     def parse_order(self, order, market: Market = None) -> Order:
         isSwap = self.safe_bool(market, 'swap', False)
-        hasPnl = ('closedPnl' in order)
+        hasPnl = ('closedPnl' in order) or ('closedPnlRv' in order) or ('totalPnlRv' in order)
         if isSwap or hasPnl:
             return self.parse_swap_order(order, market)
         return self.parse_spot_order(order, market)

ccxt/async_support/wazirx.py

@@ -121,7 +121,7 @@ class wazirx(Exchange, ImplicitAPI):
                 'public': {
                     'get': {
                         'exchangeInfo': 1,
-                        'depth': 1,
+                        'depth': 0.5,
                         'ping': 1,
                         'systemStatus': 1,
                         'tickers/24hr': 1,
@@ -140,6 +140,11 @@ class wazirx(Exchange, ImplicitAPI):
                         'openOrders': 1,
                         'order': 0.5,
                         'myTrades': 0.5,
+                        'coins': 12,
+                        'crypto/withdraws': 12,
+                        'crypto/deposits/address': 60,
+                        'sub_account/fund_transfer/history': 1,
+                        'sub_account/accounts': 1,
                     },
                     'post': {
                         'order': 0.1,