ccxt 4.2.38__py2.py3-none-any.whl → 4.2.40__py2.py3-none-any.whl

ccxt/phemex.py

@@ -50,6 +50,7 @@ class phemex(Exchange, ImplicitAPI):
                 'addMargin': False,
                 'cancelAllOrders': True,
                 'cancelOrder': True,
+                'closePosition': False,
                 'createOrder': True,
                 'createReduceOnlyOrder': True,
                 'createStopLimitOrder': True,
@@ -2589,7 +2590,7 @@ class phemex(Exchange, ImplicitAPI):
         data = self.safe_value(response, 'data', {})
         return self.parse_order(data, market)
 
-    def edit_order(self, id: str, symbol, type=None, side=None, amount=None, price=None, params={}):
+    def edit_order(self, id: str, symbol: str, type: OrderType = None, side: OrderSide = None, amount: float = None, price: float = None, params={}):
         """
         edit a trade order
         :see: https://github.com/phemex/phemex-api-docs/blob/master/Public-Hedged-Perpetual-API.md#amend-order-by-orderid
@@ -3797,7 +3798,7 @@ class phemex(Exchange, ImplicitAPI):
             'status': self.parse_margin_status(self.safe_string(data, 'code')),
         }
 
-    def set_margin_mode(self, marginMode, symbol: Str = None, params={}):
+    def set_margin_mode(self, marginMode: str, symbol: Str = None, params={}):
         """
         set margin mode to 'cross' or 'isolated'
         :param str marginMode: 'cross' or 'isolated'
@@ -3825,7 +3826,7 @@ class phemex(Exchange, ImplicitAPI):
         }
         return self.privatePutPositionsLeverage(self.extend(request, params))
 
-    def set_position_mode(self, hedged, symbol: Str = None, params={}):
+    def set_position_mode(self, hedged: bool, symbol: Str = None, params={}):
         """
         set hedged to True or False for a market
         :see: https://github.com/phemex/phemex-api-docs/blob/master/Public-Hedged-Perpetual-API.md#switch-position-mode-synchronously
@@ -4054,7 +4055,7 @@ class phemex(Exchange, ImplicitAPI):
             response = self.privatePutPositionsLeverage(self.extend(request, params))
         return response
 
-    def transfer(self, code: str, amount: float, fromAccount, toAccount, params={}) -> TransferEntry:
+    def transfer(self, code: str, amount: float, fromAccount: str, toAccount: str, params={}) -> TransferEntry:
         """
         transfer currency internally between wallets on the same account
         :param str code: unified currency code

ccxt/poloniex.py

@@ -1300,7 +1300,7 @@ class poloniex(Exchange, ImplicitAPI):
         # remember the timestamp before issuing the request
         return [request, params]
 
-    def edit_order(self, id: str, symbol, type, side, amount=None, price=None, params={}):
+    def edit_order(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: float = None, price: float = None, params={}):
         """
         edit a trade order
         :see: https://docs.poloniex.com/#authenticated-endpoints-orders-cancel-replace-order
@@ -1736,7 +1736,7 @@ class poloniex(Exchange, ImplicitAPI):
             'info': response,
         }
 
-    def transfer(self, code: str, amount: float, fromAccount, toAccount, params={}) -> TransferEntry:
+    def transfer(self, code: str, amount: float, fromAccount: str, toAccount: str, params={}) -> TransferEntry:
         """
         transfer currency internally between wallets on the same account
         :see: https://docs.poloniex.com/#authenticated-endpoints-accounts-accounts-transfer

ccxt/poloniexfutures.py

@@ -1321,7 +1321,7 @@ class poloniexfutures(Exchange, ImplicitAPI):
         """
         return self.fetch_orders_by_status('closed', symbol, since, limit, params)
 
-    def fetch_order(self, id=None, symbol: Str = None, params={}):
+    def fetch_order(self, id: str = None, symbol: Str = None, params={}):
         """
         fetches information on an order made by the user
         :see: https://futures-docs.poloniex.com/#get-details-of-a-single-order
@@ -1619,24 +1619,28 @@ class poloniexfutures(Exchange, ImplicitAPI):
         trades = self.safe_value(data, 'items', {})
         return self.parse_trades(trades, market, since, limit)
 
-    def set_margin_mode(self, marginMode, symbol, params={}):
+    def set_margin_mode(self, marginMode: str, symbol: str = None, params={}):
         """
         set margin mode to 'cross' or 'isolated'
         :see: https://futures-docs.poloniex.com/#change-margin-mode
-        :param int marginMode: 0(isolated) or 1(cross)
+        :param str marginMode: "0"(isolated) or "1"(cross)
         :param str symbol: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: response from the exchange
         """
         if symbol is None:
             raise ArgumentsRequired(self.id + ' setMarginMode() requires a symbol argument')
-        if (marginMode != 0) and (marginMode != 1):
-            raise ArgumentsRequired(self.id + ' setMarginMode() marginMode must be 0(isolated) or 1(cross)')
+        if (marginMode != '0') and (marginMode != '1') and (marginMode != 'isolated') and (marginMode != 'cross'):
+            raise ArgumentsRequired(self.id + ' setMarginMode() marginMode must be 0/isolated or 1/cross')
         self.load_markets()
+        if marginMode == 'isolated':
+            marginMode = '0'
+        if marginMode == 'cross':
+            marginMode = '1'
         market = self.market(symbol)
         request = {
             'symbol': market['id'],
-            'marginType': marginMode,
+            'marginType': self.parse_to_int(marginMode),
         }
         return self.privatePostMarginTypeChange(request)
 

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.2.38'
+__version__ = '4.2.40'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/bitmart.py

@@ -33,8 +33,10 @@ class bitmart(ccxt.async_support.bitmart):
                 'watchTicker': True,
                 'watchTickers': True,
                 'watchOrderBook': True,
+                'watchOrderBookForSymbols': True,
                 'watchOrders': True,
                 'watchTrades': True,
+                'watchTradesForSymbols': True,
                 'watchOHLCV': True,
                 'watchPosition': 'emulated',
                 'watchPositions': True,
@@ -59,8 +61,15 @@ class bitmart(ccxt.async_support.bitmart):
                     'fetchBalanceSnapshot': True,  # or False
                     'awaitBalanceSnapshot': False,  # whether to wait for the balance snapshot before providing updates
                 },
+                #
+                # orderbook channels can have:
+                #  -  'depth5', 'depth20', 'depth50'  # these endpoints emit full Orderbooks once in every 500ms
+                #  -  'depth/increase100'  # self endpoint is preferred, because it emits once in 100ms. however, when self value is chosen, it only affects spot-market, but contracts markets automatically `depth50` will be being used
                 'watchOrderBook': {
-                    'depth': 'depth/increase100',  # depth/increase100, depth5, depth20, depth50
+                    'depth': 'depth/increase100',
+                },
+                'watchOrderBookForSymbols': {
+                    'depth': 'depth/increase100',
                 },
                 'ws': {
                     'inflate': True,
@@ -105,6 +114,23 @@ class bitmart(ccxt.async_support.bitmart):
             }
         return await self.watch(url, messageHash, self.deep_extend(request, params), messageHash)
 
+    async def subscribe_multiple(self, channel: str, type: str, symbols: List[str], params={}):
+        url = self.implode_hostname(self.urls['api']['ws'][type]['public'])
+        channelType = 'spot' if (type == 'spot') else 'futures'
+        actionType = 'op' if (type == 'spot') else 'action'
+        rawSubscriptions = []
+        messageHashes = []
+        for i in range(0, len(symbols)):
+            market = self.market(symbols[i])
+            message = channelType + '/' + channel + ':' + market['id']
+            rawSubscriptions.append(message)
+            messageHashes.append(channel + ':' + market['symbol'])
+        request = {
+            'args': rawSubscriptions,
+        }
+        request[actionType] = 'subscribe'
+        return await self.watch_multiple(url, messageHashes, self.deep_extend(request, params), rawSubscriptions)
+
     async def watch_balance(self, params={}) -> Balances:
         """
         :see: https://developer-pro.bitmart.com/en/spot/#private-balance-change
@@ -236,16 +262,39 @@ class bitmart(ccxt.async_support.bitmart):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
         """
+        return await self.watch_trades_for_symbols([symbol], since, limit, params)
+
+    async def watch_trades_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}) -> List[Trade]:
+        """
+        :see: https://developer-pro.bitmart.com/en/spot/#public-trade-channel
+        get the list of most recent trades for a list of symbols
+        :param str[] symbols: unified symbol of the market to fetch trades for
+        :param int [since]: timestamp in ms of the earliest trade to fetch
+        :param int [limit]: the maximum amount of trades to fetch
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
+        """
         await self.load_markets()
-        symbol = self.symbol(symbol)
-        market = self.market(symbol)
-        type = 'spot'
-        type, params = self.handle_market_type_and_params('watchTrades', market, params)
-        trades = await self.subscribe('trade', symbol, type, params)
+        marketType = None
+        symbols, marketType, params = self.get_params_for_multiple_sub('watchTradesForSymbols', symbols, limit, params)
+        channelName = 'trade'
+        trades = await self.subscribe_multiple(channelName, marketType, symbols, params)
         if self.newUpdates:
-            limit = trades.getLimit(symbol, limit)
+            first = self.safe_dict(trades, 0)
+            tradeSymbol = self.safe_string(first, 'symbol')
+            limit = trades.getLimit(tradeSymbol, limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
+    def get_params_for_multiple_sub(self, methodName: str, symbols: List[str], limit: Int = None, params={}):
+        symbols = self.market_symbols(symbols, None, False, True)
+        length = len(symbols)
+        if length > 20:
+            raise NotSupported(self.id + ' ' + methodName + '() accepts a maximum of 20 symbols in one request')
+        market = self.market(symbols[0])
+        marketType = None
+        marketType, params = self.handle_market_type_and_params(methodName, market, params)
+        return [symbols, marketType, params]
+
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         :see: https://developer-pro.bitmart.com/en/spot/#public-ticker-channel
@@ -747,12 +796,11 @@ class bitmart(ccxt.async_support.bitmart):
         #        ]
         #    }
         #
-        channel = self.safe_string_2(message, 'table', 'group')
-        isSpot = (channel.find('spot') >= 0)
         data = self.safe_value(message, 'data')
         if data is None:
             return
         stored = None
+        symbol = None
         for i in range(0, len(data)):
             trade = self.parse_ws_trade(data[i])
             symbol = trade['symbol']
@@ -762,9 +810,7 @@ class bitmart(ccxt.async_support.bitmart):
                 stored = ArrayCache(tradesLimit)
                 self.trades[symbol] = stored
             stored.append(trade)
-        messageHash = channel
-        if isSpot:
-            messageHash += ':' + self.safe_string(data[0], 'symbol')
+        messageHash = 'trade:' + symbol
         client.resolve(stored, messageHash)
 
     def parse_ws_trade(self, trade, market: Market = None):
@@ -1084,8 +1130,8 @@ class bitmart(ccxt.async_support.bitmart):
         #         "symbol": "BTC_USDT"
         #     }
         #
-        asks = self.safe_value(message, 'asks', [])
-        bids = self.safe_value(message, 'bids', [])
+        asks = self.safe_list(message, 'asks', [])
+        bids = self.safe_list(message, 'bids', [])
         self.handle_deltas(orderbook['asks'], asks)
         self.handle_deltas(orderbook['bids'], bids)
         timestamp = self.safe_integer(message, 'ms_t')
@@ -1099,6 +1145,7 @@ class bitmart(ccxt.async_support.bitmart):
     def handle_order_book(self, client: Client, message):
         #
         # spot depth-all
+        #
         #    {
         #        "data": [
         #            {
@@ -1118,33 +1165,31 @@ class bitmart(ccxt.async_support.bitmart):
         #        ],
         #        "table": "spot/depth5"
         #    }
+        #
         # spot increse depth snapshot
+        #
         #    {
         #        "data":[
         #           {
-        #              "asks":[
-        #                 [
-        #                    "43652.52",
-        #                    "0.02039"
-        #                 ],
-        #                 ...
-        #              ],
-        #              "bids":[
-        #                [
-        #                   "43652.51",
-        #                   "0.00500"
+        #               "asks":[
+        #                   ["43652.52", "0.02039"],
+        #                   ...
         #                ],
-        #                ...
-        #              ],
-        #              "ms_t":1703376836487,
-        #              "symbol":"BTC_USDT",
-        #              "type":"snapshot",  # or update
-        #              "version":2141731
+        #                "bids":[
+        #                   ["43652.51", "0.00500"],
+        #                   ...
+        #                ],
+        #                "ms_t":1703376836487,
+        #                "symbol":"BTC_USDT",
+        #                "type":"snapshot",  # or update
+        #                "version":2141731
         #           }
         #        ],
         #        "table":"spot/depth/increase100"
         #    }
+        #
         # swap
+        #
         #    {
         #        "group":"futures/depth50:BTCUSDT",
         #        "data":{
@@ -1165,43 +1210,58 @@ class bitmart(ccxt.async_support.bitmart):
         #        }
         #    }
         #
-        data = self.safe_value(message, 'data')
-        if data is None:
+        isSpot = ('table' in message)
+        datas = []
+        if isSpot:
+            datas = self.safe_list(message, 'data', datas)
+        else:
+            orderBookEntry = self.safe_dict(message, 'data')
+            if orderBookEntry is not None:
+                datas.append(orderBookEntry)
+        length = len(datas)
+        if length <= 0:
             return
-        depths = self.safe_value(data, 'depths')
-        isSpot = (depths is None)
-        table = self.safe_string_2(message, 'table', 'group')
+        channelName = self.safe_string_2(message, 'table', 'group')
         # find limit subscribed to
         limitsToCheck = ['100', '50', '20', '10', '5']
         limit = 0
         for i in range(0, len(limitsToCheck)):
             limitString = limitsToCheck[i]
-            if table.find(limitString) >= 0:
+            if channelName.find(limitString) >= 0:
                 limit = self.parse_to_int(limitString)
                 break
         if isSpot:
-            for i in range(0, len(data)):
-                update = data[i]
+            channel = channelName.replace('spot/', '')
+            for i in range(0, len(datas)):
+                update = datas[i]
                 marketId = self.safe_string(update, 'symbol')
                 symbol = self.safe_symbol(marketId)
-                orderbook = self.safe_value(self.orderbooks, symbol)
+                orderbook = self.safe_dict(self.orderbooks, symbol)
                 if orderbook is None:
                     orderbook = self.order_book({}, limit)
                     orderbook['symbol'] = symbol
                     self.orderbooks[symbol] = orderbook
                 type = self.safe_value(update, 'type')
-                if (type == 'snapshot') or (not(table.find('increase') >= 0)):
+                if (type == 'snapshot') or (not(channelName.find('increase') >= 0)):
                     orderbook.reset({})
                 self.handle_order_book_message(client, update, orderbook)
                 timestamp = self.safe_integer(update, 'ms_t')
-                orderbook['timestamp'] = timestamp
-                orderbook['datetime'] = self.iso8601(timestamp)
-                messageHash = table + ':' + marketId
+                if orderbook['timestamp'] is None:
+                    orderbook['timestamp'] = timestamp
+                    orderbook['datetime'] = self.iso8601(timestamp)
+                messageHash = channelName + ':' + marketId
                 client.resolve(orderbook, messageHash)
+                # resolve ForSymbols
+                messageHashForMulti = channel + ':' + symbol
+                client.resolve(orderbook, messageHashForMulti)
         else:
+            tableParts = channelName.split(':')
+            channel = tableParts[0].replace('futures/', '')
+            data = datas[0]  # contract markets always contain only one member
+            depths = data['depths']
             marketId = self.safe_string(data, 'symbol')
             symbol = self.safe_symbol(marketId)
-            orderbook = self.safe_value(self.orderbooks, symbol)
+            orderbook = self.safe_dict(self.orderbooks, symbol)
             if orderbook is None:
                 orderbook = self.order_book({}, limit)
                 orderbook['symbol'] = symbol
@@ -1225,8 +1285,31 @@ class bitmart(ccxt.async_support.bitmart):
             timestamp = self.safe_integer(data, 'ms_t')
             orderbook['timestamp'] = timestamp
             orderbook['datetime'] = self.iso8601(timestamp)
-            messageHash = table
+            messageHash = channelName
             client.resolve(orderbook, messageHash)
+            # resolve ForSymbols
+            messageHashForMulti = channel + ':' + symbol
+            client.resolve(orderbook, messageHashForMulti)
+
+    async def watch_order_book_for_symbols(self, symbols: List[str], limit: Int = None, params={}) -> OrderBook:
+        """
+        watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        :see: https://developer-pro.bitmart.com/en/spot/#public-depth-increase-channel
+        :param str[] symbols: unified array of symbols
+        :param int [limit]: the maximum amount of order book entries to return
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.depth]: the type of order book to subscribe to, default is 'depth/increase100', also accepts 'depth5' or 'depth20' or depth50
+        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
+        """
+        await self.load_markets()
+        type = None
+        symbols, type, params = self.get_params_for_multiple_sub('watchOrderBookForSymbols', symbols, limit, params)
+        channel = None
+        channel, params = self.handle_option_and_params(params, 'watchOrderBookForSymbols', 'depth', 'depth/increase100')
+        if type == 'swap' and channel == 'depth/increase100':
+            channel = 'depth50'
+        orderbook = await self.subscribe_multiple(channel, type, symbols, params)
+        return orderbook.limit()
 
     async def authenticate(self, type, params={}):
         self.check_required_credentials()

ccxt/pro/bitvavo.py

@@ -530,7 +530,7 @@ class bitvavo(ccxt.async_support.bitvavo):
         request = self.create_order_request(symbol, type, side, amount, price, params)
         return await self.watch_request('privateCreateOrder', request)
 
-    async def edit_order_ws(self, id: str, symbol, type, side, amount=None, price=None, params={}) -> Order:
+    async def edit_order_ws(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: float = None, price: float = None, params={}) -> Order:
         """
         edit a trade order
         :see: https://docs.bitvavo.com/#tag/Orders/paths/~1order/put

ccxt/pro/bybit.py

@@ -136,7 +136,7 @@ class bybit(ccxt.async_support.bybit):
         self.options['requestId'] = requestId
         return requestId
 
-    def get_url_by_market_type(self, symbol: Str = None, isPrivate=False, method=None, params={}):
+    def get_url_by_market_type(self, symbol: Str = None, isPrivate=False, method: str = None, params={}):
         accessibility = 'private' if isPrivate else 'public'
         isUsdcSettled = None
         isSpot = None
@@ -185,7 +185,7 @@ class bybit(ccxt.async_support.bybit):
         market = self.market(symbol)
         symbol = market['symbol']
         messageHash = 'ticker:' + symbol
-        url = self.get_url_by_market_type(symbol, False, params)
+        url = self.get_url_by_market_type(symbol, False, 'watchTicker', params)
         params = self.clean_params(params)
         options = self.safe_value(self.options, 'watchTicker', {})
         topic = self.safe_string(options, 'name', 'tickers')
@@ -207,7 +207,7 @@ class bybit(ccxt.async_support.bybit):
         await self.load_markets()
         symbols = self.market_symbols(symbols, None, False)
         messageHashes = []
-        url = self.get_url_by_market_type(symbols[0], False, params)
+        url = self.get_url_by_market_type(symbols[0], False, 'watchTickers', params)
         params = self.clean_params(params)
         options = self.safe_value(self.options, 'watchTickers', {})
         topic = self.safe_string(options, 'name', 'tickers')
@@ -368,7 +368,7 @@ class bybit(ccxt.async_support.bybit):
         await self.load_markets()
         market = self.market(symbol)
         symbol = market['symbol']
-        url = self.get_url_by_market_type(symbol, False, params)
+        url = self.get_url_by_market_type(symbol, False, 'watchOHLCV', params)
         params = self.clean_params(params)
         ohlcv = None
         timeframeId = self.safe_string(self.timeframes, timeframe, timeframe)
@@ -477,7 +477,7 @@ class bybit(ccxt.async_support.bybit):
         if symbolsLength == 0:
             raise ArgumentsRequired(self.id + ' watchOrderBookForSymbols() requires a non-empty array of symbols')
         symbols = self.market_symbols(symbols)
-        url = self.get_url_by_market_type(symbols[0], False, params)
+        url = self.get_url_by_market_type(symbols[0], False, 'watchOrderBook', params)
         params = self.clean_params(params)
         market = self.market(symbols[0])
         if limit is None:
@@ -595,7 +595,7 @@ class bybit(ccxt.async_support.bybit):
         if symbolsLength == 0:
             raise ArgumentsRequired(self.id + ' watchTradesForSymbols() requires a non-empty array of symbols')
         params = self.clean_params(params)
-        url = self.get_url_by_market_type(symbols[0], False, params)
+        url = self.get_url_by_market_type(symbols[0], False, 'watchTrades', params)
         topics = []
         messageHashes = []
         for i in range(0, len(symbols)):

ccxt/pro/cex.py

@@ -1196,7 +1196,7 @@ class cex(ccxt.async_support.cex):
         rawOrder = await self.watch(url, messageHash, request, messageHash)
         return self.parse_order(rawOrder, market)
 
-    async def edit_order_ws(self, id: str, symbol, type, side, amount=None, price=None, params={}) -> Order:
+    async def edit_order_ws(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: float = None, price: float = None, params={}) -> Order:
         """
         edit a trade order
         :see: https://docs.cex.io/#ws-api-cancel-replace
@@ -1260,7 +1260,7 @@ class cex(ccxt.async_support.cex):
         response = await self.watch(url, messageHash, request, messageHash, messageHash)
         return self.parse_order(response, market)
 
-    async def cancel_orders_ws(self, ids, symbol: str = None, params={}):
+    async def cancel_orders_ws(self, ids: List[str], symbol: str = None, params={}):
         """
         cancel multiple orders
         :see: https://docs.cex.io/#ws-api-mass-cancel-place

ccxt/pro/coinbase.py

@@ -88,7 +88,7 @@ class coinbase(ccxt.async_support.coinbase):
         }
         return await self.watch(url, messageHash, subscribe, messageHash)
 
-    async def watch_ticker(self, symbol, params={}) -> Ticker:
+    async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
         :see: https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#ticker-channel
@@ -251,7 +251,7 @@ class coinbase(ccxt.async_support.coinbase):
             limit = trades.getLimit(symbol, limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
-    async def watch_orders(self, symbol=None, since=None, limit=None, params={}) -> List[Order]:
+    async def watch_orders(self, symbol: str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         watches information on multiple orders made by the user
         :see: https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#user-channel

ccxt/pro/coinex.py

@@ -554,7 +554,7 @@ class coinex(ccxt.async_support.coinex):
             limit = ohlcvs.getLimit(symbol, limit)
         return self.filter_by_since_limit(ohlcvs, since, limit, 0)
 
-    async def fetch_ohlcv_ws(self, symbol, timeframe='1m', since=None, limit=None, params={}) -> List[list]:
+    async def fetch_ohlcv_ws(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
         :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot004_websocket005_kline_query
         query historical candlestick data containing the open, high, low, and close price, and the volume of a market

ccxt/pro/lbank.py

@@ -248,7 +248,7 @@ class lbank(ccxt.async_support.lbank):
         requestId = self.request_id()
         return await self.watch(url, messageHash, request, requestId, request)
 
-    async def watch_ticker(self, symbol, params={}) -> Ticker:
+    async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         :see: https://www.lbank.com/en-US/docs/index.html#market
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market

ccxt/pro/mexc.py

@@ -455,7 +455,7 @@ class mexc(ccxt.async_support.mexc):
             return
         try:
             self.handle_delta(storedOrderBook, data)
-            timestamp = self.safe_integer(message, 't')
+            timestamp = self.safe_integer_2(message, 't', 'ts')
             storedOrderBook['timestamp'] = timestamp
             storedOrderBook['datetime'] = self.iso8601(timestamp)
         except Exception as e:

ccxt/probit.py

@@ -1311,7 +1311,7 @@ class probit(Exchange, ImplicitAPI):
             raise InvalidAddress(self.id + ' fetchDepositAddress() returned an empty response')
         return self.parse_deposit_address(firstAddress, currency)
 
-    def fetch_deposit_addresses(self, codes=None, params={}):
+    def fetch_deposit_addresses(self, codes: List[str] = None, params={}):
         """
         :see: https://docs-en.probit.com/reference/deposit_address
         fetch deposit addresses for multiple currencies and chain types

ccxt/test/test_async.py

@@ -373,7 +373,8 @@ class testMainClass(baseMainTestClass):
                         final_value = exchange_settings[key]
                     set_exchange_prop(exchange, key, final_value)
         # credentials
-        self.load_credentials_from_env(exchange)
+        if self.load_keys:
+            self.load_credentials_from_env(exchange)
         # skipped tests
         skipped_file = self.root_dir_for_skips + 'skip-tests.json'
         skipped_settings = io_file_read(skipped_file)
@@ -1053,6 +1054,7 @@ class testMainClass(baseMainTestClass):
         currencies = self.load_currencies_from_file(exchange_name)
         exchange = init_exchange(exchange_name, {
             'markets': markets,
+            'currencies': currencies,
             'enableRateLimit': False,
             'rateLimit': 1,
             'httpProxy': 'http://fake:8080',

ccxt/test/test_sync.py

@@ -372,7 +372,8 @@ class testMainClass(baseMainTestClass):
                         final_value = exchange_settings[key]
                     set_exchange_prop(exchange, key, final_value)
         # credentials
-        self.load_credentials_from_env(exchange)
+        if self.load_keys:
+            self.load_credentials_from_env(exchange)
         # skipped tests
         skipped_file = self.root_dir_for_skips + 'skip-tests.json'
         skipped_settings = io_file_read(skipped_file)
@@ -1052,6 +1053,7 @@ class testMainClass(baseMainTestClass):
         currencies = self.load_currencies_from_file(exchange_name)
         exchange = init_exchange(exchange_name, {
             'markets': markets,
+            'currencies': currencies,
             'enableRateLimit': False,
             'rateLimit': 1,
             'httpProxy': 'http://fake:8080',

ccxt/timex.py

@@ -755,7 +755,7 @@ class timex(Exchange, ImplicitAPI):
         order = self.safe_value(orders, 0, {})
         return self.parse_order(order, market)
 
-    def edit_order(self, id: str, symbol, type, side, amount=None, price=None, params={}):
+    def edit_order(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: float = None, price: float = None, params={}):
         self.load_markets()
         market = self.market(symbol)
         request = {

ccxt/upbit.py

@@ -1522,7 +1522,7 @@ class upbit(Exchange, ImplicitAPI):
         #
         return self.parse_order(response)
 
-    def fetch_deposit_addresses(self, codes=None, params={}):
+    def fetch_deposit_addresses(self, codes: List[str] = None, params={}):
         """
         :see: https://docs.upbit.com/reference/%EC%A0%84%EC%B2%B4-%EC%9E%85%EA%B8%88-%EC%A3%BC%EC%86%8C-%EC%A1%B0%ED%9A%8C
         fetch deposit addresses for multiple currencies and chain types

ccxt/wavesexchange.py

@@ -324,7 +324,7 @@ class wavesexchange(Exchange, ImplicitAPI):
                 },
             },
             'currencies': {
-                'WX': self.safe_currency_structure({'id': 'EMAMLxDnv3xiz8RXg8Btj33jcEw3wLczL3JKYYmuubpc', 'numericId': None, 'code': 'WX', 'precision': self.parse_number('8')}),
+                'WX': self.safe_currency_structure({'id': 'EMAMLxDnv3xiz8RXg8Btj33jcEw3wLczL3JKYYmuubpc', 'numericId': None, 'code': 'WX', 'precision': self.parse_to_int('8')}),
             },
             'precisionMode': DECIMAL_PLACES,
             'options': {

ccxt/whitebit.py

@@ -456,7 +456,7 @@ class whitebit(Exchange, ImplicitAPI):
             }
         return result
 
-    def fetch_transaction_fees(self, codes=None, params={}):
+    def fetch_transaction_fees(self, codes: List[str] = None, params={}):
         """
          * @deprecated
         please use fetchDepositWithdrawFees instead
@@ -1616,7 +1616,7 @@ class whitebit(Exchange, ImplicitAPI):
         #         "leverage": 5
         #     }
 
-    def transfer(self, code: str, amount: float, fromAccount, toAccount, params={}) -> TransferEntry:
+    def transfer(self, code: str, amount: float, fromAccount: str, toAccount: str, params={}) -> TransferEntry:
         """
         transfer currency internally between wallets on the same account
         :see: https://docs.whitebit.com/private/http-main-v4/#transfer-between-main-and-trade-balances