ccxt 3.1.52__py2.py3-none-any.whl → 3.1.54__py2.py3-none-any.whl

ccxt/async_support/bybit.py

@@ -369,6 +369,7 @@ class bybit(Exchange, ImplicitAPI):
                         'user/v3/private/frozen-sub-member': 10,  # 5/s
                         'user/v3/private/query-sub-members': 5,  # 10/s
                         'user/v3/private/query-api': 5,  # 10/s
+                        'user/v3/private/get-member-type': 1,
                         'asset/v3/private/transfer/transfer-coin/list/query': 0.84,  # 60/s
                         'asset/v3/private/transfer/account-coin/balance/query': 0.84,  # 60/s
                         'asset/v3/private/transfer/account-coins/balance/query': 50,

ccxt/async_support/cryptocom.py

@@ -79,6 +79,7 @@ class cryptocom(Exchange, ImplicitAPI):
                 'fetchOrders': True,
                 'fetchPositionMode': False,
                 'fetchPositions': False,
+                'fetchSettlementHistory': True,
                 'fetchStatus': False,
                 'fetchTicker': True,
                 'fetchTickers': True,
@@ -2476,6 +2477,88 @@ class cryptocom(Exchange, ImplicitAPI):
             'info': account,
         }
 
+    async def fetch_settlement_history(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
+        """
+        fetches historical settlement records
+        see https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#public-get-expired-settlement-price
+        :param str symbol: unified market symbol of the settlement history
+        :param int|None since: timestamp in ms
+        :param int|None limit: number of records
+        :param dict params: exchange specific params
+        :param int|None params['type']: 'future', 'option'
+        :returns [dict]: a list of [settlement history objects]
+        """
+        await self.load_markets()
+        market = None
+        if symbol is not None:
+            market = self.market(symbol)
+        type = None
+        type, params = self.handle_market_type_and_params('fetchSettlementHistory', market, params)
+        self.check_required_argument('fetchSettlementHistory', type, 'type', ['future', 'option', 'WARRANT', 'FUTURE'])
+        if type == 'option':
+            type = 'WARRANT'
+        request = {
+            'instrument_type': type.upper(),
+        }
+        response = await self.v1PublicGetPublicGetExpiredSettlementPrice(self.extend(request, params))
+        #
+        #     {
+        #         "id": -1,
+        #         "method": "public/get-expired-settlement-price",
+        #         "code": 0,
+        #         "result": {
+        #             "data": [
+        #                 {
+        #                     "i": "BTCUSD-230526",
+        #                     "x": 1685088000000,
+        #                     "v": "26464.1",
+        #                     "t": 1685087999500
+        #                 }
+        #             ]
+        #         }
+        #     }
+        #
+        result = self.safe_value(response, 'result', {})
+        data = self.safe_value(result, 'data', [])
+        settlements = self.parse_settlements(data, market)
+        sorted = self.sort_by(settlements, 'timestamp')
+        return self.filter_by_symbol_since_limit(sorted, symbol, since, limit)
+
+    def parse_settlement(self, settlement, market):
+        #
+        #     {
+        #         "i": "BTCUSD-230526",
+        #         "x": 1685088000000,
+        #         "v": "26464.1",
+        #         "t": 1685087999500
+        #     }
+        #
+        timestamp = self.safe_integer(settlement, 'x')
+        marketId = self.safe_string(settlement, 'i')
+        return {
+            'info': settlement,
+            'symbol': self.safe_symbol(marketId, market),
+            'price': self.safe_number(settlement, 'v'),
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+        }
+
+    def parse_settlements(self, settlements, market):
+        #
+        #     [
+        #         {
+        #             "i": "BTCUSD-230526",
+        #             "x": 1685088000000,
+        #             "v": "26464.1",
+        #             "t": 1685087999500
+        #         }
+        #     ]
+        #
+        result = []
+        for i in range(0, len(settlements)):
+            result.append(self.parse_settlement(settlements[i], market))
+        return result
+
     def nonce(self):
         return self.milliseconds()
 

ccxt/async_support/deribit.py

@@ -559,6 +559,7 @@ class deribit(Exchange, ImplicitAPI):
         #         testnet: False
         #     }
         #
+        parsedMarkets = {}
         currenciesResult = self.safe_value(currenciesResponse, 'result', [])
         result = []
         for i in range(0, len(currenciesResult)):
@@ -679,6 +680,10 @@ class deribit(Exchange, ImplicitAPI):
                             optionType = self.safe_string(market, 'option_type')
                             letter = 'C' if (optionType == 'call') else 'P'
                             symbol = symbol + '-' + self.number_to_string(strike) + '-' + letter
+                parsedMarketValue = self.safe_value(parsedMarkets, symbol)
+                if parsedMarketValue:
+                    continue
+                parsedMarkets[symbol] = True
                 minTradeAmount = self.safe_number(market, 'min_trade_amount')
                 tickSize = self.safe_number(market, 'tick_size')
                 result.append({

ccxt/async_support/kucoin.py

@@ -77,7 +77,7 @@ class kucoin(Exchange, ImplicitAPI):
                 'fetchDepositAddressesByNetwork': True,
                 'fetchDeposits': True,
                 'fetchDepositWithdrawFee': True,
-                'fetchDepositWithdrawFees': False,
+                'fetchDepositWithdrawFees': True,
                 'fetchFundingHistory': False,
                 'fetchFundingRate': False,
                 'fetchFundingRateHistory': False,
@@ -752,6 +752,7 @@ class kucoin(Exchange, ImplicitAPI):
     async def fetch_currencies(self, params={}):
         """
         fetches all available currencies on an exchange
+        see https://docs.kucoin.com/#get-currencies
         :param dict params: extra parameters specific to the kucoin api endpoint
         :returns dict: an associative dictionary of currencies
         """
@@ -930,22 +931,33 @@ class kucoin(Exchange, ImplicitAPI):
         #        "chain": "ERC20"
         #    }
         #
-        result = self.deposit_withdraw_fee(fee)
+        result = {
+            'info': fee,
+            'withdraw': {
+                'fee': None,
+                'percentage': None,
+            },
+            'deposit': {
+                'fee': None,
+                'percentage': None,
+            },
+            'networks': {},
+        }
         isWithdrawEnabled = self.safe_value(fee, 'isWithdrawEnabled')
         if isWithdrawEnabled:
+            result['withdraw']['fee'] = self.safe_number(fee, 'withdrawalMinFee')
+            result['withdraw']['percentage'] = False
             networkId = self.safe_string(fee, 'chain')
-            networkCode = self.network_id_to_code(networkId, self.safe_string(currency, 'code'))
-            result['networks'][networkCode] = {
-                'withdraw': {
-                    'fee': self.safe_number(fee, 'withdrawMinFee'),
-                    'percentage': None,
-                },
-                'deposit': {
-                    'fee': None,
-                    'percentage': None,
-                },
-            }
-        return self.assign_default_deposit_withdraw_fees(result)
+            if networkId:
+                networkCode = self.network_id_to_code(networkId, self.safe_string(currency, 'code'))
+                result['networks'][networkCode] = {
+                    'withdraw': result['withdraw'],
+                    'deposit': {
+                        'fee': None,
+                        'percentage': None,
+                    },
+                }
+        return result
 
     def is_futures_method(self, methodName, params):
         #
@@ -3497,6 +3509,37 @@ class kucoin(Exchange, ImplicitAPI):
             'info': info,
         }
 
+    async def fetch_deposit_withdraw_fees(self, codes: Optional[List[str]] = None, params={}):
+        """
+        fetch deposit and withdraw fees - *IMPORTANT* use fetchDepositWithdrawFee to get more in-depth info
+        see https://docs.kucoin.com/#get-currencies
+        :param [str]|None codes: list of unified currency codes
+        :param dict params: extra parameters specific to the kucoin api endpoint
+        :returns dict: a list of `fee structures <https://docs.ccxt.com/en/latest/manual.html#fee-structure>`
+        """
+        await self.load_markets()
+        response = await self.publicGetCurrencies(params)
+        #
+        #  [
+        #      {
+        #        "currency": "CSP",
+        #        "name": "CSP",
+        #        "fullName": "Caspian",
+        #        "precision": 8,
+        #        "confirms": 12,
+        #        "contractAddress": "0xa6446d655a0c34bc4f05042ee88170d056cbaf45",
+        #        "withdrawalMinSize": "2000",
+        #        "withdrawalMinFee": "1000",
+        #        "isWithdrawEnabled": True,
+        #        "isDepositEnabled": True,
+        #        "isMarginEnabled": False,
+        #        "isDebitEnabled": False
+        #      },
+        #  ]
+        #
+        data = self.safe_value(response, 'data', [])
+        return self.parse_deposit_withdraw_fees(data, codes, 'currency')
+
     def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
         #
         # the v2 URL is https://openapi-v2.kucoin.com/api/v1/endpoint

ccxt/async_support/luno.py

@@ -727,7 +727,7 @@ class luno(Exchange, ImplicitAPI):
         await self.load_markets()
         market = self.market(symbol)
         request = {
-            'symbol': market['id'],
+            'pair': market['id'],
         }
         response = await self.privateGetFeeInfo(self.extend(request, params))
         #

ccxt/async_support/okx.py

@@ -188,6 +188,7 @@ class okx(Exchange, ImplicitAPI):
                         'market/index-candles': 1,
                         'market/mark-price-candles': 1,
                         'market/trades': 1,
+                        'market/history-trades': 2,
                         'market/platform-24-volume': 10,
                         'market/open-oracle': 40,
                         'market/index-components': 1,

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '3.1.52'
+__version__ = '3.1.54'
 
 # -----------------------------------------------------------------------------
 
@@ -1728,8 +1728,6 @@ class Exchange(object):
             val = val + 1
         if val > 1:
             raise ExchangeError(self.id + ' you have multiple conflicting proxy settings, please use only one from : proxyUrl, httpProxy, httpsProxy, socksProxy, userAgent')
-        if (val == 1) and (self.proxy is not None):
-            raise ExchangeError(self.id + ' you have multiple conflicting proxy settings, instead of deprecated .proxy please use from: proxyUrl, httpProxy, httpsProxy, socksProxy')
         return [proxyUrl, httpProxy, httpsProxy, socksProxy]
 
     def find_message_hashes(self, client, element: str):
@@ -2498,8 +2496,8 @@ class Exchange(object):
         percentage = self.safe_value(ticker, 'percentage')
         average = self.safe_value(ticker, 'average')
         vwap = self.safe_value(ticker, 'vwap')
-        baseVolume = self.safe_value(ticker, 'baseVolume')
-        quoteVolume = self.safe_value(ticker, 'quoteVolume')
+        baseVolume = self.safe_string(ticker, 'baseVolume')
+        quoteVolume = self.safe_string(ticker, 'quoteVolume')
         if vwap is None:
             vwap = Precise.string_div(quoteVolume, baseVolume)
         if (last is not None) and (close is None):