ccxt 4.3.65__py2.py3-none-any.whl → 4.3.67__py2.py3-none-any.whl

ccxt/pro/currencycom.py

@@ -56,7 +56,7 @@ class currencycom(ccxt.async_support.currencycom):
             },
         })
 
-    def ping(self, client):
+    def ping(self, client: Client):
         # custom ping-pong
         requestId = str(self.request_id())
         return {

ccxt/pro/hollaex.py

@@ -546,7 +546,7 @@ class hollaex(ccxt.async_support.hollaex):
         if method is not None:
             method(client, message)
 
-    def ping(self, client):
+    def ping(self, client: Client):
         # hollaex does not support built-in ws protocol-level ping-pong
         return {'op': 'ping'}
 

ccxt/pro/hyperliquid.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, Market, Order, OrderBook, Str, Trade
+from ccxt.base.types import Int, Market, Order, OrderBook, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -23,7 +23,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
                 'watchOrderBook': True,
                 'watchOrders': True,
                 'watchTicker': False,
-                'watchTickers': False,
+                'watchTickers': True,
                 'watchTrades': True,
                 'watchPosition': False,
             },
@@ -123,6 +123,29 @@ class hyperliquid(ccxt.async_support.hyperliquid):
         messageHash = 'orderbook:' + symbol
         client.resolve(orderbook, messageHash)
 
+    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 all markets of a specific list
+        :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>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, True)
+        messageHash = 'tickers'
+        url = self.urls['api']['ws']['public']
+        request: dict = {
+            'method': 'subscribe',
+            'subscription': {
+                'type': 'webData2',  # allMids
+                'user': '0x0000000000000000000000000000000000000000',
+            },
+        }
+        tickers = await self.watch(url, messageHash, self.extend(request, params), messageHash)
+        if self.newUpdates:
+            return self.filter_by_array_tickers(tickers, 'symbol', symbols)
+        return self.tickers
+
     async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         watches information on multiple trades made by the user
@@ -154,6 +177,82 @@ class hyperliquid(ccxt.async_support.hyperliquid):
             limit = trades.getLimit(symbol, limit)
         return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
 
+    def handle_ws_tickers(self, client: Client, message):
+        #
+        #     {
+        #         "channel": "webData2",
+        #         "data": {
+        #             "meta": {
+        #                 "universe": [
+        #                     {
+        #                         "szDecimals": 5,
+        #                         "name": "BTC",
+        #                         "maxLeverage": 50,
+        #                         "onlyIsolated": False
+        #                     },
+        #                     ...
+        #                 ],
+        #             },
+        #             "assetCtxs": [
+        #                 {
+        #                     "funding": "0.00003005",
+        #                     "openInterest": "2311.50778",
+        #                     "prevDayPx": "63475.0",
+        #                     "dayNtlVlm": "468043329.64289033",
+        #                     "premium": "0.00094264",
+        #                     "oraclePx": "64712.0",
+        #                     "markPx": "64774.0",
+        #                     "midPx": "64773.5",
+        #                     "impactPxs": [
+        #                         "64773.0",
+        #                         "64774.0"
+        #                     ]
+        #                 },
+        #                 ...
+        #             ],
+        #             "spotAssetCtxs": [
+        #                 {
+        #                     "prevDayPx": "0.20937",
+        #                     "dayNtlVlm": "11188888.61984999",
+        #                     "markPx": "0.19722",
+        #                     "midPx": "0.197145",
+        #                     "circulatingSupply": "598760557.12072003",
+        #                     "coin": "PURR/USDC"
+        #                 },
+        #                 ...
+        #             ],
+        #         }
+        #     }
+        #
+        # spot
+        rawData = self.safe_dict(message, 'data', {})
+        spotAssets = self.safe_list(rawData, 'spotAssetCtxs', [])
+        parsedTickers = []
+        for i in range(0, len(spotAssets)):
+            assetObject = spotAssets[i]
+            marketId = self.safe_string(assetObject, 'coin')
+            market = self.safe_market(marketId, None, None, 'spot')
+            ticker = self.parse_ws_ticker(assetObject, market)
+            parsedTickers.append(ticker)
+        # perpetuals
+        meta = self.safe_dict(rawData, 'meta', {})
+        universe = self.safe_list(meta, 'universe', [])
+        assetCtxs = self.safe_list(rawData, 'assetCtxs', [])
+        for i in range(0, len(universe)):
+            data = self.extend(
+                self.safe_dict(universe, i, {}),
+                self.safe_dict(assetCtxs, i, {})
+            )
+            id = data['name'] + '/USDC:USDC'
+            market = self.safe_market(id, None, None, 'swap')
+            ticker = self.parse_ws_ticker(data, market)
+            parsedTickers.append(ticker)
+        tickers = self.index_by(parsedTickers, 'symbol')
+        client.resolve(tickers, 'tickers')
+
+    def parse_ws_ticker(self, rawTicker, market: Market = None) -> Ticker:
+        return self.parse_ticker(rawTicker, market)
+
     def handle_my_trades(self, client: Client, message):
         #
         #     {
@@ -497,6 +596,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
             'candle': self.handle_ohlcv,
             'orderUpdates': self.handle_order,
             'userFills': self.handle_my_trades,
+            'webData2': self.handle_ws_tickers,
         }
         exacMethod = self.safe_value(methods, topic)
         if exacMethod is not None:
@@ -510,7 +610,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
                 method(client, message)
                 return
 
-    def ping(self, client):
+    def ping(self, client: Client):
         return {
             'method': 'ping',
         }

ccxt/pro/kucoin.py

@@ -1155,7 +1155,7 @@ class kucoin(ccxt.async_support.kucoin):
         if method is not None:
             method(client, message)
 
-    def ping(self, client):
+    def ping(self, client: Client):
         # kucoin does not support built-in ws protocol-level ping-pong
         # instead it requires a custom json-based text ping-pong
         # https://docs.kucoin.com/#ping

ccxt/pro/kucoinfutures.py

@@ -1035,7 +1035,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         else:
             return elementName + 's@all'
 
-    def ping(self, client):
+    def ping(self, client: Client):
         # kucoin does not support built-in ws protocol-level ping-pong
         # instead it requires a custom json-based text ping-pong
         # https://docs.kucoin.com/#ping

ccxt/pro/mexc.py

@@ -1118,5 +1118,5 @@ class mexc(ccxt.async_support.mexc):
             method = methods[channel]
             method(client, message)
 
-    def ping(self, client):
+    def ping(self, client: Client):
         return {'method': 'ping'}

ccxt/pro/okcoin.py

@@ -573,7 +573,7 @@ class okcoin(ccxt.async_support.okcoin):
         client.resolve(message, 'authenticated')
         return message
 
-    def ping(self, client):
+    def ping(self, client: Client):
         # okex does not support built-in ws protocol-level ping-pong
         # instead it requires custom text-based ping-pong
         return 'ping'

ccxt/pro/okx.py

@@ -13,6 +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
 
 
@@ -836,7 +837,7 @@ class okx(ccxt.async_support.okx):
         for i in range(0, len(deltas)):
             self.handle_delta(bookside, deltas[i])
 
-    def handle_order_book_message(self, client: Client, message, orderbook, messageHash):
+    def handle_order_book_message(self, client: Client, message, orderbook, messageHash, market=None):
         #
         #     {
         #         "asks": [
@@ -851,6 +852,9 @@ class okx(ccxt.async_support.okx):
         #         ],
         #         "instId": "BTC-USDT",
         #         "ts": "1626537446491"
+        #         "checksum": -855196043,
+        #         "prevSeqId": 123456,
+        #         "seqId": 123457
         #     }
         #
         asks = self.safe_value(message, 'asks', [])
@@ -860,9 +864,12 @@ class okx(ccxt.async_support.okx):
         self.handle_deltas(storedAsks, asks)
         self.handle_deltas(storedBids, bids)
         marketId = self.safe_string(message, 'instId')
-        symbol = self.safe_symbol(marketId)
+        symbol = self.safe_symbol(marketId, market)
         checksum = self.handle_option('watchOrderBook', 'checksum', True)
+        seqId = self.safe_integer(message, 'seqId')
         if checksum:
+            prevSeqId = self.safe_integer(message, 'prevSeqId')
+            nonce = orderbook['nonce']
             asksLength = len(storedAsks)
             bidsLength = len(storedBids)
             payloadArray = []
@@ -876,12 +883,17 @@ class okx(ccxt.async_support.okx):
             payload = ':'.join(payloadArray)
             responseChecksum = self.safe_integer(message, 'checksum')
             localChecksum = self.crc32(payload, True)
+            error = None
+            if prevSeqId != -1 and nonce != prevSeqId:
+                error = InvalidNonce(self.id + ' watchOrderBook received invalid nonce')
             if responseChecksum != localChecksum:
                 error = ChecksumError(self.id + ' ' + self.orderbook_checksum_message(symbol))
+            if error is not None:
                 del client.subscriptions[messageHash]
                 del self.orderbooks[symbol]
                 client.reject(error, messageHash)
         timestamp = self.safe_integer(message, 'ts')
+        orderbook['nonce'] = seqId
         orderbook['timestamp'] = timestamp
         orderbook['datetime'] = self.iso8601(timestamp)
         return orderbook
@@ -1001,7 +1013,7 @@ class okx(ccxt.async_support.okx):
                 orderbook = self.orderbooks[symbol]
                 for i in range(0, len(data)):
                     update = data[i]
-                    self.handle_order_book_message(client, update, orderbook, messageHash)
+                    self.handle_order_book_message(client, update, orderbook, messageHash, market)
                     client.resolve(orderbook, messageHash)
         elif (channel == 'books5') or (channel == 'bbo-tbt'):
             if not (symbol in self.orderbooks):
@@ -1528,7 +1540,7 @@ class okx(ccxt.async_support.okx):
         await self.load_markets()
         await self.authenticate()
         url = self.get_url('private', 'private')
-        messageHash = str(self.nonce())
+        messageHash = str(self.milliseconds())
         op = None
         op, params = self.handle_option_and_params(params, 'createOrderWs', 'op', 'batch-orders')
         args = self.create_order_request(symbol, type, side, amount, price, params)
@@ -1593,7 +1605,7 @@ class okx(ccxt.async_support.okx):
         await self.load_markets()
         await self.authenticate()
         url = self.get_url('private', 'private')
-        messageHash = str(self.nonce())
+        messageHash = str(self.milliseconds())
         op = None
         op, params = self.handle_option_and_params(params, 'editOrderWs', 'op', 'amend-order')
         args = self.edit_order_request(id, symbol, type, side, amount, price, params)
@@ -1619,7 +1631,7 @@ class okx(ccxt.async_support.okx):
         await self.load_markets()
         await self.authenticate()
         url = self.get_url('private', 'private')
-        messageHash = str(self.nonce())
+        messageHash = str(self.milliseconds())
         clientOrderId = self.safe_string_2(params, 'clOrdId', 'clientOrderId')
         params = self.omit(params, ['clientOrderId', 'clOrdId'])
         arg: dict = {
@@ -1653,7 +1665,7 @@ class okx(ccxt.async_support.okx):
         await self.load_markets()
         await self.authenticate()
         url = self.get_url('private', 'private')
-        messageHash = str(self.nonce())
+        messageHash = str(self.milliseconds())
         args = []
         for i in range(0, idsLength):
             arg: dict = {
@@ -1684,7 +1696,7 @@ class okx(ccxt.async_support.okx):
         if market['type'] != 'option':
             raise BadRequest(self.id + 'cancelAllOrdersWs is only applicable to Option in Portfolio Margin mode, and MMP privilege is required.')
         url = self.get_url('private', 'private')
-        messageHash = str(self.nonce())
+        messageHash = str(self.milliseconds())
         request: dict = {
             'id': messageHash,
             'op': 'mass-cancel',
@@ -1728,7 +1740,7 @@ class okx(ccxt.async_support.okx):
         future = self.safe_value(client.futures, 'authenticated')
         future.resolve(True)
 
-    def ping(self, client):
+    def ping(self, client: Client):
         # OKX does not support the built-in WebSocket protocol-level ping-pong.
         # Instead, it requires a custom text-based ping-pong mechanism.
         return 'ping'

ccxt/pro/oxfun.py

@@ -914,7 +914,7 @@ class oxfun(ccxt.async_support.oxfun):
             if messageHash in client.subscriptions:
                 del client.subscriptions[messageHash]
 
-    def ping(self, client):
+    def ping(self, client: Client):
         return 'ping'
 
     def handle_pong(self, client: Client, message):

ccxt/pro/p2b.py

@@ -388,7 +388,7 @@ class p2b(ccxt.async_support.p2b):
             raise ExchangeError(self.id + ' error: ' + self.json(error))
         return False
 
-    def ping(self, client):
+    def ping(self, client: Client):
         """
         :see: https://github.com/P2B-team/P2B-WSS-Public/blob/main/wss_documentation.md#ping
          * @param client

ccxt/pro/poloniex.py

@@ -1160,7 +1160,7 @@ class poloniex(ccxt.async_support.poloniex):
                 del client.subscriptions[messageHash]
         return message
 
-    def ping(self, client):
+    def ping(self, client: Client):
         return {
             'event': 'ping',
         }

ccxt/pro/whitebit.py

@@ -856,7 +856,7 @@ class whitebit(ccxt.async_support.whitebit):
         client.lastPong = self.milliseconds()
         return message
 
-    def ping(self, client):
+    def ping(self, client: Client):
         return {
             'id': 0,
             'method': 'ping',

ccxt/test/tests_async.py

@@ -3,7 +3,7 @@
 import asyncio
 
 
-from tests_helpers import get_cli_arg_value, dump, exit_script, get_test_files, init_exchange, set_exchange_prop, call_method, exception_message, io_file_exists, io_file_read, baseMainTestClass, AuthenticationError, NotSupported, OperationFailed, OnMaintenance, ExchangeNotAvailable, InvalidProxySettings, get_exchange_prop, close, json_parse, json_stringify, is_null_value, io_dir_read, convert_ascii, call_exchange_method_dynamically, set_fetch_response, call_exchange_method_dynamically_sync  # noqa: F401
+from tests_helpers import AuthenticationError, NotSupported, InvalidProxySettings, ExchangeNotAvailable, OperationFailed, OnMaintenance, get_cli_arg_value, baseMainTestClass, 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, 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
 
 class testMainClass(baseMainTestClass):
     def parse_cli_args(self):
@@ -72,7 +72,10 @@ class testMainClass(baseMainTestClass):
     async def import_files(self, exchange):
         properties = list(exchange.has.keys())
         properties.append('loadMarkets')
-        self.test_files = await get_test_files(properties, self.ws_tests)
+        if self.is_synchronous:
+            self.test_files = get_test_files_sync(properties, self.ws_tests)
+        else:
+            self.test_files = await get_test_files(properties, self.ws_tests)
 
     def load_credentials_from_env(self, exchange):
         exchange_id = exchange.id
@@ -192,7 +195,10 @@ class testMainClass(baseMainTestClass):
         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), self.exchange_hint(exchange), method_name, args_stringified)
-        await call_method(self.test_files, method_name, exchange, skipped_properties_for_method, args)
+        if self.is_synchronous:
+            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)
         if self.info:
             dump(self.add_padding('[INFO] TESTING DONE', 25), self.exchange_hint(exchange), method_name)
         # add to the list of successed tests
@@ -587,7 +593,7 @@ class testMainClass(baseMainTestClass):
         if exception is not None:
             error_message = '[TEST_FAILURE] Failed ' + proxy_test_name + ' : ' + exception_message(exception)
             # temporary comment the below, because c# transpilation failure
-            # throw new ExchangeError (errorMessage.toString ());
+            # throw new Exchange Error (errorMessage.toString ());
             dump('[TEST_WARNING]' + str(error_message))
 
     async def start_test(self, exchange, symbol):
@@ -599,16 +605,19 @@ class testMainClass(baseMainTestClass):
         try:
             result = await self.load_exchange(exchange)
             if not result:
-                await close(exchange)
+                if not self.is_synchronous:
+                    await close(exchange)
                 return
             # if (exchange.id === 'binance') {
             #     # we test proxies functionality just for one random exchange on each build, because proxy functionality is not exchange-specific, instead it's all done from base methods, so just one working sample would mean it works for all ccxt exchanges
             #     # await this.testProxies (exchange);
             # }
             await self.test_exchange(exchange, symbol)
-            await close(exchange)
+            if not self.is_synchronous:
+                await close(exchange)
         except Exception as e:
-            await close(exchange)
+            if not self.is_synchronous:
+                await close(exchange)
             raise e
 
     def assert_static_error(self, cond, message, calculated_output, stored_output, key=None):
@@ -1076,7 +1085,8 @@ class testMainClass(baseMainTestClass):
         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
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True
 
     async def test_okx(self):
@@ -1101,7 +1111,8 @@ class testMainClass(baseMainTestClass):
         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
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True
 
     async def test_cryptocom(self):
@@ -1115,7 +1126,8 @@ class testMainClass(baseMainTestClass):
             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
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True
 
     async def test_bybit(self):
@@ -1129,7 +1141,8 @@ class testMainClass(baseMainTestClass):
             # 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.'
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True
 
     async def test_kucoin(self):
@@ -1146,7 +1159,8 @@ class testMainClass(baseMainTestClass):
             req_headers = exchange.last_request_headers
         id = 'ccxt'
         assert req_headers['KC-API-PARTNER'] == id, 'kucoin - id: ' + id + ' not in headers.'
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True
 
     async def test_kucoinfutures(self):
@@ -1162,7 +1176,8 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             req_headers = exchange.last_request_headers
         assert req_headers['KC-API-PARTNER'] == id, 'kucoinfutures - id: ' + id + ' not in headers.'
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True
 
     async def test_bitget(self):
@@ -1175,7 +1190,8 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             req_headers = exchange.last_request_headers
         assert req_headers['X-CHANNEL-API-CODE'] == id, 'bitget - id: ' + id + ' not in headers.'
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True
 
     async def test_mexc(self):
@@ -1189,7 +1205,8 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             req_headers = exchange.last_request_headers
         assert req_headers['source'] == id, 'mexc - id: ' + id + ' not in headers.'
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True
 
     async def test_htx(self):
@@ -1219,7 +1236,8 @@ class testMainClass(baseMainTestClass):
         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
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True
 
     async def test_woo(self):
@@ -1244,7 +1262,8 @@ class testMainClass(baseMainTestClass):
             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
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True
 
     async def test_bitmart(self):
@@ -1258,7 +1277,8 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             req_headers = exchange.last_request_headers
         assert req_headers['X-BM-BROKER-ID'] == id, 'bitmart - id: ' + id + ' not in headers'
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True
 
     async def test_coinex(self):
@@ -1273,7 +1293,8 @@ class testMainClass(baseMainTestClass):
         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
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True
 
     async def test_bingx(self):
@@ -1287,7 +1308,8 @@ class testMainClass(baseMainTestClass):
             # 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.'
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
 
     async def test_phemex(self):
         exchange = self.init_offline_exchange('phemex')
@@ -1300,7 +1322,8 @@ class testMainClass(baseMainTestClass):
         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
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
 
     async def test_blofin(self):
         exchange = self.init_offline_exchange('blofin')
@@ -1313,7 +1336,8 @@ class testMainClass(baseMainTestClass):
         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
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
 
     async def test_hyperliquid(self):
         exchange = self.init_offline_exchange('hyperliquid')
@@ -1325,7 +1349,8 @@ class testMainClass(baseMainTestClass):
             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
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
 
     async def test_coinbaseinternational(self):
         exchange = self.init_offline_exchange('coinbaseinternational')
@@ -1339,7 +1364,8 @@ class testMainClass(baseMainTestClass):
             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'
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True
 
     async def test_coinbase_advanced(self):
@@ -1353,7 +1379,8 @@ class testMainClass(baseMainTestClass):
             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'
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True
 
     async def test_woofi_pro(self):
@@ -1368,7 +1395,8 @@ class testMainClass(baseMainTestClass):
             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
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True
 
     async def test_oxfun(self):
@@ -1404,7 +1432,8 @@ class testMainClass(baseMainTestClass):
             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
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True
 
     async def test_vertex(self):
@@ -1426,5 +1455,6 @@ class testMainClass(baseMainTestClass):
         order = request['place_order']
         broker_id = order['id']
         assert broker_id == id, 'vertex - id: ' + str(id) + ' different from  broker_id: ' + str(broker_id)
-        await close(exchange)
+        if not self.is_synchronous:
+            await close(exchange)
         return True

ccxt/test/tests_helpers.py

@@ -191,6 +191,10 @@ def io_dir_read(path):
     return os.listdir(path)
 
 
+def call_method_sync(test_files, methodName, exchange, skippedProperties, args):
+    methodNameToCall = 'test_' + convert_to_snake_case(methodName)
+    return getattr(test_files[methodName], methodNameToCall)(exchange, skippedProperties, *args)
+
 async def call_method(test_files, methodName, exchange, skippedProperties, args):
     methodNameToCall = 'test_' + convert_to_snake_case(methodName)
     return await getattr(test_files[methodName], methodNameToCall)(exchange, skippedProperties, *args)
@@ -240,7 +244,7 @@ def init_exchange(exchangeId, args, is_ws=False):
     return getattr(ccxt, exchangeId)(args)
 
 
-async def get_test_files(properties, ws=False):
+def get_test_files_sync(properties, ws=False):
     tests = {}
     finalPropList = properties + [proxyTestFileName]
     for i in range(0, len(finalPropList)):
@@ -259,6 +263,9 @@ async def get_test_files(properties, ws=False):
             tests[methodName] = imp  # getattr(imp, finalName)
     return tests
 
+async def get_test_files(properties, ws=False):
+    return get_test_files_sync(properties, ws)
+
 async def close(exchange):
     if (not is_synchronous and hasattr(exchange, 'close')):
         await exchange.close()