ccxt 4.2.63__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,8 @@ class kucoin(Exchange, ImplicitAPI):
                         'project/marketInterestRate': 7.5,  # 5PW
                         'redeem/orders': 10,  # 10SW
                         'purchase/orders': 10,  # 10SW
+                        # broker
+                        'broker/api/rebase/download': 3,
                     },
                     'post': {
                         # account
@@ -393,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',
@@ -906,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',
@@ -950,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:
@@ -984,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)):
@@ -995,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')
@@ -1011,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,
@@ -1142,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))
@@ -1165,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,
@@ -1236,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]
@@ -1317,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):
@@ -1348,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
@@ -1373,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())
@@ -1510,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)):
@@ -1631,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={}):
@@ -1656,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={}):
@@ -1742,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'],
         })
@@ -1807,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')
@@ -1899,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={}):
@@ -2012,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={}):
@@ -2110,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={}):
@@ -2132,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:
@@ -2299,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)
 
@@ -2414,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)
@@ -2548,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:
@@ -2573,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
@@ -2700,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]:
@@ -2745,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:
@@ -2899,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,
@@ -2956,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):
@@ -3047,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,
@@ -3254,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)
@@ -3330,7 +3350,7 @@ class kucoin(Exchange, ImplicitAPI):
         #        }
         #    }
         #
-        data = self.safe_value(response, 'data', [])
+        data = self.safe_list(response, 'data', [])
         result = {
             'info': response,
             'timestamp': None,
@@ -3342,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 = {}
@@ -3351,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')
@@ -3427,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 = {
@@ -3454,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):
@@ -3497,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 {
@@ -3659,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)
@@ -3733,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):
@@ -3869,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):
@@ -3923,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
@@ -3977,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={}):
@@ -4014,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={}):
@@ -4045,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={}):
@@ -4080,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):
@@ -4130,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):
@@ -4139,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')
@@ -4162,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({
@@ -4179,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')
@@ -4188,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.63'
+__version__ = '4.2.65'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/bitget.py

@@ -1227,7 +1227,7 @@ class bitget(ccxt.async_support.bitget):
         if feeAmount is not None:
             feeCurrency = self.safe_string(fee, 'feeCoin')
             feeObject = {
-                'cost': Precise.string_abs(feeAmount),
+                'cost': self.parse_number(Precise.string_abs(feeAmount)),
                 'currency': self.safe_currency_code(feeCurrency),
             }
         triggerPrice = self.safe_number(order, 'triggerPrice')
@@ -1239,8 +1239,9 @@ class bitget(ccxt.async_support.bitget):
         if side == 'buy' and market['spot'] and (type == 'market'):
             cost = self.safe_string(order, 'newSize', cost)
         filled = self.safe_string_2(order, 'accBaseVolume', 'baseVolume')
-        if market['spot'] and (rawStatus != 'live'):
-            filled = Precise.string_div(cost, avgPrice)
+        # if market['spot'] and (rawStatus != 'live'):
+        #     filled = Precise.string_div(cost, avgPrice)
+        # }
         amount = self.safe_string(order, 'baseVolume')
         if not market['spot'] or not (side == 'buy' and type == 'market'):
             amount = self.safe_string(order, 'newSize', amount)

ccxt/pro/coinex.py

@@ -1008,7 +1008,7 @@ class coinex(ccxt.async_support.coinex):
             messageHash = 'authenticated:spot'
             future = self.safe_value(client.subscriptions, messageHash)
             if future is not None:
-                return future
+                return await future
             requestId = self.request_id()
             subscribe = {
                 'id': requestId,
@@ -1027,12 +1027,12 @@ class coinex(ccxt.async_support.coinex):
             }
             future = self.watch(url, messageHash, request, requestId, subscribe)
             client.subscriptions[messageHash] = future
-            return future
+            return await future
         else:
             messageHash = 'authenticated:swap'
             future = self.safe_value(client.subscriptions, messageHash)
             if future is not None:
-                return future
+                return await future
             requestId = self.request_id()
             subscribe = {
                 'id': requestId,
@@ -1051,4 +1051,4 @@ class coinex(ccxt.async_support.coinex):
             }
             future = self.watch(url, messageHash, request, requestId, subscribe)
             client.subscriptions[messageHash] = future
-            return future
+            return await future

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/pro/lbank.py

@@ -175,7 +175,7 @@ class lbank(ccxt.async_support.lbank):
         #          },
         #          type: 'kbar',
         #          pair: 'btc_usdt',
-        #          TS: '2022-10-02T12:44:15.864'
+        #          TS: '2022-10-02T12:44:15.865'
         #      }
         #
         marketId = self.safe_string(message, 'pair')

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: