ccxt 4.2.64__py2.py3-none-any.whl → 4.2.65__py2.py3-none-any.whl

ccxt/kucoin.py

@@ -135,6 +135,7 @@ class kucoin(Exchange, ImplicitAPI):
                     'futuresPrivate': 'https://api-futures.kucoin.com',
                     'futuresPublic': 'https://api-futures.kucoin.com',
                     'webExchange': 'https://kucoin.com/_api',
+                    'broker': 'https://api-broker.kucoin.com',
                 },
                 'www': 'https://www.kucoin.com',
                 'doc': [
@@ -248,6 +249,7 @@ class kucoin(Exchange, ImplicitAPI):
                         'project/marketInterestRate': 7.5,  # 5PW
                         'redeem/orders': 10,  # 10SW
                         'purchase/orders': 10,  # 10SW
+                        # broker
                         'broker/api/rebase/download': 3,
                     },
                     'post': {
@@ -394,6 +396,23 @@ class kucoin(Exchange, ImplicitAPI):
                         'currency/currency/chain-info': 1,  # self is temporary from webApi
                     },
                 },
+                'broker': {
+                    'get': {
+                        'broker/nd/info': 2,
+                        'broker/nd/account': 2,
+                        'broker/nd/account/apikey': 2,
+                        'broker/nd/rebase/download': 3,
+                    },
+                    'post': {
+                        'broker/nd/transfer': 1,
+                        'broker/nd/account': 3,
+                        'broker/nd/account/apikey': 3,
+                        'broker/nd/account/update-apikey': 3,
+                    },
+                    'delete': {
+                        'broker/nd/account/apikey': 3,
+                    },
+                },
             },
             'timeframes': {
                 '1m': '1min',
@@ -907,7 +926,7 @@ class kucoin(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         status = self.safe_string(data, 'status')
         return {
             'status': 'ok' if (status == 'open') else 'maintenance',
@@ -951,8 +970,8 @@ class kucoin(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        data = self.safe_value(response, 'data')
-        options = self.safe_value(self.options, 'fetchMarkets', {})
+        data = self.safe_list(response, 'data')
+        options = self.safe_dict(self.options, 'fetchMarkets', {})
         fetchTickersFees = self.safe_bool(options, 'fetchTickersFees', True)
         tickersResponse = {}
         if fetchTickersFees:
@@ -985,8 +1004,8 @@ class kucoin(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        tickersData = self.safe_value(tickersResponse, 'data', {})
-        tickers = self.safe_value(tickersData, 'ticker', [])
+        tickersData = self.safe_dict(tickersResponse, 'data', {})
+        tickers = self.safe_list(tickersData, 'ticker', [])
         tickersByMarketId = self.index_by(tickers, 'symbol')
         result = []
         for i in range(0, len(data)):
@@ -996,7 +1015,7 @@ class kucoin(Exchange, ImplicitAPI):
             base = self.safe_currency_code(baseId)
             quote = self.safe_currency_code(quoteId)
             # quoteIncrement = self.safe_number(market, 'quoteIncrement')
-            ticker = self.safe_value(tickersByMarketId, id, {})
+            ticker = self.safe_dict(tickersByMarketId, id, {})
             makerFeeRate = self.safe_string(ticker, 'makerFeeRate')
             takerFeeRate = self.safe_string(ticker, 'takerFeeRate')
             makerCoefficient = self.safe_string(ticker, 'makerCoefficient')
@@ -1012,11 +1031,11 @@ class kucoin(Exchange, ImplicitAPI):
                 'settleId': None,
                 'type': 'spot',
                 'spot': True,
-                'margin': self.safe_value(market, 'isMarginEnabled'),
+                'margin': self.safe_bool(market, 'isMarginEnabled'),
                 'swap': False,
                 'future': False,
                 'option': False,
-                'active': self.safe_value(market, 'enableTrading'),
+                'active': self.safe_bool(market, 'enableTrading'),
                 'contract': False,
                 'linear': None,
                 'inverse': None,
@@ -1143,7 +1162,7 @@ class kucoin(Exchange, ImplicitAPI):
             isWithdrawEnabled = None
             isDepositEnabled = None
             networks = {}
-            chains = self.safe_value(entry, 'chains', [])
+            chains = self.safe_list(entry, 'chains', [])
             extraChainsData = self.index_by(self.safe_value(additionalDataGrouped, id, []), 'chain')
             rawPrecision = self.safe_string(entry, 'precision')
             precision = self.parse_number(self.parse_precision(rawPrecision))
@@ -1166,7 +1185,7 @@ class kucoin(Exchange, ImplicitAPI):
                     isDepositEnabled = chainDepositEnabled
                 else:
                     isDepositEnabled = isDepositEnabled or chainDepositEnabled
-                chainExtraData = self.safe_value(extraChainsData, chainId, {})
+                chainExtraData = self.safe_dict(extraChainsData, chainId, {})
                 networks[networkCode] = {
                     'info': chain,
                     'id': chainId,
@@ -1237,7 +1256,7 @@ class kucoin(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        data = self.safe_value(response, 'data', [])
+        data = self.safe_list(response, 'data', [])
         result = []
         for i in range(0, len(data)):
             account = data[i]
@@ -1318,7 +1337,7 @@ class kucoin(Exchange, ImplicitAPI):
         #        }
         #    }
         #
-        data = self.safe_value(response, 'data')
+        data = self.safe_dict(response, 'data')
         return self.parse_deposit_withdraw_fee(data, currency)
 
     def parse_deposit_withdraw_fee(self, fee, currency: Currency = None):
@@ -1349,7 +1368,7 @@ class kucoin(Exchange, ImplicitAPI):
             },
             'networks': {},
         }
-        isWithdrawEnabled = self.safe_value(fee, 'isWithdrawEnabled')
+        isWithdrawEnabled = self.safe_bool(fee, 'isWithdrawEnabled')
         if isWithdrawEnabled:
             result['withdraw']['fee'] = self.safe_number_2(fee, 'withdrawalMinFee', 'withdrawMinFee')
             result['withdraw']['percentage'] = False
@@ -1374,7 +1393,7 @@ class kucoin(Exchange, ImplicitAPI):
         #
         defaultType = self.safe_string_2(self.options, methodName, 'defaultType', 'trade')
         requestedType = self.safe_string(params, 'type', defaultType)
-        accountsByType = self.safe_value(self.options, 'accountsByType')
+        accountsByType = self.safe_dict(self.options, 'accountsByType')
         type = self.safe_string(accountsByType, requestedType)
         if type is None:
             keys = list(accountsByType.keys())
@@ -1511,8 +1530,8 @@ class kucoin(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
-        tickers = self.safe_value(data, 'ticker', [])
+        data = self.safe_dict(response, 'data', {})
+        tickers = self.safe_list(data, 'ticker', [])
         time = self.safe_integer(data, 'time')
         result = {}
         for i in range(0, len(tickers)):
@@ -1632,7 +1651,7 @@ class kucoin(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        data = self.safe_value(response, 'data', [])
+        data = self.safe_list(response, 'data', [])
         return self.parse_ohlcvs(data, market, timeframe, since, limit)
 
     def create_deposit_address(self, code: str, params={}):
@@ -1657,7 +1676,7 @@ class kucoin(Exchange, ImplicitAPI):
         # {"code":"260000","msg":"Deposit address already exists."}
         # BCH {"code":"200000","data":{"address":"bitcoincash:qza3m4nj9rx7l9r0cdadfqxts6f92shvhvr5ls4q7z","memo":""}}
         # BTC {"code":"200000","data":{"address":"36SjucKqQpQSvsak9A7h6qzFjrVXpRNZhE","memo":""}}
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         return self.parse_deposit_address(data, currency)
 
     def fetch_deposit_address(self, code: str, params={}):
@@ -1743,7 +1762,7 @@ class kucoin(Exchange, ImplicitAPI):
         #     }
         #
         self.options['versions']['private']['GET']['deposit-addresses'] = version
-        chains = self.safe_value(response, 'data', [])
+        chains = self.safe_list(response, 'data', [])
         parsed = self.parse_deposit_addresses(chains, [currency['code']], False, {
             'currency': currency['id'],
         })
@@ -1808,7 +1827,7 @@ class kucoin(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         timestamp = self.safe_integer(data, 'time')
         orderbook = self.parse_order_book(data, market['symbol'], timestamp, 'bids', 'asks', level - 2, level - 1)
         orderbook['nonce'] = self.safe_integer(data, 'sequence')
@@ -1900,7 +1919,7 @@ class kucoin(Exchange, ImplicitAPI):
         #         }
         #    }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         return self.parse_order(data, market)
 
     def create_market_order_with_cost(self, symbol: str, side: OrderSide, cost: float, params={}):
@@ -2013,8 +2032,8 @@ class kucoin(Exchange, ImplicitAPI):
         #           },
         # }
         #
-        data = self.safe_value(response, 'data', {})
-        data = self.safe_value(data, 'data', [])
+        data = self.safe_dict(response, 'data', {})
+        data = self.safe_list(data, 'data', [])
         return self.parse_orders(data)
 
     def create_order_request(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: float = None, params={}):
@@ -2111,7 +2130,7 @@ class kucoin(Exchange, ImplicitAPI):
         #     }
         # }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         return self.parse_order(data, market)
 
     def cancel_order(self, id: str, symbol: Str = None, params={}):
@@ -2133,7 +2152,7 @@ class kucoin(Exchange, ImplicitAPI):
         self.load_markets()
         request = {}
         clientOrderId = self.safe_string_2(params, 'clientOid', 'clientOrderId')
-        stop = self.safe_value_2(params, 'stop', 'trigger', False)
+        stop = self.safe_bool_2(params, 'stop', 'trigger', False)
         hf = self.safe_bool(params, 'hf', False)
         if hf:
             if symbol is None:
@@ -2300,7 +2319,7 @@ class kucoin(Exchange, ImplicitAPI):
         #             ]
         #         }
         #    }
-        responseData = self.safe_value(response, 'data', {})
+        responseData = self.safe_dict(response, 'data', {})
         orders = self.safe_value(responseData, 'items', responseData)
         return self.parse_orders(orders, market, since, limit)
 
@@ -2415,7 +2434,7 @@ class kucoin(Exchange, ImplicitAPI):
                 response = self.privateGetHfOrdersOrderId(self.extend(request, params))
             else:
                 response = self.privateGetOrdersOrderId(self.extend(request, params))
-        responseData = self.safe_value(response, 'data', {})
+        responseData = self.safe_dict(response, 'data', {})
         if isinstance(responseData, list):
             responseData = self.safe_value(responseData, 0)
         return self.parse_order(responseData, market)
@@ -2549,7 +2568,7 @@ class kucoin(Exchange, ImplicitAPI):
         responseStop = self.safe_string(order, 'stop')
         stop = responseStop is not None
         stopTriggered = self.safe_bool(order, 'stopTriggered', False)
-        isActive = self.safe_value_2(order, 'isActive', 'active')
+        isActive = self.safe_bool_2(order, 'isActive', 'active')
         responseStatus = self.safe_string(order, 'status')
         status = None
         if isActive is not None:
@@ -2574,7 +2593,7 @@ class kucoin(Exchange, ImplicitAPI):
             'symbol': self.safe_symbol(marketId, market, '-'),
             'type': self.safe_string(order, 'type'),
             'timeInForce': self.safe_string(order, 'timeInForce'),
-            'postOnly': self.safe_value(order, 'postOnly'),
+            'postOnly': self.safe_bool(order, 'postOnly'),
             'side': self.safe_string(order, 'side'),
             'amount': self.safe_string(order, 'size'),
             'price': self.safe_string(order, 'price'),  # price is zero for market order, omitZero is called in safeOrder2
@@ -2701,12 +2720,12 @@ class kucoin(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         trades = None
         if parseResponseData:
             trades = data
         else:
-            trades = self.safe_value(data, 'items', [])
+            trades = self.safe_list(data, 'items', [])
         return self.parse_trades(trades, market, since, limit)
 
     def fetch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
@@ -2746,7 +2765,7 @@ class kucoin(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        trades = self.safe_value(response, 'data', [])
+        trades = self.safe_list(response, 'data', [])
         return self.parse_trades(trades, market, since, limit)
 
     def parse_trade(self, trade, market: Market = None) -> Trade:
@@ -2900,8 +2919,8 @@ class kucoin(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        data = self.safe_value(response, 'data', [])
-        first = self.safe_value(data, 0)
+        data = self.safe_list(response, 'data', [])
+        first = self.safe_dict(data, 0)
         marketId = self.safe_string(first, 'symbol')
         return {
             'info': response,
@@ -2957,7 +2976,7 @@ class kucoin(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         return self.parse_transaction(data, currency)
 
     def parse_transaction_status(self, status):
@@ -3048,7 +3067,7 @@ class kucoin(Exchange, ImplicitAPI):
                 timestamp = timestamp * 1000
             if updated is not None:
                 updated = updated * 1000
-        internal = self.safe_value(transaction, 'isInner')
+        internal = self.safe_bool(transaction, 'isInner')
         tag = self.safe_string(transaction, 'memo')
         return {
             'info': transaction,
@@ -3255,7 +3274,7 @@ class kucoin(Exchange, ImplicitAPI):
             currency = self.currency(code)
         defaultType = self.safe_string_2(self.options, 'fetchBalance', 'defaultType', 'spot')
         requestedType = self.safe_string(params, 'type', defaultType)
-        accountsByType = self.safe_value(self.options, 'accountsByType')
+        accountsByType = self.safe_dict(self.options, 'accountsByType')
         type = self.safe_string(accountsByType, requestedType, requestedType)
         params = self.omit(params, 'type')
         isHf = self.safe_bool(params, 'hf', False)
@@ -3331,7 +3350,7 @@ class kucoin(Exchange, ImplicitAPI):
         #        }
         #    }
         #
-        data = self.safe_value(response, 'data', [])
+        data = self.safe_list(response, 'data', [])
         result = {
             'info': response,
             'timestamp': None,
@@ -3343,8 +3362,8 @@ class kucoin(Exchange, ImplicitAPI):
                 entry = assets[i]
                 marketId = self.safe_string(entry, 'symbol')
                 symbol = self.safe_symbol(marketId, None, '_')
-                base = self.safe_value(entry, 'baseAsset', {})
-                quote = self.safe_value(entry, 'quoteAsset', {})
+                base = self.safe_dict(entry, 'baseAsset', {})
+                quote = self.safe_dict(entry, 'quoteAsset', {})
                 baseCode = self.safe_currency_code(self.safe_string(base, 'currency'))
                 quoteCode = self.safe_currency_code(self.safe_string(quote, 'currency'))
                 subResult = {}
@@ -3352,7 +3371,7 @@ class kucoin(Exchange, ImplicitAPI):
                 subResult[quoteCode] = self.parse_balance_helper(quote)
                 result[symbol] = self.safe_balance(subResult)
         elif cross:
-            accounts = self.safe_value(data, 'accounts', [])
+            accounts = self.safe_list(data, 'accounts', [])
             for i in range(0, len(accounts)):
                 balance = accounts[i]
                 currencyId = self.safe_string(balance, 'currency')
@@ -3428,7 +3447,7 @@ class kucoin(Exchange, ImplicitAPI):
             #         }
             #     }
             #
-            data = self.safe_value(response, 'data')
+            data = self.safe_dict(response, 'data')
             return self.parse_transfer(data, currency)
         else:
             request = {
@@ -3455,7 +3474,7 @@ class kucoin(Exchange, ImplicitAPI):
             #         }
             #     }
             #
-            data = self.safe_value(response, 'data')
+            data = self.safe_dict(response, 'data')
             return self.parse_transfer(data, currency)
 
     def parse_transfer(self, transfer, currency: Currency = None):
@@ -3498,7 +3517,7 @@ class kucoin(Exchange, ImplicitAPI):
         rawStatus = self.safe_string(transfer, 'status')
         accountFromRaw = self.safe_string_lower(transfer, 'payAccountType')
         accountToRaw = self.safe_string_lower(transfer, 'recAccountType')
-        accountsByType = self.safe_value(self.options, 'accountsByType')
+        accountsByType = self.safe_dict(self.options, 'accountsByType')
         accountFrom = self.safe_string(accountsByType, accountFromRaw, accountFromRaw)
         accountTo = self.safe_string(accountsByType, accountToRaw, accountToRaw)
         return {
@@ -3660,7 +3679,7 @@ class kucoin(Exchange, ImplicitAPI):
         self.load_accounts()
         paginate = False
         paginate, params = self.handle_option_and_params(params, 'fetchLedger', 'paginate')
-        isHf = self.safe_value(params, 'hf')
+        isHf = self.safe_bool(params, 'hf')
         params = self.omit(params, 'hf')
         if paginate:
             return self.fetch_paginated_call_dynamic('fetchLedger', code, since, limit, params)
@@ -3734,9 +3753,9 @@ class kucoin(Exchange, ImplicitAPI):
         return self.parse_ledger(items, currency, since, limit)
 
     def calculate_rate_limiter_cost(self, api, method, path, params, config={}):
-        versions = self.safe_value(self.options, 'versions', {})
-        apiVersions = self.safe_value(versions, api, {})
-        methodVersions = self.safe_value(apiVersions, method, {})
+        versions = self.safe_dict(self.options, 'versions', {})
+        apiVersions = self.safe_dict(versions, api, {})
+        methodVersions = self.safe_dict(apiVersions, method, {})
         defaultVersion = self.safe_string(methodVersions, path, self.options['version'])
         version = self.safe_string(params, 'version', defaultVersion)
         if version == 'v3' and ('v3' in config):
@@ -3870,8 +3889,8 @@ class kucoin(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
-        assets = self.safe_value(data, 'assets', []) if (marginMode == 'isolated') else self.safe_value(data, 'accounts', [])
+        data = self.safe_dict(response, 'data', {})
+        assets = self.safe_list(data, 'assets', []) if (marginMode == 'isolated') else self.safe_list(data, 'accounts', [])
         return self.parse_borrow_interests(assets, None)
 
     def parse_borrow_interest(self, info, market: Market = None):
@@ -3924,7 +3943,7 @@ class kucoin(Exchange, ImplicitAPI):
         market = self.safe_market(marketId, market)
         symbol = self.safe_string(market, 'symbol')
         timestamp = self.safe_integer(info, 'createdAt')
-        isolatedBase = self.safe_value(info, 'baseAsset', {})
+        isolatedBase = self.safe_dict(info, 'baseAsset', {})
         amountBorrowed = None
         interest = None
         currencyId = None
@@ -3978,7 +3997,7 @@ class kucoin(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         return self.parse_margin_loan(data, currency)
 
     def borrow_isolated_margin(self, symbol: str, code: str, amount: float, params={}):
@@ -4015,7 +4034,7 @@ class kucoin(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         return self.parse_margin_loan(data, currency)
 
     def repay_cross_margin(self, code: str, amount, params={}):
@@ -4046,7 +4065,7 @@ class kucoin(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         return self.parse_margin_loan(data, currency)
 
     def repay_isolated_margin(self, symbol: str, code: str, amount, params={}):
@@ -4081,7 +4100,7 @@ class kucoin(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         return self.parse_margin_loan(data, currency)
 
     def parse_margin_loan(self, info, currency: Currency = None):
@@ -4131,7 +4150,7 @@ class kucoin(Exchange, ImplicitAPI):
         #      },
         #  ]
         #
-        data = self.safe_value(response, 'data', [])
+        data = self.safe_list(response, 'data', [])
         return self.parse_deposit_withdraw_fees(data, codes, 'currency')
 
     def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
@@ -4140,9 +4159,9 @@ class kucoin(Exchange, ImplicitAPI):
         #                                ↑                 ↑
         #                                ↑                 ↑
         #
-        versions = self.safe_value(self.options, 'versions', {})
-        apiVersions = self.safe_value(versions, api, {})
-        methodVersions = self.safe_value(apiVersions, method, {})
+        versions = self.safe_dict(self.options, 'versions', {})
+        apiVersions = self.safe_dict(versions, api, {})
+        methodVersions = self.safe_dict(apiVersions, method, {})
         defaultVersion = self.safe_string(methodVersions, path, self.options['version'])
         version = self.safe_string(params, 'version', defaultVersion)
         params = self.omit(params, 'version')
@@ -4163,7 +4182,8 @@ class kucoin(Exchange, ImplicitAPI):
         url = url + endpoint
         isFuturePrivate = (api == 'futuresPrivate')
         isPrivate = (api == 'private')
-        if isPrivate or isFuturePrivate:
+        isBroker = (api == 'private')
+        if isPrivate or isFuturePrivate or isBroker:
             self.check_required_credentials()
             timestamp = str(self.nonce())
             headers = self.extend({
@@ -4180,7 +4200,7 @@ class kucoin(Exchange, ImplicitAPI):
             payload = timestamp + method + endpoint + endpart
             signature = self.hmac(self.encode(payload), self.encode(self.secret), hashlib.sha256, 'base64')
             headers['KC-API-SIGN'] = signature
-            partner = self.safe_value(self.options, 'partner', {})
+            partner = self.safe_dict(self.options, 'partner', {})
             partner = self.safe_value(partner, 'future', partner) if isFuturePrivate else self.safe_value(partner, 'spot', partner)
             partnerId = self.safe_string(partner, 'id')
             partnerSecret = self.safe_string_2(partner, 'secret', 'key')
@@ -4189,6 +4209,9 @@ class kucoin(Exchange, ImplicitAPI):
                 partnerSignature = self.hmac(self.encode(partnerPayload), self.encode(partnerSecret), hashlib.sha256, 'base64')
                 headers['KC-API-PARTNER-SIGN'] = partnerSignature
                 headers['KC-API-PARTNER'] = partnerId
+            if isBroker:
+                brokerName = self.safe_string(partner, 'name')
+                headers['KC-BROKER-NAME'] = brokerName
         return {'url': url, 'method': method, 'body': body, 'headers': headers}
 
     def handle_errors(self, code, reason, url, method, headers, body, response, requestHeaders, requestBody):

ccxt/okx.py

@@ -6496,7 +6496,7 @@ class okx(Exchange, ImplicitAPI):
             'info': interest,
         }, market)
 
-    def set_sandbox_mode(self, enable):
+    def set_sandbox_mode(self, enable: bool):
         super(okx, self).set_sandbox_mode(enable)
         self.options['sandboxMode'] = enable
         if enable:

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.2.64'
+__version__ = '4.2.65'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/currencycom.py

@@ -194,7 +194,7 @@ class currencycom(ccxt.async_support.currencycom):
             'fee': None,
         }
 
-    def handle_trades(self, client: Client, message, subscription):
+    def handle_trades(self, client: Client, message):
         #
         #     {
         #         "status": "OK",

ccxt/static_dependencies/ethereum/utils/__init__.py

@@ -97,12 +97,6 @@ from .logging import (
 from .module_loading import (
     import_string,
 )
-from .network import (
-    Network,
-    name_from_chain_id,
-    network_from_chain_id,
-    short_name_from_chain_id,
-)
 from .numeric import (
     clamp,
 )

ccxt/static_dependencies/ethereum/utils/curried/__init__.py

@@ -17,7 +17,6 @@ from .. import (
     HasExtendedDebugLoggerMeta,
     HasLogger,
     HasLoggerMeta,
-    Network,
     ValidationError,
     add_0x_prefix,
     apply_formatter_at_index,
@@ -75,13 +74,10 @@ from .. import (
     is_text,
     is_tuple,
     # keccak,
-    name_from_chain_id,
-    network_from_chain_id,
     remove_0x_prefix,
     replace_exceptions,
     reversed_return,
     setup_DEBUG2_logging,
-    short_name_from_chain_id,
     sort_return,
     text_if_str as non_curried_text_if_str,
     to_bytes,

ccxt/test/base/test_shared_methods.py

@@ -117,7 +117,7 @@ def assert_timestamp(exchange, skipped_properties, method, entry, now_to_check=N
         assert isinstance(ts, numbers.Real), 'timestamp is not numeric' + log_text
         assert isinstance(ts, int), 'timestamp should be an integer' + log_text
         min_ts = 1230940800000  # 03 Jan 2009 - first block
-        max_ts = 2147483648000  # 03 Jan 2009 - first block
+        max_ts = 2147483648000  # 19 Jan 2038 - max int
         assert ts > min_ts, 'timestamp is impossible to be before ' + str(min_ts) + ' (03.01.2009)' + log_text  # 03 Jan 2009 - first block
         assert ts < max_ts, 'timestamp more than ' + str(max_ts) + ' (19.01.2038)' + log_text  # 19 Jan 2038 - int32 overflows # 7258118400000  -> Jan 1 2200
         if now_to_check is not None:

ccxt/woo.py

@@ -2732,6 +2732,6 @@ class woo(Exchange, ImplicitAPI):
         # if it was not returned according to above options, then return the first network of currency
         return self.safe_value(networkKeys, 0)
 
-    def set_sandbox_mode(self, enable):
+    def set_sandbox_mode(self, enable: bool):
         super(woo, self).set_sandbox_mode(enable)
         self.options['sandboxMode'] = enable

{ccxt-4.2.64.dist-info → ccxt-4.2.65.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 4.2.64
+Version: 4.2.65
 Summary: A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges
 Home-page: https://ccxt.com
 Author: Igor Kroitor
@@ -259,13 +259,13 @@ console.log(version, Object.keys(exchanges));
 
 All-in-one browser bundle (dependencies included), served from a CDN of your choice:
 
-* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.2.64/dist/ccxt.browser.js
-* unpkg: https://unpkg.com/ccxt@4.2.64/dist/ccxt.browser.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.2.65/dist/ccxt.browser.js
+* unpkg: https://unpkg.com/ccxt@4.2.65/dist/ccxt.browser.js
 
 CDNs are not updated in real-time and may have delays. Defaulting to the most recent version without specifying the version number is not recommended. Please, keep in mind that we are not responsible for the correct operation of those CDN servers.
 
 ```HTML
-<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.2.64/dist/ccxt.browser.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.2.65/dist/ccxt.browser.js"></script>
 ```
 
 Creates a global `ccxt` object: