ccxt 4.4.13__py2.py3-none-any.whl → 4.4.15__py2.py3-none-any.whl

ccxt/onetrading.py

@@ -128,8 +128,8 @@ class onetrading(Exchange, ImplicitAPI):
             'urls': {
                 'logo': 'https://github.com/ccxt/ccxt/assets/43336371/bdbc26fd-02f2-4ca7-9f1e-17333690bb1c',
                 'api': {
-                    'public': 'https://api.onetrading.com/public',
-                    'private': 'https://api.onetrading.com/public',
+                    'public': 'https://api.onetrading.com/fast',
+                    'private': 'https://api.onetrading.com/fast',
                 },
                 'www': 'https://onetrading.com/',
                 'doc': [

ccxt/poloniexfutures.py

@@ -48,6 +48,8 @@ class poloniexfutures(Exchange, ImplicitAPI):
                 'fetchDepositAddress': False,
                 'fetchDepositAddresses': False,
                 'fetchDepositAddressesByNetwork': False,
+                'fetchFundingInterval': True,
+                'fetchFundingIntervals': False,
                 'fetchFundingRate': True,
                 'fetchFundingRateHistory': False,
                 'fetchL3OrderBook': True,
@@ -1550,28 +1552,50 @@ class poloniexfutures(Exchange, ImplicitAPI):
         #        "predictedValue": 0.00375
         #    }
         #
-        data = self.safe_value(response, 'data')
+        data = self.safe_dict(response, 'data', {})
+        return self.parse_funding_rate(data, market)
+
+    def fetch_funding_interval(self, symbol: str, params={}) -> FundingRate:
+        """
+        fetch the current funding rate interval
+        :see: https://api-docs.poloniex.com/futures/api/futures-index#get-premium-index
+        :param str symbol: unified market symbol
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `funding rate structure <https://docs.ccxt.com/#/?id=funding-rate-structure>`
+        """
+        return self.fetch_funding_rate(symbol, params)
+
+    def parse_funding_rate(self, data, market: Market = None) -> FundingRate:
+        #
+        #     {
+        #         "symbol": ".ETHUSDTMFPI8H",
+        #         "granularity": 28800000,
+        #         "timePoint": 1637380800000,
+        #         "value": 0.0001,
+        #         "predictedValue": 0.0001,
+        #     }
+        #
         fundingTimestamp = self.safe_integer(data, 'timePoint')
-        # the website displayes the previous funding rate as "funding rate"
+        marketId = self.safe_string(data, 'symbol')
         return {
             'info': data,
-            'symbol': market['symbol'],
+            'symbol': self.safe_symbol(marketId, market, None, 'contract'),
             'markPrice': None,
             'indexPrice': None,
             'interestRate': None,
             'estimatedSettlePrice': None,
             'timestamp': None,
             'datetime': None,
-            'fundingRate': self.safe_number(data, 'predictedValue'),
-            'fundingTimestamp': None,
-            'fundingDatetime': None,
-            'nextFundingRate': None,
+            'fundingRate': self.safe_number(data, 'value'),
+            'fundingTimestamp': fundingTimestamp,
+            'fundingDatetime': self.iso8601(fundingTimestamp),
+            'nextFundingRate': self.safe_number(data, 'predictedValue'),
             'nextFundingTimestamp': None,
             'nextFundingDatetime': None,
-            'previousFundingRate': self.safe_number(data, 'value'),
-            'previousFundingTimestamp': fundingTimestamp,
-            'previousFundingDatetime': self.iso8601(fundingTimestamp),
-            'interval': self.parse_funding_interval(self.safe_string(data, 'interval')),
+            'previousFundingRate': None,
+            'previousFundingTimestamp': None,
+            'previousFundingDatetime': None,
+            'interval': self.parse_funding_interval(self.safe_string(data, 'granularity')),
         }
 
     def parse_funding_interval(self, interval):

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.13'
+__version__ = '4.4.15'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/binance.py

@@ -243,7 +243,7 @@ class binance(ccxt.async_support.binance):
         type = None
         type, params = self.handle_market_type_and_params('watchLiquidationsForSymbols', firstMarket, params)
         if type == 'spot':
-            raise BadRequest(self.id + 'watchLiquidationsForSymbols is not supported for swap symbols')
+            raise BadRequest(self.id + 'watchLiquidationsForSymbols is not supported for spot symbols')
         subType = None
         subType, params = self.handle_sub_type_and_params('watchLiquidationsForSymbols', firstMarket, params)
         if self.isLinear(type, subType):

ccxt/pro/okx.py

@@ -25,6 +25,8 @@ class okx(ccxt.async_support.okx):
             'has': {
                 'ws': True,
                 'watchTicker': True,
+                'watchMarkPrice': True,
+                'watchMarkPrices': True,
                 'watchTickers': True,
                 'watchBidsAsks': True,
                 'watchOrderBook': True,
@@ -408,6 +410,41 @@ class okx(ccxt.async_support.okx):
             return newTickers
         return self.filter_by_array(self.tickers, 'symbol', symbols)
 
+    async def watch_mark_price(self, symbol: str, params={}) -> Ticker:
+        """
+        :see: https://www.okx.com/docs-v5/en/#public-data-websocket-mark-price-channel
+        watches a mark price
+        :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.channel]: the channel to subscribe to, tickers by default. Can be tickers, sprd-tickers, index-tickers, block-tickers
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        channel = None
+        channel, params = self.handle_option_and_params(params, 'watchMarkPrice', 'channel', 'mark-price')
+        params['channel'] = channel
+        market = self.market(symbol)
+        symbol = market['symbol']
+        ticker = await self.watch_mark_prices([symbol], params)
+        return ticker[symbol]
+
+    async def watch_mark_prices(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        :see: https://www.okx.com/docs-v5/en/#public-data-websocket-mark-price-channel
+        watches mark prices
+        :param str[] [symbols]: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.channel]: the channel to subscribe to, tickers by default. Can be tickers, sprd-tickers, index-tickers, block-tickers
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        channel = None
+        channel, params = self.handle_option_and_params(params, 'watchMarkPrices', 'channel', 'mark-price')
+        newTickers = await self.subscribe_multiple('public', channel, symbols, params)
+        if self.newUpdates:
+            return newTickers
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
+
     async def un_watch_tickers(self, symbols: Strings = None, params={}) -> Any:
         """
         :see: https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-tickers-channel
@@ -2157,6 +2194,7 @@ class okx(ccxt.async_support.okx):
                 'books50-l2-tbt': self.handle_order_book,  # only users who're VIP4 and above can subscribe, identity verification required before subscription
                 'books-l2-tbt': self.handle_order_book,  # only users who're VIP5 and above can subscribe, identity verification required before subscription
                 'tickers': self.handle_ticker,
+                'mark-price': self.handle_ticker,
                 'positions': self.handle_positions,
                 'index-tickers': self.handle_ticker,
                 'sprd-tickers': self.handle_ticker,

ccxt/pro/upbit.py

@@ -5,7 +5,7 @@
 
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById
-from ccxt.base.types import Balances, Int, Order, OrderBook, Str, Ticker, Trade
+from ccxt.base.types import Balances, Int, Order, OrderBook, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 
@@ -18,6 +18,7 @@ class upbit(ccxt.async_support.upbit):
                 'ws': True,
                 'watchOrderBook': True,
                 'watchTicker': True,
+                'watchTickers': True,
                 'watchTrades': True,
                 'watchTradesForSymbols': True,
                 'watchOrders': True,
@@ -60,6 +61,31 @@ class upbit(ccxt.async_support.upbit):
         messageHash = channel + ':' + marketId
         return await self.watch(url, messageHash, request, messageHash)
 
+    async def watch_public_multiple(self, symbols: Strings, channel, params={}):
+        await self.load_markets()
+        if symbols is None:
+            symbols = self.symbols
+        symbols = self.market_symbols(symbols)
+        marketIds = self.market_ids(symbols)
+        url = self.implode_params(self.urls['api']['ws'], {
+            'hostname': self.hostname,
+        })
+        messageHashes = []
+        for i in range(0, len(marketIds)):
+            messageHashes.append(channel + ':' + marketIds[i])
+        request = [
+            {
+                'ticket': self.uuid(),
+            },
+            {
+                'type': channel,
+                'codes': marketIds,
+                # 'isOnlySnapshot': False,
+                # 'isOnlyRealtime': False,
+            },
+        ]
+        return await self.watch_multiple(url, messageHashes, request, messageHashes)
+
     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
@@ -70,6 +96,21 @@ class upbit(ccxt.async_support.upbit):
         """
         return await self.watch_public(symbol, 'ticker')
 
+    async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+        :see: https://global-docs.upbit.com/reference/websocket-ticker
+        :param str symbol: 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>`
+        """
+        newTickers = await self.watch_public_multiple(symbols, 'ticker')
+        if self.newUpdates:
+            tickers: dict = {}
+            tickers[newTickers['symbol']] = newTickers
+            return tickers
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
+
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol

ccxt/pro/vertex.py

@@ -53,6 +53,9 @@ class vertex(ccxt.async_support.vertex):
                     'fetchPositionsSnapshot': True,  # or False
                     'awaitPositionsSnapshot': True,  # whether to wait for the positions snapshot before providing updates
                 },
+                'ws': {
+                    'inflate': True,
+                },
             },
             'streaming': {
                 # 'ping': self.ping,
@@ -81,6 +84,14 @@ class vertex(ccxt.async_support.vertex):
             'id': requestId,
         }
         request = self.extend(subscribe, message)
+        wsOptions = {
+            'headers': {
+                'Sec-WebSocket-Extensions': 'permessage-deflate',
+            },
+        }
+        self.options['ws'] = {
+            'options': wsOptions,
+        }
         return await self.watch(url, messageHash, request, messageHash, subscribe)
 
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:

ccxt/test/tests_async.py

@@ -3,10 +3,9 @@
 import asyncio
 
 
-from tests_helpers import AuthenticationError, NotSupported, InvalidProxySettings, ExchangeNotAvailable, OperationFailed, OnMaintenance, get_cli_arg_value, ENV_VARS, NEW_LINE, LANG, EXT, ROOT_DIR, PROXY_TEST_FILE_NAME, IS_SYNCHRONOUS, dump, json_parse, json_stringify, convert_ascii, io_file_exists, io_file_read, io_dir_read, call_method, call_method_sync, call_exchange_method_dynamically, call_exchange_method_dynamically_sync, get_root_exception, exception_message, exit_script, get_exchange_prop, set_exchange_prop, init_exchange, get_test_files_sync, get_test_files, set_fetch_response, is_null_value, close  # noqa: F401
+from tests_helpers import AuthenticationError, NotSupported, InvalidProxySettings, ExchangeNotAvailable, OperationFailed, OnMaintenance, get_cli_arg_value, get_root_dir, is_sync, dump, json_parse, json_stringify, convert_ascii, io_file_exists, io_file_read, io_dir_read, call_method, call_method_sync, call_exchange_method_dynamically, call_exchange_method_dynamically_sync, get_root_exception, exception_message, exit_script, get_exchange_prop, set_exchange_prop, init_exchange, get_test_files_sync, get_test_files, set_fetch_response, is_null_value, close, get_env_vars, get_lang, get_ext  # noqa: F401
 
 class testMainClass:
-    is_synchronous = IS_SYNCHRONOUS
     id_tests = False
     request_tests_failed = False
     response_tests_failed = False
@@ -21,20 +20,17 @@ class testMainClass:
     private_test_only = False
     load_keys = False
     sandbox = False
-    proxy_test_file_name = PROXY_TEST_FILE_NAME
     only_specific_tests = []
     skipped_settings_for_exchange = {}
     skipped_methods = {}
     checked_public_tests = {}
     test_files = {}
     public_tests = {}
-    new_line = NEW_LINE
-    root_dir = ROOT_DIR
-    env_vars = ENV_VARS
-    ext = EXT
-    lang = LANG
+    ext = ''
+    lang = ''
+    proxy_test_file_name = 'proxies'
 
-    def parse_cli_args(self):
+    def parse_cli_args_and_props(self):
         self.response_tests = get_cli_arg_value('--responseTests')
         self.id_tests = get_cli_arg_value('--idTests')
         self.request_tests = get_cli_arg_value('--requestTests')
@@ -46,9 +42,11 @@ class testMainClass:
         self.sandbox = get_cli_arg_value('--sandbox')
         self.load_keys = get_cli_arg_value('--loadKeys')
         self.ws_tests = get_cli_arg_value('--ws')
+        self.lang = get_lang()
+        self.ext = get_ext()
 
     async def init(self, exchange_id, symbol_argv, method_argv):
-        self.parse_cli_args()
+        self.parse_cli_args_and_props()
         if self.request_tests and self.response_tests:
             await self.run_static_request_tests(exchange_id, symbol_argv)
             await self.run_static_response_tests(exchange_id, symbol_argv)
@@ -62,12 +60,13 @@ class testMainClass:
         if self.id_tests:
             await self.run_broker_id_tests()
             return
-        dump(self.new_line + '' + self.new_line + '' + '[INFO] TESTING ', self.ext, {
+        new_line = '\n'
+        dump(new_line + '' + new_line + '' + '[INFO] TESTING ', self.ext, {
             'exchange': exchange_id,
             'symbol': symbol_argv,
             'method': method_argv,
             'isWs': self.ws_tests,
-        }, self.new_line)
+        }, new_line)
         exchange_args = {
             'verbose': self.verbose,
             'debug': self.debug,
@@ -100,7 +99,7 @@ class testMainClass:
     async def import_files(self, exchange):
         properties = list(exchange.has.keys())
         properties.append('loadMarkets')
-        if self.is_synchronous:
+        if is_sync():
             self.test_files = get_test_files_sync(properties, self.ws_tests)
         else:
             self.test_files = await get_test_files(properties, self.ws_tests)
@@ -115,14 +114,15 @@ class testMainClass:
             if is_required and get_exchange_prop(exchange, credential) is None:
                 full_key = exchange_id + '_' + credential
                 credential_env_name = full_key.upper()  # example: KRAKEN_APIKEY
-                credential_value = self.env_vars[credential_env_name] if (credential_env_name in self.env_vars) else None
+                env_vars = get_env_vars()
+                credential_value = env_vars[credential_env_name] if (credential_env_name in env_vars) else None
                 if credential_value:
                     set_exchange_prop(exchange, credential, credential_value)
 
     def expand_settings(self, exchange):
         exchange_id = exchange.id
-        keys_global = self.root_dir + 'keys.json'
-        keys_local = self.root_dir + 'keys.local.json'
+        keys_global = get_root_dir() + 'keys.json'
+        keys_local = get_root_dir() + 'keys.local.json'
         keys_global_exists = io_file_exists(keys_global)
         keys_local_exists = io_file_exists(keys_local)
         global_settings = io_file_read(keys_global) if keys_global_exists else {}
@@ -145,7 +145,7 @@ class testMainClass:
         if self.load_keys:
             self.load_credentials_from_env(exchange)
         # skipped tests
-        skipped_file = self.root_dir + 'skip-tests.json'
+        skipped_file = get_root_dir() + 'skip-tests.json'
         skipped_settings = io_file_read(skipped_file)
         self.skipped_settings_for_exchange = exchange.safe_value(skipped_settings, exchange_id, {})
         skipped_settings_for_exchange = self.skipped_settings_for_exchange
@@ -206,7 +206,7 @@ class testMainClass:
         if self.info:
             args_stringified = '(' + exchange.json(args) + ')'  # args.join() breaks when we provide a list of symbols or multidimensional array; "args.toString()" breaks bcz of "array to string conversion"
             dump(self.add_padding('[INFO] TESTING', 25), name, method_name, args_stringified)
-        if self.is_synchronous:
+        if is_sync():
             call_method_sync(self.test_files, method_name, exchange, skipped_properties_for_method, args)
         else:
             await call_method(self.test_files, method_name, exchange, skipped_properties_for_method, args)
@@ -589,7 +589,7 @@ class testMainClass:
         # these tests should be synchronously executed, because of conflicting nature of proxy settings
         proxy_test_name = self.proxy_test_file_name
         # todo: temporary skip for sync py
-        if self.ext == 'py' and self.is_synchronous:
+        if self.ext == 'py' and is_sync():
             return
         # try proxy several times
         max_retries = 3
@@ -617,7 +617,7 @@ class testMainClass:
         try:
             result = await self.load_exchange(exchange)
             if not result:
-                if not self.is_synchronous:
+                if not is_sync():
                     await close(exchange)
                 return
             # if (exchange.id === 'binance') {
@@ -625,10 +625,10 @@ class testMainClass:
             #     # await this.testProxies (exchange);
             # }
             await self.test_exchange(exchange, symbol)
-            if not self.is_synchronous:
+            if not is_sync():
                 await close(exchange)
         except Exception as e:
-            if not self.is_synchronous:
+            if not is_sync():
                 await close(exchange)
             raise e
 
@@ -648,12 +648,12 @@ class testMainClass:
         # to make this test as fast as possible
         # and basically independent from the exchange
         # so we can run it offline
-        filename = self.root_dir + './ts/src/test/static/markets/' + id + '.json'
+        filename = get_root_dir() + './ts/src/test/static/markets/' + id + '.json'
         content = io_file_read(filename)
         return content
 
     def load_currencies_from_file(self, id):
-        filename = self.root_dir + './ts/src/test/static/currencies/' + id + '.json'
+        filename = get_root_dir() + './ts/src/test/static/currencies/' + id + '.json'
         content = io_file_read(filename)
         return content
 
@@ -843,7 +843,7 @@ class testMainClass:
         output = None
         request_url = None
         try:
-            if not self.is_synchronous:
+            if not is_sync():
                 await call_exchange_method_dynamically(exchange, method, self.sanitize_data_input(data['input']))
             else:
                 call_exchange_method_dynamically_sync(exchange, method, self.sanitize_data_input(data['input']))
@@ -864,7 +864,7 @@ class testMainClass:
         expected_result = exchange.safe_value(data, 'parsedResponse')
         mocked_exchange = set_fetch_response(exchange, data['httpResponse'])
         try:
-            if not self.is_synchronous:
+            if not is_sync():
                 unified_result = await call_exchange_method_dynamically(exchange, method, self.sanitize_data_input(data['input']))
                 self.assert_static_response_output(mocked_exchange, skip_keys, unified_result, expected_result)
             else:
@@ -960,7 +960,7 @@ class testMainClass:
                 # reset options
                 # exchange.options = exchange.deepExtend (oldExchangeOptions, {});
                 exchange.extend_exchange_options(exchange.deep_extend(old_exchange_options, {}))
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True   # in c# methods that will be used with promiseAll need to return something
 
@@ -1010,7 +1010,7 @@ class testMainClass:
                 # reset options
                 # exchange.options = exchange.deepExtend (oldExchangeOptions, {});
                 exchange.extend_exchange_options(exchange.deep_extend(old_exchange_options, {}))
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True   # in c# methods that will be used with promiseAll need to return something
 
@@ -1031,7 +1031,7 @@ class testMainClass:
         await self.run_static_tests('request', target_exchange, test_name)
 
     async def run_static_tests(self, type, target_exchange=None, test_name=None):
-        folder = self.root_dir + './ts/src/test/static/' + type + '/'
+        folder = get_root_dir() + './ts/src/test/static/' + type + '/'
         static_data = self.load_static_data(folder, target_exchange)
         if static_data is None:
             return
@@ -1056,7 +1056,7 @@ class testMainClass:
         if self.request_tests_failed or self.response_tests_failed:
             exit_script(1)
         else:
-            prefix = '[SYNC]' if (self.is_synchronous) else ''
+            prefix = '[SYNC]' if (is_sync()) else ''
             success_message = '[' + self.lang + ']' + prefix + '[TEST_SUCCESS] ' + str(sum) + ' static ' + type + ' tests passed.'
             dump('[INFO]' + success_message)
 
@@ -1103,7 +1103,7 @@ class testMainClass:
         assert client_order_id_swap.startswith(swap_id_string), 'binance - swap clientOrderId: ' + client_order_id_swap + ' does not start with swapId' + swap_id_string
         client_order_id_inverse = swap_inverse_order_request['newClientOrderId']
         assert client_order_id_inverse.startswith(swap_id_string), 'binance - swap clientOrderIdInverse: ' + client_order_id_inverse + ' does not start with swapId' + swap_id_string
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1129,7 +1129,7 @@ class testMainClass:
         assert client_order_id_swap.startswith(id_string), 'okx - swap clientOrderId: ' + client_order_id_swap + ' does not start with id: ' + id_string
         swap_tag = swap_order_request[0]['tag']
         assert swap_tag == id, 'okx - id: ' + id + ' different from swap tag: ' + swap_tag
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1144,7 +1144,7 @@ class testMainClass:
             request = json_parse(exchange.last_request_body)
         broker_id = request['params']['broker_id']
         assert broker_id == id, 'cryptocom - id: ' + id + ' different from  broker_id: ' + broker_id
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1159,7 +1159,7 @@ class testMainClass:
             # we expect an error here, we're only interested in the headers
             req_headers = exchange.last_request_headers
         assert req_headers['Referer'] == id, 'bybit - id: ' + id + ' not in headers.'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1177,7 +1177,7 @@ class testMainClass:
             req_headers = exchange.last_request_headers
         id = 'ccxt'
         assert req_headers['KC-API-PARTNER'] == id, 'kucoin - id: ' + id + ' not in headers.'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1194,7 +1194,7 @@ class testMainClass:
         except Exception as e:
             req_headers = exchange.last_request_headers
         assert req_headers['KC-API-PARTNER'] == id, 'kucoinfutures - id: ' + id + ' not in headers.'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1208,7 +1208,7 @@ class testMainClass:
         except Exception as e:
             req_headers = exchange.last_request_headers
         assert req_headers['X-CHANNEL-API-CODE'] == id, 'bitget - id: ' + id + ' not in headers.'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1223,7 +1223,7 @@ class testMainClass:
         except Exception as e:
             req_headers = exchange.last_request_headers
         assert req_headers['source'] == id, 'mexc - id: ' + id + ' not in headers.'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1254,7 +1254,7 @@ class testMainClass:
         assert client_order_id_swap.startswith(id_string), 'htx - swap channel_code ' + client_order_id_swap + ' does not start with id: ' + id_string
         client_order_id_inverse = swap_inverse_order_request['channel_code']
         assert client_order_id_inverse.startswith(id_string), 'htx - swap inverse channel_code ' + client_order_id_inverse + ' does not start with id: ' + id_string
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1280,7 +1280,7 @@ class testMainClass:
             stop_order_request = json_parse(exchange.last_request_body)
         client_order_id_stop = stop_order_request['brokerId']
         assert client_order_id_stop.startswith(id_string), 'woo - brokerId: ' + client_order_id_stop + ' does not start with id: ' + id_string
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1295,7 +1295,7 @@ class testMainClass:
         except Exception as e:
             req_headers = exchange.last_request_headers
         assert req_headers['X-BM-BROKER-ID'] == id, 'bitmart - id: ' + id + ' not in headers'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1311,7 +1311,7 @@ class testMainClass:
         client_order_id = spot_order_request['client_id']
         id_string = str(id)
         assert client_order_id.startswith(id_string), 'coinex - clientOrderId: ' + client_order_id + ' does not start with id: ' + id_string
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1326,7 +1326,7 @@ class testMainClass:
             # we expect an error here, we're only interested in the headers
             req_headers = exchange.last_request_headers
         assert req_headers['X-SOURCE-KEY'] == id, 'bingx - id: ' + id + ' not in headers.'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
 
     async def test_phemex(self):
@@ -1340,7 +1340,7 @@ class testMainClass:
         client_order_id = request['clOrdID']
         id_string = str(id)
         assert client_order_id.startswith(id_string), 'phemex - clOrdID: ' + client_order_id + ' does not start with id: ' + id_string
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
 
     async def test_blofin(self):
@@ -1354,7 +1354,7 @@ class testMainClass:
         broker_id = request['brokerId']
         id_string = str(id)
         assert broker_id.startswith(id_string), 'blofin - brokerId: ' + broker_id + ' does not start with id: ' + id_string
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
 
     async def test_hyperliquid(self):
@@ -1367,7 +1367,7 @@ class testMainClass:
             request = json_parse(exchange.last_request_body)
         broker_id = str((request['action']['brokerCode']))
         assert broker_id == id, 'hyperliquid - brokerId: ' + broker_id + ' does not start with id: ' + id
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
 
     async def test_coinbaseinternational(self):
@@ -1382,7 +1382,7 @@ class testMainClass:
             request = json_parse(exchange.last_request_body)
         client_order_id = request['client_order_id']
         assert client_order_id.startswith(str(id)), 'clientOrderId does not start with id'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1397,7 +1397,7 @@ class testMainClass:
             request = json_parse(exchange.last_request_body)
         client_order_id = request['client_order_id']
         assert client_order_id.startswith(str(id)), 'clientOrderId does not start with id'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1413,7 +1413,7 @@ class testMainClass:
             request = json_parse(exchange.last_request_body)
         broker_id = request['order_tag']
         assert broker_id == id, 'woofipro - id: ' + id + ' different from  broker_id: ' + broker_id
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1450,7 +1450,7 @@ class testMainClass:
             swap_order_request = json_parse(exchange.last_request_body)
         swap_media = swap_order_request['clientMedia']
         assert swap_media == id, 'xt - id: ' + id + ' different from swap tag: ' + swap_media
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1473,7 +1473,7 @@ class testMainClass:
         order = request['place_order']
         broker_id = order['id']
         assert broker_id == id, 'vertex - id: ' + str(id) + ' different from  broker_id: ' + str(broker_id)
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1515,7 +1515,7 @@ class testMainClass:
         except Exception as e:
             req_headers = exchange.last_request_headers
         assert req_headers['PARADEX-PARTNER'] == id, 'paradex - id: ' + id + ' not in headers'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True
 
@@ -1529,6 +1529,6 @@ class testMainClass:
             # we expect an error here, we're only interested in the headers
             req_headers = exchange.last_request_headers
         assert req_headers['INPUT-SOURCE'] == id, 'hashkey - id: ' + id + ' not in headers.'
-        if not self.is_synchronous:
+        if not is_sync():
             await close(exchange)
         return True