ccxt 4.2.84__py2.py3-none-any.whl → 4.2.86__py2.py3-none-any.whl

ccxt/pro/binance.py

@@ -12,6 +12,7 @@ from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
+from ccxt.base.errors import NotSupported
 from ccxt.base.precise import Precise
 
 
@@ -22,6 +23,7 @@ class binance(ccxt.async_support.binance):
             'has': {
                 'ws': True,
                 'watchBalance': True,
+                'watchBidsAsks': True,
                 'watchMyTrades': True,
                 'watchOHLCV': True,
                 'watchOHLCVForSymbols': False,
@@ -103,10 +105,10 @@ class binance(ccxt.async_support.binance):
                     'name': 'trade',  # 'trade' or 'aggTrade'
                 },
                 'watchTicker': {
-                    'name': 'ticker',  # ticker = 1000ms L1+OHLCV, bookTicker = real-time L1
+                    'name': 'ticker',  # ticker or miniTicker or ticker_<window_size>
                 },
                 'watchTickers': {
-                    'name': 'ticker',  # ticker or miniTicker or bookTicker
+                    'name': 'ticker',  # ticker or miniTicker or ticker_<window_size>
                 },
                 'watchOHLCV': {
                     'name': 'kline',  # or indexPriceKline or markPriceKline(coin-m futures)
@@ -127,6 +129,15 @@ class binance(ccxt.async_support.binance):
                 'ws': {
                     'cost': 5,
                 },
+                'tickerChannelsMap': {
+                    '24hrTicker': 'ticker',
+                    '24hrMiniTicker': 'miniTicker',
+                    # rolling window tickers
+                    '1hTicker': 'ticker_1h',
+                    '4hTicker': 'ticker_4h',
+                    '1dTicker': 'ticker_1d',
+                    'bookTicker': 'bookTicker',
+                },
             },
         })
 
@@ -867,33 +878,13 @@ class binance(ccxt.async_support.binance):
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :param str [params.name]: stream to use can be ticker or bookTicker
+        :param str [params.name]: stream to use can be ticker or miniTicker
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
         await self.load_markets()
-        market = self.market(symbol)
-        marketId = market['lowercaseId']
-        type = market['type']
-        if market['contract']:
-            type = 'future' if market['linear'] else 'delivery'
-        options = self.safe_value(self.options, 'watchTicker', {})
-        name = self.safe_string(options, 'name', 'ticker')
-        name = self.safe_string(params, 'name', name)
-        params = self.omit(params, 'name')
-        messageHash = marketId + '@' + name
-        url = self.urls['api']['ws'][type] + '/' + self.stream(type, messageHash)
-        requestId = self.request_id(url)
-        request = {
-            'method': 'SUBSCRIBE',
-            'params': [
-                messageHash,
-            ],
-            'id': requestId,
-        }
-        subscribe = {
-            'id': requestId,
-        }
-        return await self.watch(url, messageHash, self.extend(request, params), messageHash, subscribe)
+        symbol = self.symbol(symbol)
+        tickers = await self.watch_tickers([symbol], self.extend(params, {'callerMethodName': 'watchTicker'}))
+        return tickers[symbol]
 
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
@@ -902,52 +893,89 @@ class binance(ccxt.async_support.binance):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
+        channelName = None
+        channelName, params = self.handle_option_and_params(params, 'watchTickers', 'name', 'ticker')
+        if channelName == 'bookTicker':
+            raise BadRequest(self.id + ' deprecation notice - to subscribe for bids-asks, use watch_bids_asks() method instead')
+        newTickers = await self.watch_multi_ticker_helper('watchTickers', channelName, symbols, params)
+        if self.newUpdates:
+            return newTickers
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
+
+    async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        :see: https://binance-docs.github.io/apidocs/spot/en/#individual-symbol-book-ticker-streams
+        :see: https://binance-docs.github.io/apidocs/futures/en/#all-book-tickers-stream
+        :see: https://binance-docs.github.io/apidocs/delivery/en/#all-book-tickers-stream
+        watches best bid & ask for symbols
+        :param str[] symbols: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        result = await self.watch_multi_ticker_helper('watchBidsAsks', 'bookTicker', symbols, params)
+        if self.newUpdates:
+            return result
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
+
+    async def watch_multi_ticker_helper(self, methodName, channelName: str, symbols: Strings = None, params={}):
         await self.load_markets()
-        symbols = self.market_symbols(symbols, None, True, True, True)
-        marketIds = self.market_ids(symbols)
-        market = None
-        type = None
-        if symbols is not None:
-            market = self.market(symbols[0])
-        type, params = self.handle_market_type_and_params('watchTickers', market, params)
+        symbols = self.market_symbols(symbols, None, True, False, True)
+        firstMarket = None
+        marketType = None
+        symbolsDefined = (symbols is not None)
+        if symbolsDefined:
+            firstMarket = self.market(symbols[0])
+        marketType, params = self.handle_market_type_and_params(methodName, firstMarket, params)
         subType = None
-        subType, params = self.handle_sub_type_and_params('watchTickers', market, params)
-        if self.isLinear(type, subType):
-            type = 'future'
-        elif self.isInverse(type, subType):
-            type = 'delivery'
-        options = self.safe_value(self.options, 'watchTickers', {})
-        name = self.safe_string(options, 'name', 'ticker')
-        name = self.safe_string(params, 'name', name)
-        params = self.omit(params, 'name')
-        wsParams = []
-        messageHash = 'tickers'
-        if symbols is not None:
-            messageHash = 'tickers::' + ','.join(symbols)
-        if name == 'bookTicker':
-            if marketIds is None:
-                raise ArgumentsRequired(self.id + ' watchTickers() requires symbols for bookTicker')
-            # simulate watchTickers with subscribe multiple individual bookTicker topic
-            for i in range(0, len(marketIds)):
-                wsParams.append(marketIds[i].lower() + '@bookTicker')
+        subType, params = self.handle_sub_type_and_params(methodName, firstMarket, params)
+        rawMarketType = None
+        if self.isLinear(marketType, subType):
+            rawMarketType = 'future'
+        elif self.isInverse(marketType, subType):
+            rawMarketType = 'delivery'
+        elif marketType == 'spot':
+            rawMarketType = marketType
         else:
-            wsParams = [
-                '!' + name + '@arr',
-            ]
-        url = self.urls['api']['ws'][type] + '/' + self.stream(type, messageHash)
+            raise NotSupported(self.id + ' ' + methodName + '() does not support options markets')
+        isBidAsk = (channelName == 'bookTicker')
+        subscriptionArgs = []
+        messageHashes = []
+        if symbolsDefined:
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                market = self.market(symbol)
+                subscriptionArgs.append(market['lowercaseId'] + '@' + channelName)
+                messageHashes.append(self.get_message_hash(channelName, market['symbol'], isBidAsk))
+        else:
+            if isBidAsk:
+                if marketType == 'spot':
+                    raise ArgumentsRequired(self.id + ' ' + methodName + '() requires symbols for self channel for spot markets')
+                subscriptionArgs.append('!' + channelName)
+            else:
+                subscriptionArgs.append('!' + channelName + '@arr')
+            messageHashes.append(self.get_message_hash(channelName, None, isBidAsk))
+        streamHash = channelName
+        if symbolsDefined:
+            streamHash = channelName + '::' + ','.join(symbols)
+        url = self.urls['api']['ws'][rawMarketType] + '/' + self.stream(rawMarketType, streamHash)
         requestId = self.request_id(url)
         request = {
             'method': 'SUBSCRIBE',
-            'params': wsParams,
+            'params': subscriptionArgs,
             'id': requestId,
         }
         subscribe = {
             'id': requestId,
         }
-        newTickers = await self.watch(url, messageHash, self.extend(request, params), messageHash, subscribe)
-        if self.newUpdates:
-            return newTickers
-        return self.filter_by_array(self.tickers, 'symbol', symbols)
+        result = await self.watch_multiple(url, messageHashes, self.deep_extend(request, params), subscriptionArgs, subscribe)
+        # for efficiency, we have two type of returned structure here - if symbols array was provided, then individual
+        # ticker dict comes in, otherwise all-tickers dict comes in
+        if not symbolsDefined:
+            return result
+        else:
+            newDict = {}
+            newDict[result['symbol']] = result
+            return newDict
 
     def parse_ws_ticker(self, message, marketType):
         #
@@ -1028,11 +1056,24 @@ class binance(ccxt.async_support.binance):
             'info': message,
         }, market)
 
-    def handle_ticker(self, client: Client, message):
+    def handle_bids_asks(self, client: Client, message):
+        #
+        # arrives one symbol dict or array of symbol dicts
+        #
+        #     {
+        #         "u": 7488717758,
+        #         "s": "BTCUSDT",
+        #         "b": "28621.74000000",
+        #         "B": "1.43278800",
+        #         "a": "28621.75000000",
+        #         "A": "2.52500800"
+        #     }
+        #
+        self.handle_tickers_and_bids_asks(client, message, 'bidasks')
+
+    def handle_tickers(self, client: Client, message):
         #
-        # 24hr rolling window ticker statistics for a single symbol
-        # These are NOT the statistics of the UTC day, but a 24hr rolling window for the previous 24hrs
-        # Update Speed 1000ms
+        # arrives one symbol dict or array of symbol dicts
         #
         #     {
         #         "e": "24hrTicker",      # event type
@@ -1060,34 +1101,14 @@ class binance(ccxt.async_support.binance):
         #         "n": 163222,            # total number of trades
         #     }
         #
-        event = self.safe_string(message, 'e', 'bookTicker')
-        if event == '24hrTicker':
-            event = 'ticker'
-        elif event == '24hrMiniTicker':
-            event = 'miniTicker'
-        wsMarketId = self.safe_string_lower(message, 's')
-        messageHash = wsMarketId + '@' + event
-        isSpot = ((client.url.find('/stream') > -1) or (client.url.find('/testnet.binance') > -1))
-        marketType = 'spot' if (isSpot) else 'contract'
-        result = self.parse_ws_ticker(message, marketType)
-        symbol = result['symbol']
-        self.tickers[symbol] = result
-        client.resolve(result, messageHash)
-        if event == 'bookTicker':
-            # watch bookTickers
-            client.resolve(result, '!' + 'bookTicker@arr')
-            messageHashes = self.find_message_hashes(client, 'tickers::')
-            for i in range(0, len(messageHashes)):
-                currentMessageHash = messageHashes[i]
-                parts = currentMessageHash.split('::')
-                symbolsString = parts[1]
-                symbols = symbolsString.split(',')
-                if self.in_array(symbol, symbols):
-                    client.resolve(result, currentMessageHash)
+        self.handle_tickers_and_bids_asks(client, message, 'tickers')
 
-    def handle_tickers(self, client: Client, message):
+    def handle_tickers_and_bids_asks(self, client: Client, message, methodType):
         isSpot = ((client.url.find('/stream') > -1) or (client.url.find('/testnet.binance') > -1))
         marketType = 'spot' if (isSpot) else 'contract'
+        isBidAsk = (methodType == 'bidasks')
+        channelName = None
+        resolvedMessageHashes = []
         rawTickers = []
         newTickers = {}
         if isinstance(message, list):
@@ -1096,22 +1117,34 @@ class binance(ccxt.async_support.binance):
             rawTickers.append(message)
         for i in range(0, len(rawTickers)):
             ticker = rawTickers[i]
-            result = self.parse_ws_ticker(ticker, marketType)
-            symbol = result['symbol']
-            self.tickers[symbol] = result
-            newTickers[symbol] = result
-        messageHashes = self.find_message_hashes(client, 'tickers::')
-        for i in range(0, len(messageHashes)):
-            messageHash = messageHashes[i]
-            parts = messageHash.split('::')
-            symbolsString = parts[1]
-            symbols = symbolsString.split(',')
-            tickers = self.filter_by_array(newTickers, 'symbol', symbols)
-            tickersSymbols = list(tickers.keys())
-            numTickers = len(tickersSymbols)
-            if numTickers > 0:
-                client.resolve(tickers, messageHash)
-        client.resolve(newTickers, 'tickers')
+            event = self.safe_string(ticker, 'e')
+            if isBidAsk:
+                event = 'bookTicker'  # in `handleMessage`, bookTicker doesn't have identifier, so manually set here
+            channelName = self.safe_string(self.options['tickerChannelsMap'], event, event)
+            if channelName is None:
+                continue
+            parsedTicker = self.parse_ws_ticker(ticker, marketType)
+            symbol = parsedTicker['symbol']
+            newTickers[symbol] = parsedTicker
+            if isBidAsk:
+                self.bidsasks[symbol] = parsedTicker
+            else:
+                self.tickers[symbol] = parsedTicker
+            messageHash = self.get_message_hash(channelName, symbol, isBidAsk)
+            resolvedMessageHashes.append(messageHash)
+            client.resolve(parsedTicker, messageHash)
+        # resolve batch endpoint
+        length = len(resolvedMessageHashes)
+        if length > 0:
+            batchMessageHash = self.get_message_hash(channelName, None, isBidAsk)
+            client.resolve(newTickers, batchMessageHash)
+
+    def get_message_hash(self, channelName: str, symbol: Str, isBidAsk: bool):
+        prefix = 'bidask' if isBidAsk else 'ticker'
+        if symbol is not None:
+            return prefix + ':' + channelName + '@' + symbol
+        else:
+            return prefix + 's' + ':' + channelName
 
     def sign_params(self, params={}):
         self.check_required_credentials()
@@ -2741,11 +2774,17 @@ class binance(ccxt.async_support.binance):
             'kline': self.handle_ohlcv,
             'markPrice_kline': self.handle_ohlcv,
             'indexPrice_kline': self.handle_ohlcv,
+            '1hTicker@arr': self.handle_tickers,
+            '4hTicker@arr': self.handle_tickers,
+            '1dTicker@arr': self.handle_tickers,
             '24hrTicker@arr': self.handle_tickers,
             '24hrMiniTicker@arr': self.handle_tickers,
-            '24hrTicker': self.handle_ticker,
-            '24hrMiniTicker': self.handle_ticker,
-            'bookTicker': self.handle_ticker,
+            '1hTicker': self.handle_tickers,
+            '4hTicker': self.handle_tickers,
+            '1dTicker': self.handle_tickers,
+            '24hrTicker': self.handle_tickers,
+            '24hrMiniTicker': self.handle_tickers,
+            'bookTicker': self.handle_bids_asks,  # there is no "bookTicker@arr" endpoint
             'outboundAccountPosition': self.handle_balance,
             'balanceUpdate': self.handle_balance,
             'ACCOUNT_UPDATE': self.handle_acount_update,
@@ -2773,8 +2812,7 @@ class binance(ccxt.async_support.binance):
             #         "A": "2.52500800"
             #     }
             #
-            if event is None:
-                self.handle_ticker(client, message)
-                self.handle_tickers(client, message)
+            if event is None and ('a' in message) and ('b' in message):
+                self.handle_bids_asks(client, message)
         else:
             method(client, message)

ccxt/pro/bitget.py

@@ -90,6 +90,7 @@ class bitget(ccxt.async_support.bitget):
                         '30015': AuthenticationError,  # {event: 'error', code: 30015, msg: 'Invalid sign'}
                         '30016': BadRequest,  # {event: 'error', code: 30016, msg: 'Param error'}
                     },
+                    'broad': {},
                 },
             },
         })

ccxt/pro/kucoin.py

@@ -824,17 +824,16 @@ class kucoin(ccxt.async_support.kucoin):
         return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
 
     def handle_my_trade(self, client: Client, message):
-        trades = self.myTrades
-        if trades is None:
+        if self.myTrades is None:
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
-            trades = ArrayCacheBySymbolById(limit)
-        data = self.safe_value(message, 'data')
+            self.myTrades = ArrayCacheBySymbolById(limit)
+        data = self.safe_dict(message, 'data')
         parsed = self.parse_ws_trade(data)
-        trades.append(parsed)
+        self.myTrades.append(parsed)
         messageHash = 'myTrades'
-        client.resolve(trades, messageHash)
+        client.resolve(self.myTrades, messageHash)
         symbolSpecificMessageHash = messageHash + ':' + parsed['symbol']
-        client.resolve(trades, symbolSpecificMessageHash)
+        client.resolve(self.myTrades, symbolSpecificMessageHash)
 
     def parse_ws_trade(self, trade, market=None):
         #

ccxt/pro/okx.py

@@ -459,7 +459,7 @@ class okx(ccxt.async_support.okx):
         """
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
         :param str[] symbols: unified array of symbols
-        :param int [limit]: the maximum amount of order book entries to return
+        :param int [limit]: 1,5, 400, 50(l2-tbt, vip4+) or 40000(vip5+) the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
         """
@@ -467,6 +467,17 @@ class okx(ccxt.async_support.okx):
         symbols = self.market_symbols(symbols)
         options = self.safe_value(self.options, 'watchOrderBook', {})
         depth = self.safe_string(options, 'depth', 'books')
+        if limit is not None:
+            if limit == 1:
+                depth = 'bbo-tbt'
+            elif limit > 1 and limit <= 5:
+                depth = 'books5'
+            elif limit == 400:
+                depth = 'books'
+            elif limit == 50:
+                depth = 'books50-l2-tbt'  # Make sure you have VIP4 and above
+            elif limit == 4000:
+                depth = 'books-l2-tbt'  # Make sure you have VIP5 and above
         if (depth == 'books-l2-tbt') or (depth == 'books50-l2-tbt'):
             await self.authenticate({'access': 'public'})
         topics = []

ccxt/probit.py

@@ -616,7 +616,7 @@ class probit(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        data = self.safe_value(response, 'data', [])
+        data = self.safe_list(response, 'data', [])
         return self.parse_tickers(data, symbols)
 
     def fetch_ticker(self, symbol: str, params={}) -> Ticker:
@@ -744,7 +744,7 @@ class probit(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        data = self.safe_value(response, 'data', [])
+        data = self.safe_list(response, 'data', [])
         return self.parse_trades(data, market, since, limit)
 
     def fetch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
@@ -793,7 +793,7 @@ class probit(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        data = self.safe_value(response, 'data', [])
+        data = self.safe_list(response, 'data', [])
         return self.parse_trades(data, market, since, limit)
 
     def parse_trade(self, trade, market: Market = None) -> Trade:
@@ -963,7 +963,7 @@ class probit(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        data = self.safe_value(response, 'data', [])
+        data = self.safe_list(response, 'data', [])
         return self.parse_ohlcvs(data, market, timeframe, since, limit)
 
     def parse_ohlcv(self, ohlcv, market: Market = None) -> list:
@@ -1007,7 +1007,7 @@ class probit(Exchange, ImplicitAPI):
             market = self.market(symbol)
             request['market_id'] = market['id']
         response = self.privateGetOpenOrder(self.extend(request, params))
-        data = self.safe_value(response, 'data')
+        data = self.safe_list(response, 'data')
         return self.parse_orders(data, market, since, limit)
 
     def fetch_closed_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
@@ -1035,7 +1035,7 @@ class probit(Exchange, ImplicitAPI):
         if limit:
             request['limit'] = limit
         response = self.privateGetOrderHistory(self.extend(request, params))
-        data = self.safe_value(response, 'data')
+        data = self.safe_list(response, 'data')
         return self.parse_orders(data, market, since, limit)
 
     def fetch_order(self, id: str, symbol: Str = None, params={}):
@@ -1061,7 +1061,7 @@ class probit(Exchange, ImplicitAPI):
         query = self.omit(params, ['clientOrderId', 'client_order_id'])
         response = self.privateGetOrder(self.extend(request, query))
         data = self.safe_value(response, 'data', [])
-        order = self.safe_value(data, 0)
+        order = self.safe_dict(data, 0)
         return self.parse_order(order, market)
 
     def parse_order_status(self, status):
@@ -1242,7 +1242,7 @@ class probit(Exchange, ImplicitAPI):
             'order_id': id,
         }
         response = self.privatePostCancelOrder(self.extend(request, params))
-        data = self.safe_value(response, 'data')
+        data = self.safe_dict(response, 'data')
         return self.parse_order(data)
 
     def parse_deposit_address(self, depositAddress, currency: Currency = None):
@@ -1328,7 +1328,7 @@ class probit(Exchange, ImplicitAPI):
                 currencyIds.append(currency['id'])
             request['currency_id'] = ','.join(codes)
         response = self.privateGetDepositAddress(self.extend(request, params))
-        data = self.safe_value(response, 'data', [])
+        data = self.safe_list(response, 'data', [])
         return self.parse_deposit_addresses(data, codes)
 
     def withdraw(self, code: str, amount: float, address, tag=None, params={}):
@@ -1371,7 +1371,7 @@ class probit(Exchange, ImplicitAPI):
             request['platform_id'] = network
             params = self.omit(params, 'network')
         response = self.privatePostWithdrawal(self.extend(request, params))
-        data = self.safe_value(response, 'data')
+        data = self.safe_dict(response, 'data')
         return self.parse_transaction(data, currency)
 
     def fetch_deposits(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
@@ -1605,7 +1605,7 @@ class probit(Exchange, ImplicitAPI):
         #     ]
         #  }
         #
-        data = self.safe_value(response, 'data')
+        data = self.safe_list(response, 'data')
         return self.parse_deposit_withdraw_fees(data, codes, 'id')
 
     def parse_deposit_withdraw_fee(self, fee, currency: Currency = None):

ccxt/timex.py

@@ -541,7 +541,7 @@ class timex(Exchange, ImplicitAPI):
         #         }
         #     ]
         #
-        ticker = self.safe_value(response, 0)
+        ticker = self.safe_dict(response, 0)
         return self.parse_ticker(ticker, market)
 
     def fetch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
@@ -779,7 +779,7 @@ class timex(Exchange, ImplicitAPI):
         #     }
         #
         orders = self.safe_value(response, 'orders', [])
-        order = self.safe_value(orders, 0, {})
+        order = self.safe_dict(orders, 0, {})
         return self.parse_order(order, market)
 
     def edit_order(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: Num = None, price: Num = None, params={}):
@@ -827,7 +827,7 @@ class timex(Exchange, ImplicitAPI):
             })
         orders = self.safe_value(response, 'changedOrders', [])
         firstOrder = self.safe_value(orders, 0, {})
-        order = self.safe_value(firstOrder, 'newOrder', {})
+        order = self.safe_dict(firstOrder, 'newOrder', {})
         return self.parse_order(order, market)
 
     def cancel_order(self, id: str, symbol: Str = None, params={}):
@@ -929,7 +929,7 @@ class timex(Exchange, ImplicitAPI):
         #     }
         #
         order = self.safe_value(response, 'order', {})
-        trades = self.safe_value(response, 'trades', [])
+        trades = self.safe_list(response, 'trades', [])
         return self.parse_order(self.extend(order, {'trades': trades}))
 
     def fetch_open_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
@@ -980,7 +980,7 @@ class timex(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        orders = self.safe_value(response, 'orders', [])
+        orders = self.safe_list(response, 'orders', [])
         return self.parse_orders(orders, market, since, limit)
 
     def fetch_closed_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
@@ -1035,7 +1035,7 @@ class timex(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        orders = self.safe_value(response, 'orders', [])
+        orders = self.safe_list(response, 'orders', [])
         return self.parse_orders(orders, market, since, limit)
 
     def fetch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
@@ -1093,7 +1093,7 @@ class timex(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        trades = self.safe_value(response, 'trades', [])
+        trades = self.safe_list(response, 'trades', [])
         return self.parse_trades(trades, market, since, limit)
 
     def parse_trading_fee(self, fee, market: Market = None):

ccxt/tokocrypto.py

@@ -1203,7 +1203,7 @@ class tokocrypto(Exchange, ImplicitAPI):
         }
         response = self.binanceGetTicker24hr(self.extend(request, params))
         if isinstance(response, list):
-            firstTicker = self.safe_value(response, 0, {})
+            firstTicker = self.safe_dict(response, 0, {})
             return self.parse_ticker(firstTicker, market)
         return self.parse_ticker(response, market)
 
@@ -1311,7 +1311,7 @@ class tokocrypto(Exchange, ImplicitAPI):
         #         [1591478640000,"0.02500800","0.02501100","0.02500300","0.02500800","154.14200000",1591478699999,"3.85405839",97,"5.32300000","0.13312641","0"],
         #     ]
         #
-        data = self.safe_value(response, 'data', response)
+        data = self.safe_list(response, 'data', response)
         return self.parse_ohlcvs(data, market, timeframe, since, limit)
 
     def fetch_balance(self, params={}) -> Balances:
@@ -1712,7 +1712,7 @@ class tokocrypto(Exchange, ImplicitAPI):
         #         "timestamp": 1662710994975
         #     }
         #
-        rawOrder = self.safe_value(response, 'data', {})
+        rawOrder = self.safe_dict(response, 'data', {})
         return self.parse_order(rawOrder, market)
 
     def fetch_order(self, id: str, symbol: Str = None, params={}):
@@ -1759,7 +1759,7 @@ class tokocrypto(Exchange, ImplicitAPI):
         #
         data = self.safe_value(response, 'data', {})
         list = self.safe_value(data, 'list', [])
-        rawOrder = self.safe_value(list, 0, {})
+        rawOrder = self.safe_dict(list, 0, {})
         return self.parse_order(rawOrder)
 
     def fetch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
@@ -1825,7 +1825,7 @@ class tokocrypto(Exchange, ImplicitAPI):
         #     }
         #
         data = self.safe_value(response, 'data', {})
-        orders = self.safe_value(data, 'list', [])
+        orders = self.safe_list(data, 'list', [])
         return self.parse_orders(orders, market, since, limit)
 
     def fetch_open_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
@@ -1894,7 +1894,7 @@ class tokocrypto(Exchange, ImplicitAPI):
         #         "timestamp": 1662710683634
         #     }
         #
-        rawOrder = self.safe_value(response, 'data', {})
+        rawOrder = self.safe_dict(response, 'data', {})
         return self.parse_order(rawOrder)
 
     def fetch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
@@ -1949,7 +1949,7 @@ class tokocrypto(Exchange, ImplicitAPI):
         #     }
         #
         data = self.safe_value(response, 'data', {})
-        trades = self.safe_value(data, 'list', [])
+        trades = self.safe_list(data, 'list', [])
         return self.parse_trades(trades, market, since, limit)
 
     def fetch_deposit_address(self, code: str, params={}):
@@ -2056,7 +2056,7 @@ class tokocrypto(Exchange, ImplicitAPI):
         #     }
         #
         data = self.safe_value(response, 'data', {})
-        deposits = self.safe_value(data, 'list', [])
+        deposits = self.safe_list(data, 'list', [])
         return self.parse_transactions(deposits, currency, since, limit)
 
     def fetch_withdrawals(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
@@ -2108,7 +2108,7 @@ class tokocrypto(Exchange, ImplicitAPI):
         #     }
         #
         data = self.safe_value(response, 'data', {})
-        withdrawals = self.safe_value(data, 'list', [])
+        withdrawals = self.safe_list(data, 'list', [])
         return self.parse_transactions(withdrawals, currency, since, limit)
 
     def parse_transaction_status_by_type(self, status, type=None):