ccxt 4.3.62__py2.py3-none-any.whl → 4.3.64__py2.py3-none-any.whl

ccxt/pro/gate.py

@@ -14,7 +14,7 @@ from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import NotSupported
-from ccxt.base.errors import InvalidNonce
+from ccxt.base.errors import ChecksumError
 from ccxt.base.precise import Precise
 
 
@@ -105,6 +105,7 @@ class gate(ccxt.async_support.gate):
                     'interval': '100ms',
                     'snapshotDelay': 10,  # how many deltas to cache before fetching a snapshot
                     'snapshotMaxRetries': 3,
+                    'checksum': True,
                 },
                 'watchBalance': {
                     'settle': 'usdt',  # or btc
@@ -460,10 +461,12 @@ class gate(ccxt.async_support.gate):
         elif nonce >= deltaStart - 1:
             self.handle_delta(storedOrderBook, delta)
         else:
-            error = InvalidNonce(self.id + ' orderbook update has a nonce bigger than u')
             del client.subscriptions[messageHash]
             del self.orderbooks[symbol]
-            client.reject(error, messageHash)
+            checksum = self.handle_option('watchOrderBook', 'checksum', True)
+            if checksum:
+                error = ChecksumError(self.id + ' ' + self.orderbook_checksum_message(symbol))
+                client.reject(error, messageHash)
         client.resolve(storedOrderBook, messageHash)
 
     def get_cache_index(self, orderBook, cache):
@@ -1192,7 +1195,7 @@ class gate(ccxt.async_support.gate):
             elif event == 'finish':
                 status = self.safe_string(parsed, 'status')
                 if status is None:
-                    left = self.safe_number(info, 'left')
+                    left = self.safe_integer(info, 'left')
                     parsed['status'] = 'closed' if (left == 0) else 'canceled'
             stored.append(parsed)
             symbol = parsed['symbol']

ccxt/pro/gemini.py

@@ -11,6 +11,7 @@ from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import NotSupported
+from ccxt.base.precise import Precise
 
 
 class gemini(ccxt.async_support.gemini):
@@ -445,9 +446,10 @@ class gemini(ccxt.async_support.gemini):
             entry = rawBidAskChanges[i]
             rawSide = self.safe_string(entry, 'side')
             price = self.safe_number(entry, 'price')
-            size = self.safe_number(entry, 'remaining')
-            if size == 0:
+            sizeString = self.safe_string(entry, 'remaining')
+            if Precise.string_eq(sizeString, '0'):
                 continue
+            size = self.parse_number(sizeString)
             if rawSide == 'bid':
                 currentBidAsk['bid'] = price
                 currentBidAsk['bidVolume'] = size

ccxt/pro/htx.py

@@ -16,6 +16,7 @@ from ccxt.base.errors import BadRequest
 from ccxt.base.errors import BadSymbol
 from ccxt.base.errors import NetworkError
 from ccxt.base.errors import InvalidNonce
+from ccxt.base.errors import ChecksumError
 
 
 class htx(ccxt.async_support.htx):
@@ -109,6 +110,7 @@ class htx(ccxt.async_support.htx):
                 'api': 'api',  # or api-aws for clients hosted on AWS
                 'watchOrderBook': {
                     'maxRetries': 3,
+                    'checksum': True,
                 },
                 'ws': {
                     'gunzip': True,
@@ -549,7 +551,9 @@ class htx(ccxt.async_support.htx):
             orderbook.reset(snapshot)
             orderbook['nonce'] = version
         if (prevSeqNum is not None) and prevSeqNum > orderbook['nonce']:
-            raise InvalidNonce(self.id + ' watchOrderBook() received a mesage out of order')
+            checksum = self.handle_option('watchOrderBook', 'checksum', True)
+            if checksum:
+                raise ChecksumError(self.id + ' ' + self.orderbook_checksum_message(symbol))
         spotConditon = market['spot'] and (prevSeqNum == orderbook['nonce'])
         nonSpotCondition = market['contract'] and (version - 1 == orderbook['nonce'])
         if spotConditon or nonSpotCondition:

ccxt/pro/independentreserve.py

@@ -9,7 +9,7 @@ from ccxt.base.types import Int, OrderBook, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import NotSupported
-from ccxt.base.errors import InvalidNonce
+from ccxt.base.errors import ChecksumError
 
 
 class independentreserve(ccxt.async_support.independentreserve):
@@ -33,7 +33,9 @@ class independentreserve(ccxt.async_support.independentreserve):
                 },
             },
             'options': {
-                'checksum': False,  # TODO: currently only working for snapshot
+                'watchOrderBook': {
+                    'checksum': True,  # TODO: currently only working for snapshot
+                },
             },
             'streaming': {
             },
@@ -196,7 +198,7 @@ class independentreserve(ccxt.async_support.independentreserve):
             self.handle_deltas(orderbook['bids'], bids)
             orderbook['timestamp'] = timestamp
             orderbook['datetime'] = self.iso8601(timestamp)
-        checksum = self.safe_bool(self.options, 'checksum', True)
+        checksum = self.handle_option('watchOrderBook', 'checksum', True)
         if checksum and receivedSnapshot:
             storedAsks = orderbook['asks']
             storedBids = orderbook['bids']
@@ -212,7 +214,7 @@ class independentreserve(ccxt.async_support.independentreserve):
             calculatedChecksum = self.crc32(payload, True)
             responseChecksum = self.safe_integer(orderBook, 'Crc32')
             if calculatedChecksum != responseChecksum:
-                error = InvalidNonce(self.id + ' invalid checksum')
+                error = ChecksumError(self.id + ' ' + self.orderbook_checksum_message(symbol))
                 del client.subscriptions[messageHash]
                 del self.orderbooks[symbol]
                 client.reject(error, messageHash)

ccxt/pro/kraken.py

@@ -5,7 +5,7 @@
 
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
-from ccxt.base.types import Int, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade
+from ccxt.base.types import Balances, Int, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -20,7 +20,7 @@ from ccxt.base.errors import OrderNotFound
 from ccxt.base.errors import NotSupported
 from ccxt.base.errors import RateLimitExceeded
 from ccxt.base.errors import ExchangeNotAvailable
-from ccxt.base.errors import InvalidNonce
+from ccxt.base.errors import ChecksumError
 from ccxt.base.precise import Precise
 
 
@@ -30,7 +30,7 @@ class kraken(ccxt.async_support.kraken):
         return self.deep_extend(super(kraken, self).describe(), {
             'has': {
                 'ws': True,
-                'watchBalance': False,  # no such type of subscription 2021-01-05
+                'watchBalance': True,
                 'watchMyTrades': True,
                 'watchOHLCV': True,
                 'watchOrderBook': True,
@@ -53,6 +53,7 @@ class kraken(ccxt.async_support.kraken):
                     'ws': {
                         'public': 'wss://ws.kraken.com',
                         'private': 'wss://ws-auth.kraken.com',
+                        'privateV2': 'wss://ws-auth.kraken.com/v2',
                         'beta': 'wss://beta-ws.kraken.com',
                         'beta-private': 'wss://beta-ws-auth.kraken.com',
                     },
@@ -66,7 +67,9 @@ class kraken(ccxt.async_support.kraken):
                 'OHLCVLimit': 1000,
                 'ordersLimit': 1000,
                 'symbolsByOrderId': {},
-                'checksum': True,
+                'watchOrderBook': {
+                    'checksum': True,
+                },
             },
             'exceptions': {
                 'ws': {
@@ -715,7 +718,7 @@ class kraken(ccxt.async_support.kraken):
                 example = self.safe_value(b, 0)
             # don't remove self line or I will poop on your face
             orderbook.limit()
-            checksum = self.safe_bool(self.options, 'checksum', True)
+            checksum = self.handle_option('watchOrderBook', 'checksum', True)
             if checksum:
                 priceString = self.safe_string(example, 0)
                 amountString = self.safe_string(example, 1)
@@ -734,7 +737,7 @@ class kraken(ccxt.async_support.kraken):
                 payload = ''.join(payloadArray)
                 localChecksum = self.crc32(payload, False)
                 if localChecksum != c:
-                    error = InvalidNonce(self.id + ' invalid checksum')
+                    error = ChecksumError(self.id + ' ' + self.orderbook_checksum_message(symbol))
                     del client.subscriptions[messageHash]
                     del self.orderbooks[symbol]
                     client.reject(error, messageHash)
@@ -1247,6 +1250,68 @@ class kraken(ccxt.async_support.kraken):
         url = self.urls['api']['ws']['public']
         return await self.watch_multiple(url, messageHashes, self.deep_extend(request, params), messageHashes, subscriptionArgs)
 
+    async def watch_balance(self, params={}) -> Balances:
+        """
+        watch balance and get the amount of funds available for trading or funds locked in orders
+        :see: https://docs.kraken.com/api/docs/websocket-v2/balances
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
+        """
+        await self.load_markets()
+        token = await self.authenticate()
+        messageHash = 'balances'
+        url = self.urls['api']['ws']['privateV2']
+        requestId = self.request_id()
+        subscribe: dict = {
+            'method': 'subscribe',
+            'req_id': requestId,
+            'params': {
+                'channel': 'balances',
+                'token': token,
+            },
+        }
+        request = self.deep_extend(subscribe, params)
+        return await self.watch(url, messageHash, request, messageHash)
+
+    def handle_balance(self, client: Client, message):
+        #
+        #     {
+        #         "channel": "balances",
+        #         "data": [
+        #             {
+        #                 "asset": "BTC",
+        #                 "asset_class": "currency",
+        #                 "balance": 1.2,
+        #                 "wallets": [
+        #                     {
+        #                         "type": "spot",
+        #                         "id": "main",
+        #                         "balance": 1.2
+        #                     }
+        #                 ]
+        #             }
+        #         ],
+        #         "type": "snapshot",
+        #         "sequence": 1
+        #     }
+        #
+        data = self.safe_list(message, 'data', [])
+        result: dict = {'info': message}
+        for i in range(0, len(data)):
+            currencyId = self.safe_string(data[i], 'asset')
+            code = self.safe_currency_code(currencyId)
+            account = self.account()
+            eq = self.safe_string(data[i], 'balance')
+            account['total'] = eq
+            result[code] = account
+        type = 'spot'
+        balance = self.safe_balance(result)
+        oldBalance = self.safe_value(self.balance, type, {})
+        newBalance = self.deep_extend(oldBalance, balance)
+        self.balance[type] = self.safe_balance(newBalance)
+        channel = self.safe_string(message, 'channel')
+        client.resolve(self.balance[type], channel)
+
     def get_message_hash(self, unifiedElementName: str, subChannelName: Str = None, symbol: Str = None):
         # unifiedElementName can be : orderbook, trade, ticker, bidask ...
         # subChannelName only applies to channel that needs specific variation(i.e. depth_50, depth_100..) to be selected
@@ -1340,6 +1405,14 @@ class kraken(ccxt.async_support.kraken):
             if method is not None:
                 method(client, message, subscription)
         else:
+            channel = self.safe_string(message, 'channel')
+            if channel is not None:
+                methods: dict = {
+                    'balances': self.handle_balance,
+                }
+                method = self.safe_value(methods, channel)
+                if method is not None:
+                    method(client, message)
             if self.handle_error_message(client, message):
                 event = self.safe_string(message, 'event')
                 methods: dict = {

ccxt/pro/okx.py

@@ -13,7 +13,7 @@ from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
-from ccxt.base.errors import InvalidNonce
+from ccxt.base.errors import ChecksumError
 
 
 class okx(ccxt.async_support.okx):
@@ -56,6 +56,7 @@ class okx(ccxt.async_support.okx):
             },
             'options': {
                 'watchOrderBook': {
+                    'checksum': True,
                     #
                     # bbo-tbt
                     # 1. Newly added channel that sends tick-by-tick Level 1 data
@@ -103,7 +104,6 @@ class okx(ccxt.async_support.okx):
                 'ws': {
                     # 'inflate': True,
                 },
-                'checksum': True,
             },
             'streaming': {
                 # okex does not support built-in ws protocol-level ping-pong
@@ -861,7 +861,7 @@ class okx(ccxt.async_support.okx):
         self.handle_deltas(storedBids, bids)
         marketId = self.safe_string(message, 'instId')
         symbol = self.safe_symbol(marketId)
-        checksum = self.safe_bool(self.options, 'checksum', True)
+        checksum = self.handle_option('watchOrderBook', 'checksum', True)
         if checksum:
             asksLength = len(storedAsks)
             bidsLength = len(storedBids)
@@ -877,7 +877,7 @@ class okx(ccxt.async_support.okx):
             responseChecksum = self.safe_integer(message, 'checksum')
             localChecksum = self.crc32(payload, True)
             if responseChecksum != localChecksum:
-                error = InvalidNonce(self.id + ' invalid checksum')
+                error = ChecksumError(self.id + ' ' + self.orderbook_checksum_message(symbol))
                 del client.subscriptions[messageHash]
                 del self.orderbooks[symbol]
                 client.reject(error, messageHash)
@@ -1645,7 +1645,7 @@ class okx(ccxt.async_support.okx):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
-        idsLength = len(ids)
+        idsLength: number = len(ids)
         if idsLength > 20:
             raise BadRequest(self.id + ' cancelOrdersWs() accepts up to 20 ids at a time')
         if symbol is None:

ccxt/pro/onetrading.py

@@ -10,6 +10,7 @@ from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import NotSupported
+from ccxt.base.precise import Precise
 
 
 class onetrading(ccxt.async_support.onetrading):
@@ -934,9 +935,9 @@ class onetrading(ccxt.async_support.onetrading):
             previousOrderArray = self.filter_by_array(self.orders, 'id', orderId, False)
             previousOrder = self.safe_value(previousOrderArray, 0, {})
             symbol = previousOrder['symbol']
-            filled = self.safe_number(update, 'filled_amount')
+            filled = self.safe_string(update, 'filled_amount')
             status = self.parse_ws_order_status(updateType)
-            if updateType == 'ORDER_CLOSED' and filled == 0:
+            if updateType == 'ORDER_CLOSED' and Precise.string_eq(filled, '0'):
                 status = 'canceled'
             orderObject: dict = {
                 'id': orderId,

ccxt/pro/oxfun.py

@@ -854,7 +854,7 @@ class oxfun(ccxt.async_support.oxfun):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
-        idsLength = len(ids)
+        idsLength: number = len(ids)
         if idsLength > 20:
             raise BadRequest(self.id + ' cancelOrdersWs() accepts up to 20 ids at a time')
         if symbol is None:

ccxt/pro/poloniexfutures.py

@@ -10,7 +10,7 @@ from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import BadRequest
-from ccxt.base.errors import InvalidNonce
+from ccxt.base.errors import ChecksumError
 
 
 class poloniexfutures(ccxt.async_support.poloniexfutures):
@@ -57,6 +57,7 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
                     'method': '/contractMarket/level2',  # can also be '/contractMarket/level3v2'
                     'snapshotDelay': 5,
                     'snapshotMaxRetries': 3,
+                    'checksum': True,
                 },
                 'streamLimit': 5,  # called tunnels by poloniexfutures docs
                 'streamBySubscriptionsHash': {},
@@ -822,7 +823,9 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
         if nonce > sequence:
             return
         if nonce != lastSequence:
-            raise InvalidNonce(self.id + ' watchOrderBook received an out-of-order nonce')
+            checksum = self.handle_option('watchOrderBook', 'checksum', True)
+            if checksum:
+                raise ChecksumError(self.id + ' ' + self.orderbook_checksum_message(''))
         changes = self.safe_list(delta, 'changes')
         for i in range(0, len(changes)):
             change = changes[i]

ccxt/pro/vertex.py

@@ -798,9 +798,10 @@ class vertex(ccxt.async_support.vertex):
         #
         marketId = self.safe_string(order, 'product_id')
         timestamp = self.parse_to_int(Precise.string_div(self.safe_string(order, 'timestamp'), '1000000'))
-        remaining = self.parse_to_numeric(self.convertFromX18(self.safe_string(order, 'amount')))
+        remainingString = self.convertFromX18(self.safe_string(order, 'amount'))
+        remaining = self.parse_to_numeric(remainingString)
         status = self.parse_ws_order_status(self.safe_string(order, 'reason'))
-        if remaining == 0 and status == 'open':
+        if Precise.string_eq(remainingString, '0') and status == 'open':
             status = 'closed'
         market = self.safe_market(marketId, market)
         symbol = market['symbol']

ccxt/pro/woo.py

@@ -638,9 +638,10 @@ class woo(ccxt.async_support.woo):
             'cost': self.safe_string(order, 'totalFee'),
             'currency': self.safe_string(order, 'feeAsset'),
         }
+        priceString = self.safe_string(order, 'price')
         price = self.safe_number(order, 'price')
         avgPrice = self.safe_number(order, 'avgPrice')
-        if (price == 0) and (avgPrice is not None):
+        if Precise.string_eq(priceString, '0') and (avgPrice is not None):
             price = avgPrice
         amount = self.safe_float(order, 'quantity')
         side = self.safe_string_lower(order, 'side')

ccxt/pro/woofipro.py

@@ -363,7 +363,7 @@ class woofipro(ccxt.async_support.woofipro):
         :param int [since]: the earliest time in ms to fetch trades for
         :param int [limit]: the maximum number of trade structures to retrieve
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict[]: a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
         """
         await self.load_markets()
         market = self.market(symbol)
@@ -686,9 +686,10 @@ class woofipro(ccxt.async_support.woofipro):
             'cost': self.safe_string(order, 'totalFee'),
             'currency': self.safe_string(order, 'feeAsset'),
         }
+        priceString = self.safe_string(order, 'price')
         price = self.safe_number(order, 'price')
         avgPrice = self.safe_number(order, 'avgPrice')
-        if (price == 0) and (avgPrice is not None):
+        if Precise.string_eq(priceString, '0') and (avgPrice is not None):
             price = avgPrice
         amount = self.safe_string(order, 'quantity')
         side = self.safe_string_lower(order, 'side')

ccxt/test/tests_async.py

@@ -818,7 +818,7 @@ class testMainClass(baseMainTestClass):
                 new_input.append(current)
         return new_input
 
-    async def test_method_statically(self, exchange, method, data, type, skip_keys):
+    async def test_request_statically(self, exchange, method, data, type, skip_keys):
         output = None
         request_url = None
         try:
@@ -850,7 +850,7 @@ class testMainClass(baseMainTestClass):
                 unified_result_sync = call_exchange_method_dynamically_sync(exchange, method, self.sanitize_data_input(data['input']))
                 self.assert_static_response_output(mocked_exchange, skip_keys, unified_result_sync, expected_result)
         except Exception as e:
-            self.request_tests_failed = True
+            self.response_tests_failed = True
             error_message = '[' + self.lang + '][STATIC_RESPONSE_TEST_FAILURE]' + '[' + self.exchange_hint(exchange) + ']' + '[' + method + ']' + '[' + data['description'] + ']' + str(e)
             dump('[TEST_FAILURE]' + error_message)
         set_fetch_response(exchange, None)  # reset state
@@ -929,7 +929,7 @@ class testMainClass(baseMainTestClass):
                     continue
                 type = exchange.safe_string(exchange_data, 'outputType')
                 skip_keys = exchange.safe_value(exchange_data, 'skipKeys', [])
-                await self.test_method_statically(exchange, method, result, type, skip_keys)
+                await self.test_request_statically(exchange, method, result, type, skip_keys)
                 # reset options
                 # exchange.options = exchange.deepExtend (oldExchangeOptions, {});
                 exchange.extend_exchange_options(exchange.deep_extend(old_exchange_options, {}))

ccxt/test/tests_helpers.py

@@ -73,7 +73,6 @@ parser.add_argument('--requestTests', action='store_true', help='run response te
 parser.add_argument('--sync', action='store_true', help='is sync')
 parser.add_argument('--baseTests', action='store_true', help='is base tests')
 parser.add_argument('--exchangeTests', action='store_true', help='is exchange tests')
-parser.add_argument('--nonce', type=int, help='integer')
 parser.add_argument('exchange', type=str, help='exchange id in lowercase', nargs='?')
 parser.add_argument('symbol', type=str, help='symbol in uppercase', nargs='?')
 parser.parse_args(namespace=argv)
@@ -279,6 +278,7 @@ def set_fetch_response(exchange: ccxt.Exchange, data):
     return exchange
 
 
+argvExchange = argv.exchange
 argvSymbol = argv.symbol if argv.symbol and '/' in argv.symbol else None
 # in python, we check it through "symbol" arg (as opposed to JS/PHP) because argvs were already built above
 argvMethod = argv.symbol if argv.symbol and '()' in argv.symbol else None

ccxt/test/tests_init.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-from tests_helpers import get_cli_arg_value, is_synchronous, argv, argvSymbol, argvMethod
+from tests_helpers import get_cli_arg_value, is_synchronous, argvExchange, argvSymbol, argvMethod
 
 try:
     import asyncio
@@ -29,7 +29,7 @@ if (isBaseTests):
 # ###### exchange tests #######
 if (is_synchronous):
     from tests_sync import testMainClass as testMainClassSync
-    testMainClassSync().init(argv.exchange, argvSymbol, argvMethod)
+    testMainClassSync().init(argvExchange, argvSymbol, argvMethod)
 else:
     from tests_async import testMainClass as testMainClassAsync
-    asyncio.run(testMainClassAsync().init(argv.exchange, argvSymbol, argvMethod))
+    asyncio.run(testMainClassAsync().init(argvExchange, argvSymbol, argvMethod))

ccxt/test/tests_sync.py

@@ -815,7 +815,7 @@ class testMainClass(baseMainTestClass):
                 new_input.append(current)
         return new_input
 
-    def test_method_statically(self, exchange, method, data, type, skip_keys):
+    def test_request_statically(self, exchange, method, data, type, skip_keys):
         output = None
         request_url = None
         try:
@@ -847,7 +847,7 @@ class testMainClass(baseMainTestClass):
                 unified_result_sync = call_exchange_method_dynamically_sync(exchange, method, self.sanitize_data_input(data['input']))
                 self.assert_static_response_output(mocked_exchange, skip_keys, unified_result_sync, expected_result)
         except Exception as e:
-            self.request_tests_failed = True
+            self.response_tests_failed = True
             error_message = '[' + self.lang + '][STATIC_RESPONSE_TEST_FAILURE]' + '[' + self.exchange_hint(exchange) + ']' + '[' + method + ']' + '[' + data['description'] + ']' + str(e)
             dump('[TEST_FAILURE]' + error_message)
         set_fetch_response(exchange, None)  # reset state
@@ -926,7 +926,7 @@ class testMainClass(baseMainTestClass):
                     continue
                 type = exchange.safe_string(exchange_data, 'outputType')
                 skip_keys = exchange.safe_value(exchange_data, 'skipKeys', [])
-                self.test_method_statically(exchange, method, result, type, skip_keys)
+                self.test_request_statically(exchange, method, result, type, skip_keys)
                 # reset options
                 # exchange.options = exchange.deepExtend (oldExchangeOptions, {});
                 exchange.extend_exchange_options(exchange.deep_extend(old_exchange_options, {}))

ccxt/whitebit.py

@@ -2404,7 +2404,7 @@ class whitebit(Exchange, ImplicitAPI):
         records = self.safe_list(response, 'records')
         return self.parse_transactions(records, currency, since, limit)
 
-    def is_fiat(self, currency):
+    def is_fiat(self, currency: str):
         fiatCurrencies = self.safe_value(self.options, 'fiatCurrencies', [])
         return self.in_array(currency, fiatCurrencies)