ccxt 4.2.76__py2.py3-none-any.whl → 4.4.48__py2.py3-none-any.whl

ccxt/test/{test_sync.py → tests_sync.py}

@@ -1,272 +1,36 @@
 # -*- coding: utf-8 -*-
 
-import argparse
-import json
-# import logging
-import os
-import sys
-from traceback import format_tb, format_exception
-
-import importlib  # noqa: E402
-import re
-
-# ------------------------------------------------------------------------------
-# logging.basicConfig(level=logging.INFO)
-# ------------------------------------------------------------------------------
-DIR_NAME = os.path.dirname(os.path.abspath(__file__))
-root = os.path.dirname(os.path.dirname(DIR_NAME))
-sys.path.append(root)
-
-import ccxt  # noqa: E402
-import ccxt.pro as ccxtpro  # noqa: E402
-
-# ------------------------------------------------------------------------------
-# from typing import Optional
-# from typing import List
-from ccxt.base.errors import NotSupported
-from ccxt.base.errors import ProxyError
-from ccxt.base.errors import OperationFailed
-# from ccxt.base.errors import ExchangeError
-from ccxt.base.errors import ExchangeNotAvailable
-from ccxt.base.errors import OnMaintenance
-from ccxt.base.errors import AuthenticationError
-
-# ------------------------------------------------------------------------------
-
-class Argv(object):
-    id_tests = False
-    static_tests = False
-    ws_tests = False
-    request_tests = False
-    response_tests = False
-
-    sandbox = False
-    privateOnly = False
-    private = False
-    ws = False
-    verbose = False
-    nonce = None
-    exchange = None
-    symbol = None
-    info = False
-    pass
-
-
-argv = Argv()
-parser = argparse.ArgumentParser()
-
-parser.add_argument('--sandbox', action='store_true', help='enable sandbox mode')
-parser.add_argument('--privateOnly', action='store_true', help='run private tests only')
-parser.add_argument('--private', action='store_true', help='run private tests')
-parser.add_argument('--verbose', action='store_true', help='enable verbose output')
-parser.add_argument('--ws', action='store_true', help='websockets version')
-parser.add_argument('--info', action='store_true', help='enable info output')
-parser.add_argument('--static', action='store_true', help='run static tests')
-parser.add_argument('--useProxy', action='store_true', help='run static tests')
-parser.add_argument('--idTests', action='store_true', help='run brokerId tests')
-parser.add_argument('--responseTests', action='store_true', help='run response tests')
-parser.add_argument('--requestTests', action='store_true', help='run response 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)
-
-# ------------------------------------------------------------------------------
-
-path = os.path.dirname(ccxt.__file__)
-if 'site-packages' in os.path.dirname(ccxt.__file__):
-    raise Exception("You are running test_async.py/test.py against a globally-installed version of the library! It was previously installed into your site-packages folder by pip or pip3. To ensure testing against the local folder uninstall it first with pip uninstall ccxt or pip3 uninstall ccxt")
-
-# ------------------------------------------------------------------------------
-
-Error = Exception
-
-# # print an error string
-# def dump_error(*args):
-#     string = ' '.join([str(arg) for arg in args])
-#     print(string)
-#     sys.stderr.write(string + "\n")
-#     sys.stderr.flush()
-
-
-def handle_all_unhandled_exceptions(type, value, traceback):
-    dump((type), (value), '\n<UNHANDLED EXCEPTION>\n' + ('\n'.join(format_tb(traceback))))
-    exit(1)  # unrecoverable crash
-
-
-sys.excepthook = handle_all_unhandled_exceptions
-# ------------------------------------------------------------------------------
-
-# non-transpiled part, but shared names among langs
-
-is_synchronous = 'async' not in os.path.basename(__file__)
-
-rootDir = DIR_NAME + '/../../../'
-rootDirForSkips = DIR_NAME + '/../../../'
-envVars = os.environ
-LOG_CHARS_LENGTH = 10000
-ext = 'py'
-proxyTestFileName = 'proxies'
-
-
-def get_cli_arg_value(arg):
-    arg_exists = getattr(argv, arg) if hasattr(argv, arg) else False
-    with_hyphen = '--' + arg
-    arg_exists_with_hyphen = getattr(argv, with_hyphen) if hasattr(argv, with_hyphen) else False
-    without_hyphen = arg.replace('--', '')
-    arg_exists_wo_hyphen = getattr(argv, without_hyphen) if hasattr(argv, without_hyphen) else False
-    return arg_exists or arg_exists_with_hyphen or arg_exists_wo_hyphen
-
-isWsTests = get_cli_arg_value('--ws')
-
+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 baseMainTestClass():
-    lang = 'PY'
-    is_synchronous = is_synchronous
+class testMainClass:
+    id_tests = False
     request_tests_failed = False
     response_tests_failed = False
-    response_tests = False
+    request_tests = False
     ws_tests = False
+    response_tests = False
+    static_tests = False
+    info = False
+    verbose = False
+    debug = False
+    private_test = False
+    private_test_only = False
     load_keys = False
+    sandbox = False
+    only_specific_tests = []
+    skipped_settings_for_exchange = {}
     skipped_methods = {}
-    check_public_tests = {}
+    checked_public_tests = {}
     test_files = {}
     public_tests = {}
-    new_line = '\n'
-    root_dir = rootDir
-    env_vars = envVars
-    ext = ext
-    root_dir_for_skips = rootDirForSkips
-    only_specific_tests = []
-    proxy_test_file_name = proxyTestFileName
-    pass
-
-
-def dump(*args):
-    print(' '.join([str(arg) for arg in args]))
-
-
-def convert_ascii(str):
-    return str  # stub
-
-def json_parse(elem):
-    return json.loads(elem)
-
-
-def json_stringify(elem):
-    return json.dumps(elem)
-
-
-def convert_to_snake_case(content):
-    res = re.sub(r'(?<!^)(?=[A-Z])', '_', content).lower()
-    return res.replace('o_h_l_c_v', 'ohlcv')
-
-
-def get_test_name(methodName):
-    # stub
-    return methodName
-
-
-def io_file_exists(path):
-    return os.path.isfile(path)
-
-
-def io_file_read(path, decode=True):
-    fs = open(path, "r", encoding="utf-8")
-    content = fs.read()
-    if decode:
-        return json.loads(content)
-    else:
-        return content
-
+    ext = ''
+    lang = ''
+    proxy_test_file_name = 'proxies'
 
-def io_dir_read(path):
-    return os.listdir(path)
-
-
-def call_method(test_files, methodName, exchange, skippedProperties, args):
-    methodNameToCall = 'test_' + convert_to_snake_case(methodName)
-    return getattr(test_files[methodName], methodNameToCall)(exchange, skippedProperties, *args)
-
-
-def call_exchange_method_dynamically(exchange, methodName, args):
-    return getattr(exchange, methodName)(*args)
-
-def call_overriden_method(exchange, methodName, args):
-    # needed for php
-    return call_exchange_method_dynamically(exchange, methodName, args)
-
-def exception_message(exc):
-    message = '[' + type(exc).__name__ + '] ' + "".join(format_exception(type(exc), exc, exc.__traceback__, limit=6))
-    if len(message) > LOG_CHARS_LENGTH:
-        # Accessing out of range element causes error
-        message = message[0:LOG_CHARS_LENGTH]
-    return message
-
-
-def exit_script(code=0):
-    exit(code)
-
-
-def get_exchange_prop(exchange, prop, defaultValue=None):
-    if hasattr(exchange, prop):
-        res = getattr(exchange, prop)
-        if res is not None and res != '':
-            return res
-    return defaultValue
-
-
-def set_exchange_prop(exchange, prop, value):
-    setattr(exchange, prop, value)
-    # set snake case too
-    setattr(exchange, convert_to_snake_case(prop), value)
-
-
-def init_exchange(exchangeId, args, is_ws=False):
-    if (is_ws):
-        return getattr(ccxtpro, exchangeId)(args)
-    return getattr(ccxt, exchangeId)(args)
-
-
-def get_test_files(properties, ws=False):
-    tests = {}
-    finalPropList = properties + [proxyTestFileName]
-    for i in range(0, len(finalPropList)):
-        methodName = finalPropList[i]
-        name_snake_case = convert_to_snake_case(methodName)
-        prefix = 'async' if not is_synchronous else 'sync'
-        dir_to_test = DIR_NAME + '/' + prefix + '/'
-        module_string = 'ccxt.test.' + prefix + '.test_' + name_snake_case
-        if (ws):
-            prefix = 'pro'
-            dir_to_test = DIR_NAME + '/../' + prefix + '/test/Exchange/'
-            module_string = 'ccxt.pro.test.Exchange.test_' + name_snake_case
-        filePathWithExt = dir_to_test + 'test_' + name_snake_case + '.py'
-        if (io_file_exists (filePathWithExt)):
-            imp = importlib.import_module(module_string)
-            tests[methodName] = imp  # getattr(imp, finalName)
-    return tests
-
-def close(exchange):
-    if (not is_synchronous and hasattr(exchange, 'close')):
-        exchange.close()
-
-def is_null_value(value):
-    return value is None
-
-def set_fetch_response(exchange: ccxt.Exchange, data):
-    def fetch(url, method='GET', headers=None, body=None):
-        return data
-    exchange.fetch = fetch
-    return exchange
-
-# *********************************
-# ***** AUTO-TRANSPILER-START *****
-class testMainClass(baseMainTestClass):
-    def parse_cli_args(self):
-        self.response_tests = get_cli_arg_value('--responseTests')
+    def parse_cli_args_and_props(self):
+        self.response_tests = get_cli_arg_value('--responseTests') or get_cli_arg_value('--response')
         self.id_tests = get_cli_arg_value('--idTests')
-        self.request_tests = get_cli_arg_value('--requestTests')
+        self.request_tests = get_cli_arg_value('--requestTests') or get_cli_arg_value('--request')
         self.info = get_cli_arg_value('--info')
         self.verbose = get_cli_arg_value('--verbose')
         self.debug = get_cli_arg_value('--debug')
@@ -275,9 +39,11 @@ class testMainClass(baseMainTestClass):
         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()
 
-    def init(self, exchange_id, symbol_argv):
-        self.parse_cli_args()
+    def init(self, exchange_id, symbol_argv, method_argv):
+        self.parse_cli_args_and_props()
         if self.request_tests and self.response_tests:
             self.run_static_request_tests(exchange_id, symbol_argv)
             self.run_static_response_tests(exchange_id, symbol_argv)
@@ -291,13 +57,14 @@ class testMainClass(baseMainTestClass):
         if self.id_tests:
             self.run_broker_id_tests()
             return
-        symbol_str = symbol_argv if symbol_argv is not None else 'all'
-        exchange_object = {
+        new_line = '\n'
+        dump(new_line + '' + new_line + '' + '[INFO] TESTING ', self.ext, {
             'exchange': exchange_id,
-            'symbol': symbol_str,
+            'symbol': symbol_argv,
+            'method': method_argv,
             'isWs': self.ws_tests,
-        }
-        dump(self.new_line + '' + self.new_line + '' + '[INFO] TESTING ', self.ext, json_stringify(exchange_object), self.new_line)
+            'useProxy': get_cli_arg_value('--useProxy'),
+        }, new_line)
         exchange_args = {
             'verbose': self.verbose,
             'debug': self.debug,
@@ -310,30 +77,30 @@ class testMainClass(baseMainTestClass):
         self.import_files(exchange)
         assert len(list(self.test_files.keys())) > 0, 'Test files were not loaded'  # ensure test files are found & filled
         self.expand_settings(exchange)
-        symbol = self.check_if_specific_test_is_chosen(symbol_argv)
-        self.start_test(exchange, symbol)
+        self.check_if_specific_test_is_chosen(method_argv)
+        self.start_test(exchange, symbol_argv)
         exit_script(0)  # needed to be explicitly finished for WS tests
 
-    def check_if_specific_test_is_chosen(self, symbol_argv):
-        if symbol_argv is not None:
+    def check_if_specific_test_is_chosen(self, method_argv):
+        if method_argv is not None:
             test_file_names = list(self.test_files.keys())
-            possible_method_names = symbol_argv.split(',')  # i.e. `test.ts binance fetchBalance,fetchDeposits`
+            possible_method_names = method_argv.split(',')  # i.e. `test.ts binance fetchBalance,fetchDeposits`
             if len(possible_method_names) >= 1:
                 for i in range(0, len(test_file_names)):
                     test_file_name = test_file_names[i]
                     for j in range(0, len(possible_method_names)):
                         method_name = possible_method_names[j]
+                        method_name = method_name.replace('()', '')
                         if test_file_name == method_name:
                             self.only_specific_tests.append(test_file_name)
-            # if method names were found, then remove them from symbolArgv
-            if len(self.only_specific_tests) > 0:
-                return None
-        return symbol_argv
 
     def import_files(self, exchange):
         properties = list(exchange.has.keys())
         properties.append('loadMarkets')
-        self.test_files = get_test_files(properties, self.ws_tests)
+        if is_sync():
+            self.test_files = get_test_files_sync(properties, self.ws_tests)
+        else:
+            self.test_files = get_test_files(properties, self.ws_tests)
 
     def load_credentials_from_env(self, exchange):
         exchange_id = exchange.id
@@ -345,14 +112,15 @@ class testMainClass(baseMainTestClass):
             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 {}
@@ -375,9 +143,10 @@ class testMainClass(baseMainTestClass):
         if self.load_keys:
             self.load_credentials_from_env(exchange)
         # skipped tests
-        skipped_file = self.root_dir_for_skips + 'skip-tests.json'
+        skipped_file = get_root_dir() + 'skip-tests.json'
         skipped_settings = io_file_read(skipped_file)
-        skipped_settings_for_exchange = exchange.safe_value(skipped_settings, exchange_id, {})
+        self.skipped_settings_for_exchange = exchange.safe_value(skipped_settings, exchange_id, {})
+        skipped_settings_for_exchange = self.skipped_settings_for_exchange
         # others
         timeout = exchange.safe_value(skipped_settings_for_exchange, 'timeout')
         if timeout is not None:
@@ -400,31 +169,18 @@ class testMainClass(baseMainTestClass):
                 res += ' '
         return message + res
 
-    def exchange_hint(self, exchange, market=None):
-        market_type = exchange.safe_string_2(exchange.options, 'defaultType', 'type', '')
-        market_sub_type = exchange.safe_string_2(exchange.options, 'defaultSubType', 'subType')
-        if market is not None:
-            market_type = market['type']
-            if market['linear']:
-                market_sub_type = 'linear'
-            elif market['inverse']:
-                market_sub_type = 'inverse'
-            elif exchange.safe_value(market, 'quanto'):
-                market_sub_type = 'quanto'
-        is_ws = ('ws' in exchange.has)
-        ws_flag = '(WS)' if is_ws else ''
-        result = exchange.id + ' ' + ws_flag + ' ' + market_type
-        if market_sub_type is not None:
-            result = result + ' [subType: ' + market_sub_type + '] '
-        return result
-
     def test_method(self, method_name, exchange, args, is_public):
+        # todo: temporary skip for c#
+        if 'OrderBook' in method_name and self.ext == 'cs':
+            exchange.options['checksum'] = False
         # todo: temporary skip for php
         if 'OrderBook' in method_name and self.ext == 'php':
             return
+        skipped_properties_for_method = self.get_skips(exchange, method_name)
         is_load_markets = (method_name == 'loadMarkets')
         is_fetch_currencies = (method_name == 'fetchCurrencies')
         is_proxy_test = (method_name == self.proxy_test_file_name)
+        is_feature_test = (method_name == 'features')
         # if this is a private test, and the implementation was already tested in public, then no need to re-test it in private test (exception is fetchCurrencies, because our approach in base exchange)
         if not is_public and (method_name in self.checked_public_tests) and not is_fetch_currencies:
             return
@@ -432,31 +188,46 @@ class testMainClass(baseMainTestClass):
         supported_by_exchange = (method_name in exchange.has) and exchange.has[method_name]
         if not is_load_markets and (len(self.only_specific_tests) > 0 and not exchange.in_array(method_name, self.only_specific_tests)):
             skip_message = '[INFO] IGNORED_TEST'
-        elif not is_load_markets and not supported_by_exchange and not is_proxy_test:
+        elif not is_load_markets and not supported_by_exchange and not is_proxy_test and not is_feature_test:
             skip_message = '[INFO] UNSUPPORTED_TEST'  # keep it aligned with the longest message
-        elif (method_name in self.skipped_methods) and (isinstance(self.skipped_methods[method_name], str)):
+        elif isinstance(skipped_properties_for_method, str):
             skip_message = '[INFO] SKIPPED_TEST'
         elif not (method_name in self.test_files):
             skip_message = '[INFO] UNIMPLEMENTED_TEST'
         # exceptionally for `loadMarkets` call, we call it before it's even checked for "skip" as we need it to be called anyway (but can skip "test.loadMarket" for it)
         if is_load_markets:
             exchange.load_markets(True)
+        name = exchange.id
         if skip_message:
             if self.info:
-                dump(self.add_padding(skip_message, 25), self.exchange_hint(exchange), method_name)
+                dump(self.add_padding(skip_message, 25), name, method_name)
             return
         if self.info:
-            args_stringified = '(' + ','.join(args) + ')'
-            dump(self.add_padding('[INFO] TESTING', 25), self.exchange_hint(exchange), method_name, args_stringified)
-        call_method(self.test_files, method_name, exchange, self.get_skips(exchange, method_name), args)
-        # if it was passed successfully, add to the list of successfull tests
+            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 is_sync():
+            call_method_sync(self.test_files, method_name, exchange, skipped_properties_for_method, args)
+        else:
+            call_method(self.test_files, method_name, exchange, skipped_properties_for_method, args)
+        if self.info:
+            dump(self.add_padding('[INFO] TESTING DONE', 25), name, method_name)
+        # add to the list of successed tests
         if is_public:
             self.checked_public_tests[method_name] = True
         return
 
     def get_skips(self, exchange, method_name):
-        # get "method-specific" skips
-        skips_for_method = exchange.safe_value(self.skipped_methods, method_name, {})
+        final_skips = {}
+        # check the exact method (i.e. `fetchTrades`) and language-specific (i.e. `fetchTrades.php`)
+        method_names = [method_name, method_name + '.' + self.ext]
+        for i in range(0, len(method_names)):
+            m_name = method_names[i]
+            if m_name in self.skipped_methods:
+                # if whole method is skipped, by assigning a string to it, i.e. "fetchOrders":"blabla"
+                if isinstance(self.skipped_methods[m_name], str):
+                    return self.skipped_methods[m_name]
+                else:
+                    final_skips = exchange.deep_extend(final_skips, self.skipped_methods[m_name])
         # get "object-specific" skips
         object_skips = {
             'orderBook': ['fetchOrderBook', 'fetchOrderBooks', 'fetchL2OrderBook', 'watchOrderBook', 'watchOrderBookForSymbols'],
@@ -472,9 +243,21 @@ class testMainClass(baseMainTestClass):
             object_name = object_names[i]
             object_methods = object_skips[object_name]
             if exchange.in_array(method_name, object_methods):
+                # if whole object is skipped, by assigning a string to it, i.e. "orderBook":"blabla"
+                if (object_name in self.skipped_methods) and (isinstance(self.skipped_methods[object_name], str)):
+                    return self.skipped_methods[object_name]
                 extra_skips = exchange.safe_dict(self.skipped_methods, object_name, {})
-                return exchange.deep_extend(skips_for_method, extra_skips)
-        return skips_for_method
+                final_skips = exchange.deep_extend(final_skips, extra_skips)
+        # extend related skips
+        # - if 'timestamp' is skipped, we should do so for 'datetime' too
+        # - if 'bid' is skipped, skip 'ask' too
+        if ('timestamp' in final_skips) and not ('datetime' in final_skips):
+            final_skips['datetime'] = final_skips['timestamp']
+        if ('bid' in final_skips) and not ('ask' in final_skips):
+            final_skips['ask'] = final_skips['bid']
+        if ('baseVolume' in final_skips) and not ('quoteVolume' in final_skips):
+            final_skips['quoteVolume'] = final_skips['baseVolume']
+        return final_skips
 
     def test_safe(self, method_name, exchange, args=[], is_public=False):
         # `testSafe` method does not throw an exception, instead mutes it. The reason we
@@ -483,12 +266,13 @@ class testMainClass(baseMainTestClass):
         # formatted message "[TEST_FAILURE] ..." and that output is then regex-matched by
         # run-tests.js, so the exceptions are still printed out to console from there.
         max_retries = 3
-        args_stringified = exchange.json(args)  # args.join() breaks when we provide a list of symbols | "args.toString()" breaks bcz of "array to string conversion"
+        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"
         for i in range(0, max_retries):
             try:
                 self.test_method(method_name, exchange, args, is_public)
                 return True
-            except Exception as e:
+            except Exception as ex:
+                e = get_root_exception(ex)
                 is_load_markets = (method_name == 'loadMarkets')
                 is_auth_error = (isinstance(e, AuthenticationError))
                 is_not_supported = (isinstance(e, NotSupported))
@@ -520,36 +304,37 @@ class testMainClass(baseMainTestClass):
                                 return_success = True
                         # output the message
                         fail_type = '[TEST_FAILURE]' if should_fail else '[TEST_WARNING]'
-                        dump(fail_type, 'Method could not be tested due to a repeated Network/Availability issues', ' | ', self.exchange_hint(exchange), method_name, args_stringified, exception_message(e))
+                        dump(fail_type, 'Method could not be tested due to a repeated Network/Availability issues', ' | ', exchange.id, method_name, args_stringified, exception_message(e))
                         return return_success
                     else:
                         # wait and retry again
                         # (increase wait time on every retry)
-                        exchange.sleep(i * 1000)
+                        exchange.sleep((i + 1) * 1000)
                         continue
                 else:
                     # if it's loadMarkets, then fail test, because it's mandatory for tests
                     if is_load_markets:
-                        dump('[TEST_FAILURE]', 'Exchange can not load markets', exception_message(e), self.exchange_hint(exchange), method_name, args_stringified)
+                        dump('[TEST_FAILURE]', 'Exchange can not load markets', exception_message(e), exchange.id, method_name, args_stringified)
                         return False
                     # if the specific arguments to the test method throws "NotSupported" exception
                     # then let's don't fail the test
                     if is_not_supported:
                         if self.info:
-                            dump('[INFO] NOT_SUPPORTED', exception_message(e), self.exchange_hint(exchange), method_name, args_stringified)
+                            dump('[INFO] NOT_SUPPORTED', exception_message(e), exchange.id, method_name, args_stringified)
                         return True
                     # If public test faces authentication error, we don't break (see comments under `testSafe` method)
                     if is_public and is_auth_error:
                         if self.info:
-                            dump('[INFO]', 'Authentication problem for public method', exception_message(e), self.exchange_hint(exchange), method_name, args_stringified)
+                            dump('[INFO]', 'Authentication problem for public method', exception_message(e), exchange.id, method_name, args_stringified)
                         return True
                     else:
-                        dump('[TEST_FAILURE]', exception_message(e), self.exchange_hint(exchange), method_name, args_stringified)
+                        dump('[TEST_FAILURE]', exception_message(e), exchange.id, method_name, args_stringified)
                         return False
         return True
 
     def run_public_tests(self, exchange, symbol):
         tests = {
+            'features': [],
             'fetchCurrencies': [],
             'fetchTicker': [symbol],
             'fetchTickers': [symbol],
@@ -566,10 +351,14 @@ class testMainClass(baseMainTestClass):
         if self.ws_tests:
             tests = {
                 'watchOHLCV': [symbol],
+                'watchOHLCVForSymbols': [symbol],
                 'watchTicker': [symbol],
                 'watchTickers': [symbol],
+                'watchBidsAsks': [symbol],
                 'watchOrderBook': [symbol],
+                'watchOrderBookForSymbols': [[symbol]],
                 'watchTrades': [symbol],
+                'watchTradesForSymbols': [[symbol]],
             }
         market = exchange.market(symbol)
         is_spot = market['spot']
@@ -606,34 +395,26 @@ class testMainClass(baseMainTestClass):
         test_prefix_string = 'PUBLIC_TESTS' if is_public_test else 'PRIVATE_TESTS'
         if len(failed_methods):
             errors_string = ', '.join(failed_methods)
-            dump('[TEST_FAILURE]', self.exchange_hint(exchange), test_prefix_string, 'Failed methods : ' + errors_string)
+            dump('[TEST_FAILURE]', exchange.id, test_prefix_string, 'Failed methods : ' + errors_string)
         if self.info:
-            dump(self.add_padding('[INFO] END ' + test_prefix_string + ' ' + self.exchange_hint(exchange), 25))
+            dump(self.add_padding('[INFO] END ' + test_prefix_string + ' ' + exchange.id, 25))
 
     def load_exchange(self, exchange):
         result = self.test_safe('loadMarkets', exchange, [], True)
         if not result:
             return False
-        symbols = ['BTC/USDT', 'BTC/USDC', 'BTC/CNY', 'BTC/USD', 'BTC/EUR', 'BTC/ETH', 'ETH/BTC', 'BTC/JPY', 'ETH/EUR', 'ETH/JPY', 'ETH/CNY', 'ETH/USD', 'LTC/CNY', 'DASH/BTC', 'DOGE/BTC', 'BTC/AUD', 'BTC/PLN', 'USD/SLL', 'BTC/RUB', 'BTC/UAH', 'LTC/BTC', 'EUR/USD']
-        result_symbols = []
-        exchange_specific_symbols = exchange.symbols
-        for i in range(0, len(exchange_specific_symbols)):
-            symbol = exchange_specific_symbols[i]
-            if exchange.in_array(symbol, symbols):
-                result_symbols.append(symbol)
-        result_msg = ''
-        result_length = len(result_symbols)
         exchange_symbols_length = len(exchange.symbols)
-        if result_length > 0:
-            if exchange_symbols_length > result_length:
-                result_msg = ', '.join(result_symbols) + ' + more...'
-            else:
-                result_msg = ', '.join(result_symbols)
-        dump('[INFO:MAIN] Exchange loaded', exchange_symbols_length, 'symbols', result_msg)
+        dump('[INFO:MAIN] Exchange loaded', exchange_symbols_length, 'symbols')
         return True
 
     def get_test_symbol(self, exchange, is_spot, symbols):
         symbol = None
+        preferred_spot_symbol = exchange.safe_string(self.skipped_settings_for_exchange, 'preferredSpotSymbol')
+        preferred_swap_symbol = exchange.safe_string(self.skipped_settings_for_exchange, 'preferredSwapSymbol')
+        if is_spot and preferred_spot_symbol:
+            return preferred_spot_symbol
+        elif not is_spot and preferred_swap_symbol:
+            return preferred_swap_symbol
         for i in range(0, len(symbols)):
             s = symbols[i]
             market = exchange.safe_value(exchange.markets, s)
@@ -668,9 +449,9 @@ class testMainClass(baseMainTestClass):
 
     def get_valid_symbol(self, exchange, spot=True):
         current_type_markets = self.get_markets_from_exchange(exchange, spot)
-        codes = ['BTC', 'ETH', 'XRP', 'LTC', 'BCH', 'EOS', 'BNB', 'BSV', 'USDT', 'ATOM', 'BAT', 'BTG', 'DASH', 'DOGE', 'ETC', 'IOTA', 'LSK', 'MKR', 'NEO', 'PAX', 'QTUM', 'TRX', 'TUSD', 'USD', 'USDC', 'WAVES', 'XEM', 'XMR', 'ZEC', 'ZRX']
-        spot_symbols = ['BTC/USDT', 'BTC/USDC', 'BTC/USD', 'BTC/CNY', 'BTC/EUR', 'BTC/ETH', 'ETH/BTC', 'ETH/USD', 'ETH/USDT', 'BTC/JPY', 'LTC/BTC', 'ZRX/WETH', 'EUR/USD']
-        swap_symbols = ['BTC/USDT:USDT', 'BTC/USDC:USDC', 'BTC/USD:USD', 'ETH/USDT:USDT', 'ETH/USD:USD', 'LTC/USDT:USDT', 'DOGE/USDT:USDT', 'ADA/USDT:USDT', 'BTC/USD:BTC', 'ETH/USD:ETH']
+        codes = ['BTC', 'ETH', 'XRP', 'LTC', 'BNB', 'DASH', 'DOGE', 'ETC', 'TRX', 'USDT', 'USDC', 'USD', 'EUR', 'TUSD', 'CNY', 'JPY', 'BRL']
+        spot_symbols = ['BTC/USDT', 'BTC/USDC', 'BTC/USD', 'BTC/CNY', 'BTC/EUR', 'BTC/AUD', 'BTC/BRL', 'BTC/JPY', 'ETH/USDT', 'ETH/USDC', 'ETH/USD', 'ETH/CNY', 'ETH/EUR', 'ETH/AUD', 'ETH/BRL', 'ETH/JPY', 'EUR/USDT', 'EUR/USD', 'EUR/USDC', 'USDT/EUR', 'USD/EUR', 'USDC/EUR', 'BTC/ETH', 'ETH/BTC']
+        swap_symbols = ['BTC/USDT:USDT', 'BTC/USDC:USDC', 'BTC/USD:USD', 'ETH/USDT:USDT', 'ETH/USDC:USDC', 'ETH/USD:USD', 'BTC/USD:BTC', 'ETH/USD:ETH']
         target_symbols = spot_symbols if spot else swap_symbols
         symbol = self.get_test_symbol(exchange, spot, target_symbols)
         # if symbols wasn't found from above hardcoded list, then try to locate any symbol which has our target hardcoded 'base' code
@@ -778,6 +559,8 @@ class testMainClass(baseMainTestClass):
             'fetchBorrowRateHistory': [code],
             'fetchLedgerEntry': [code],
         }
+        if get_cli_arg_value('--fundedTests'):
+            tests['createOrder'] = [symbol]
         if self.ws_tests:
             tests = {
                 'watchBalance': [code],
@@ -808,7 +591,7 @@ class testMainClass(baseMainTestClass):
         # 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
@@ -816,12 +599,16 @@ class testMainClass(baseMainTestClass):
         for j in range(0, max_retries):
             try:
                 self.test_method(proxy_test_name, exchange, [], True)
-                break  # if successfull, then break
+                return   # if successfull, then end the test
             except Exception as e:
                 exception = e
+                exchange.sleep(j * 1000)
         # if exception was set, then throw it
-        if exception:
+        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 Exchange Error (errorMessage.toString ());
+            dump('[TEST_WARNING]' + str(error_message))
 
     def start_test(self, exchange, symbol):
         # we do not need to test aliases
@@ -832,16 +619,19 @@ class testMainClass(baseMainTestClass):
         try:
             result = self.load_exchange(exchange)
             if not result:
-                close(exchange)
+                if not is_sync():
+                    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
             #     # this.testProxies (exchange);
             # }
             self.test_exchange(exchange, symbol)
-            close(exchange)
+            if not is_sync():
+                close(exchange)
         except Exception as e:
-            close(exchange)
+            if not is_sync():
+                close(exchange)
             raise e
 
     def assert_static_error(self, cond, message, calculated_output, stored_output, key=None):
@@ -850,9 +640,10 @@ class testMainClass(baseMainTestClass):
         #  -----------------------------------------------------------------------------
         calculated_string = json_stringify(calculated_output)
         stored_string = json_stringify(stored_output)
-        error_message = message + ' computed ' + stored_string + ' stored: ' + calculated_string
+        error_message = message
         if key is not None:
-            error_message = ' | ' + key + ' | ' + 'computed value: ' + stored_string + ' stored value: ' + calculated_string
+            error_message = '[' + key + ']'
+        error_message += ' computed: ' + stored_string + ' stored: ' + calculated_string
         assert cond, error_message
 
     def load_markets_from_file(self, id):
@@ -860,12 +651,12 @@ class testMainClass(baseMainTestClass):
         # 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
 
@@ -922,7 +713,7 @@ class testMainClass(baseMainTestClass):
             result[key] = value
         return result
 
-    def assert_new_and_stored_output(self, exchange, skip_keys, new_output, stored_output, strict_type_check=True, asserting_key=None):
+    def assert_new_and_stored_output_inner(self, exchange, skip_keys, new_output, stored_output, strict_type_check=True, asserting_key=None):
         if is_null_value(new_output) and is_null_value(stored_output):
             return True
         if not new_output and not stored_output:
@@ -963,9 +754,17 @@ class testMainClass(baseMainTestClass):
                 # when comparing the response we want to allow some flexibility, because a 50.0 can be equal to 50 after saving it to the json file
                 self.assert_static_error(sanitized_new_output == sanitized_stored_output, message_error, stored_output, new_output, asserting_key)
             else:
-                is_boolean = (isinstance(sanitized_new_output, bool)) or (isinstance(sanitized_stored_output, bool))
-                is_string = (isinstance(sanitized_new_output, str)) or (isinstance(sanitized_stored_output, str))
-                is_undefined = (sanitized_new_output is None) or (sanitized_stored_output is None)  # undefined is a perfetly valid value
+                is_computed_bool = (isinstance(sanitized_new_output, bool))
+                is_stored_bool = (isinstance(sanitized_stored_output, bool))
+                is_computed_string = (isinstance(sanitized_new_output, str))
+                is_stored_string = (isinstance(sanitized_stored_output, str))
+                is_computed_undefined = (sanitized_new_output is None)
+                is_stored_undefined = (sanitized_stored_output is None)
+                should_be_same = (is_computed_bool == is_stored_bool) and (is_computed_string == is_stored_string) and (is_computed_undefined == is_stored_undefined)
+                self.assert_static_error(should_be_same, 'output type mismatch', stored_output, new_output, asserting_key)
+                is_boolean = is_computed_bool or is_stored_bool
+                is_string = is_computed_string or is_stored_string
+                is_undefined = is_computed_undefined or is_stored_undefined  # undefined is a perfetly valid value
                 if is_boolean or is_string or is_undefined:
                     if self.lang == 'C#':
                         # tmp c# number comparsion
@@ -996,6 +795,25 @@ class testMainClass(baseMainTestClass):
                         self.assert_static_error(numeric_new_output == numeric_stored_output, message_error, stored_output, new_output, asserting_key)
         return True   # c# requ
 
+    def assert_new_and_stored_output(self, exchange, skip_keys, new_output, stored_output, strict_type_check=True, asserting_key=None):
+        try:
+            return self.assert_new_and_stored_output_inner(exchange, skip_keys, new_output, stored_output, strict_type_check, asserting_key)
+        except Exception as e:
+            if self.info:
+                error_message = self.var_to_string(new_output) + '(calculated)' + ' != ' + self.var_to_string(stored_output) + '(stored)'
+                dump('[TEST_FAILURE_DETAIL]' + error_message)
+            raise e
+
+    def var_to_string(self, obj=None):
+        new_string = None
+        if obj is None:
+            new_string = 'undefined'
+        elif is_null_value(obj):
+            new_string = 'null'
+        else:
+            new_string = json_stringify(obj)
+        return new_string
+
     def assert_static_request_output(self, exchange, type, skip_keys, stored_url, request_url, stored_output, new_output):
         if stored_url != request_url:
             # remove the host part from the url
@@ -1051,13 +869,16 @@ 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:
-            call_exchange_method_dynamically(exchange, method, self.sanitize_data_input(data['input']))
+            if not is_sync():
+                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']))
         except Exception as e:
-            if not (isinstance(e, ProxyError)):
+            if not (isinstance(e, InvalidProxySettings)):
                 raise e
             output = exchange.last_request_body
             request_url = exchange.last_request_url
@@ -1066,18 +887,22 @@ class testMainClass(baseMainTestClass):
             self.assert_static_request_output(exchange, type, skip_keys, data['url'], request_url, call_output, output)
         except Exception as e:
             self.request_tests_failed = True
-            error_message = '[' + self.lang + '][STATIC_REQUEST_TEST_FAILURE]' + '[' + self.exchange_hint(exchange) + ']' + '[' + method + ']' + '[' + data['description'] + ']' + str(e)
+            error_message = '[' + self.lang + '][STATIC_REQUEST]' + '[' + exchange.id + ']' + '[' + method + ']' + '[' + data['description'] + ']' + str(e)
             dump('[TEST_FAILURE]' + error_message)
 
     def test_response_statically(self, exchange, method, skip_keys, data):
         expected_result = exchange.safe_value(data, 'parsedResponse')
         mocked_exchange = set_fetch_response(exchange, data['httpResponse'])
         try:
-            unified_result = 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)
+            if not is_sync():
+                unified_result = 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:
+                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
-            error_message = '[' + self.lang + '][STATIC_RESPONSE_TEST_FAILURE]' + '[' + self.exchange_hint(exchange) + ']' + '[' + method + ']' + '[' + data['description'] + ']' + str(e)
+            self.response_tests_failed = True
+            error_message = '[' + self.lang + '][STATIC_RESPONSE]' + '[' + exchange.id + ']' + '[' + method + ']' + '[' + data['description'] + ']' + str(e)
             dump('[TEST_FAILURE]' + error_message)
         set_fetch_response(exchange, None)  # reset state
 
@@ -1098,6 +923,8 @@ class testMainClass(baseMainTestClass):
             'privateKey': '0xff3bdd43534543d421f05aec535965b5050ad6ac15345435345435453495e771',
             'uid': 'uid',
             'token': 'token',
+            'login': 'login',
+            'accountId': 'accountId',
             'accounts': [{
     'id': 'myAccount',
     'code': 'USDT',
@@ -1120,7 +947,24 @@ class testMainClass(baseMainTestClass):
         # instantiate the exchange and make sure that we sink the requests to avoid an actual request
         exchange = self.init_offline_exchange(exchange_name)
         global_options = exchange.safe_dict(exchange_data, 'options', {})
-        exchange.options = exchange.deep_extend(exchange.options, global_options)  # custom options to be used in the tests
+        # read apiKey/secret from the test file
+        api_key = exchange.safe_string(exchange_data, 'apiKey')
+        if api_key:
+            exchange.apiKey = str(api_key)
+        secret = exchange.safe_string(exchange_data, 'secret')
+        if secret:
+            exchange.secret = str(secret)
+        private_key = exchange.safe_string(exchange_data, 'privateKey')
+        if private_key:
+            exchange.privateKey = str(private_key)
+        wallet_address = exchange.safe_string(exchange_data, 'walletAddress')
+        if wallet_address:
+            exchange.walletAddress = str(wallet_address)
+        accounts = exchange.safe_list(exchange_data, 'accounts')
+        if accounts:
+            exchange.accounts = accounts
+        # exchange.options = exchange.deepExtend (exchange.options, globalOptions); # custom options to be used in the tests
+        exchange.extend_exchange_options(global_options)
         methods = exchange.safe_value(exchange_data, 'methods', {})
         methods_names = list(methods.keys())
         for i in range(0, len(methods_names)):
@@ -1130,26 +974,49 @@ class testMainClass(baseMainTestClass):
                 result = results[j]
                 old_exchange_options = exchange.options  # snapshot options;
                 test_exchange_options = exchange.safe_value(result, 'options', {})
-                exchange.options = exchange.deep_extend(old_exchange_options, test_exchange_options)  # custom options to be used in the tests
+                # exchange.options = exchange.deepExtend (oldExchangeOptions, testExchangeOptions); # custom options to be used in the tests
+                exchange.extend_exchange_options(exchange.deep_extend(old_exchange_options, test_exchange_options))
                 description = exchange.safe_value(result, 'description')
                 if (test_name is not None) and (test_name != description):
                     continue
                 is_disabled = exchange.safe_bool(result, 'disabled', False)
                 if is_disabled:
                     continue
+                disabled_string = exchange.safe_string(result, 'disabled', '')
+                if disabled_string != '':
+                    continue
+                is_disabled_c_sharp = exchange.safe_bool(result, 'disabledCS', False)
+                if is_disabled_c_sharp and (self.lang == 'C#'):
+                    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.deep_extend(old_exchange_options, {})
-        close(exchange)
+                # exchange.options = exchange.deepExtend (oldExchangeOptions, {});
+                exchange.extend_exchange_options(exchange.deep_extend(old_exchange_options, {}))
+        if not is_sync():
+            close(exchange)
         return True   # in c# methods that will be used with promiseAll need to return something
 
     def test_exchange_response_statically(self, exchange_name, exchange_data, test_name=None):
         exchange = self.init_offline_exchange(exchange_name)
+        # read apiKey/secret from the test file
+        api_key = exchange.safe_string(exchange_data, 'apiKey')
+        if api_key:
+            exchange.apiKey = str(api_key)
+        secret = exchange.safe_string(exchange_data, 'secret')
+        if secret:
+            exchange.secret = str(secret)
+        private_key = exchange.safe_string(exchange_data, 'privateKey')
+        if private_key:
+            exchange.privateKey = str(private_key)
+        wallet_address = exchange.safe_string(exchange_data, 'walletAddress')
+        if wallet_address:
+            exchange.walletAddress = str(wallet_address)
         methods = exchange.safe_value(exchange_data, 'methods', {})
         options = exchange.safe_value(exchange_data, 'options', {})
-        exchange.options = exchange.deep_extend(exchange.options, options)  # custom options to be used in the tests
+        # exchange.options = exchange.deepExtend (exchange.options, options); # custom options to be used in the tests
+        exchange.extend_exchange_options(options)
         methods_names = list(methods.keys())
         for i in range(0, len(methods_names)):
             method = methods_names[i]
@@ -1159,7 +1026,8 @@ class testMainClass(baseMainTestClass):
                 description = exchange.safe_value(result, 'description')
                 old_exchange_options = exchange.options  # snapshot options;
                 test_exchange_options = exchange.safe_value(result, 'options', {})
-                exchange.options = exchange.deep_extend(old_exchange_options, test_exchange_options)  # custom options to be used in the tests
+                # exchange.options = exchange.deepExtend (oldExchangeOptions, testExchangeOptions); # custom options to be used in the tests
+                exchange.extend_exchange_options(exchange.deep_extend(old_exchange_options, test_exchange_options))
                 is_disabled = exchange.safe_bool(result, 'disabled', False)
                 if is_disabled:
                     continue
@@ -1174,8 +1042,10 @@ class testMainClass(baseMainTestClass):
                 skip_keys = exchange.safe_value(exchange_data, 'skipKeys', [])
                 self.test_response_statically(exchange, method, skip_keys, result)
                 # reset options
-                exchange.options = exchange.deep_extend(old_exchange_options, {})
-        close(exchange)
+                # exchange.options = exchange.deepExtend (oldExchangeOptions, {});
+                exchange.extend_exchange_options(exchange.deep_extend(old_exchange_options, {}))
+        if not is_sync():
+            close(exchange)
         return True   # in c# methods that will be used with promiseAll need to return something
 
     def get_number_of_tests_from_exchange(self, exchange, exchange_data, test_name=None):
@@ -1195,7 +1065,7 @@ class testMainClass(baseMainTestClass):
         self.run_static_tests('request', target_exchange, test_name)
 
     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
@@ -1216,11 +1086,20 @@ class testMainClass(baseMainTestClass):
                 promises.append(self.test_exchange_request_statically(exchange_name, exchange_data, test_name))
             else:
                 promises.append(self.test_exchange_response_statically(exchange_name, exchange_data, test_name))
-        (promises)
+        try:
+            (promises)
+        except Exception as e:
+            if type == 'request':
+                self.request_tests_failed = True
+            else:
+                self.response_tests_failed = True
+            error_message = '[' + self.lang + '][STATIC_REQUEST]' + str(e)
+            dump('[TEST_FAILURE]' + error_message)
         if self.request_tests_failed or self.response_tests_failed:
             exit_script(1)
         else:
-            success_message = '[' + self.lang + '][TEST_SUCCESS] ' + str(sum) + ' static ' + type + ' tests passed.'
+            prefix = '[SYNC]' if (is_sync()) else ''
+            success_message = '[' + self.lang + ']' + prefix + '[TEST_SUCCESS] ' + str(sum) + ' static ' + type + ' tests passed.'
             dump('[INFO]' + success_message)
 
     def run_static_response_tests(self, exchange_name=None, test=None):
@@ -1233,7 +1112,7 @@ class testMainClass(baseMainTestClass):
         #  -----------------------------------------------------------------------------
         #  --- Init of brokerId tests functions-----------------------------------------
         #  -----------------------------------------------------------------------------
-        promises = [self.test_binance(), self.test_okx(), self.test_cryptocom(), self.test_bybit(), self.test_kucoin(), self.test_kucoinfutures(), self.test_bitget(), self.test_mexc(), self.test_htx(), self.test_woo(), self.test_bitmart(), self.test_coinex(), self.test_bingx(), self.test_phemex(), self.test_blofin(), self.test_hyperliquid(), self.test_coinbaseinternational()]
+        promises = [self.test_binance(), self.test_okx(), self.test_cryptocom(), self.test_bybit(), self.test_kucoin(), self.test_kucoinfutures(), self.test_bitget(), self.test_mexc(), self.test_htx(), self.test_woo(), self.test_bitmart(), self.test_coinex(), self.test_bingx(), self.test_phemex(), self.test_blofin(), self.test_hyperliquid(), self.test_coinbaseinternational(), self.test_coinbase_advanced(), self.test_woofi_pro(), self.test_oxfun(), self.test_xt(), self.test_vertex(), self.test_paradex(), self.test_hashkey(), self.test_coincatch(), self.test_defx()]
         (promises)
         success_message = '[' + self.lang + '][TEST_SUCCESS] brokerId tests passed.'
         dump('[INFO]' + success_message)
@@ -1266,7 +1145,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
-        close(exchange)
+        if not is_sync():
+            close(exchange)
         return True
 
     def test_okx(self):
@@ -1291,7 +1171,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
-        close(exchange)
+        if not is_sync():
+            close(exchange)
         return True
 
     def test_cryptocom(self):
@@ -1305,7 +1186,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
-        close(exchange)
+        if not is_sync():
+            close(exchange)
         return True
 
     def test_bybit(self):
@@ -1319,17 +1201,17 @@ 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.'
-        close(exchange)
+        if not is_sync():
+            close(exchange)
         return True
 
     def test_kucoin(self):
         exchange = self.init_offline_exchange('kucoin')
         req_headers = None
-        options_string = str(exchange.options)
         spot_id = exchange.options['partner']['spot']['id']
         spot_key = exchange.options['partner']['spot']['key']
-        assert spot_id == 'ccxt', 'kucoin - id: ' + spot_id + ' not in options: ' + options_string
-        assert spot_key == '9e58cc35-5b5e-4133-92ec-166e3f077cb8', 'kucoin - key: ' + spot_key + ' not in options: ' + options_string
+        assert spot_id == 'ccxt', 'kucoin - id: ' + spot_id + ' not in options'
+        assert spot_key == '9e58cc35-5b5e-4133-92ec-166e3f077cb8', 'kucoin - key: ' + spot_key + ' not in options.'
         try:
             exchange.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
@@ -1337,54 +1219,54 @@ class testMainClass(baseMainTestClass):
             req_headers = exchange.last_request_headers
         id = 'ccxt'
         assert req_headers['KC-API-PARTNER'] == id, 'kucoin - id: ' + id + ' not in headers.'
-        close(exchange)
+        if not is_sync():
+            close(exchange)
         return True
 
     def test_kucoinfutures(self):
         exchange = self.init_offline_exchange('kucoinfutures')
         req_headers = None
         id = 'ccxtfutures'
-        options_string = str(exchange.options['partner']['future'])
         future_id = exchange.options['partner']['future']['id']
         future_key = exchange.options['partner']['future']['key']
-        assert future_id == id, 'kucoinfutures - id: ' + future_id + ' not in options: ' + options_string
-        assert future_key == '1b327198-f30c-4f14-a0ac-918871282f15', 'kucoinfutures - key: ' + future_key + ' not in options: ' + options_string
+        assert future_id == id, 'kucoinfutures - id: ' + future_id + ' not in options.'
+        assert future_key == '1b327198-f30c-4f14-a0ac-918871282f15', 'kucoinfutures - key: ' + future_key + ' not in options.'
         try:
             exchange.create_order('BTC/USDT:USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
             req_headers = exchange.last_request_headers
         assert req_headers['KC-API-PARTNER'] == id, 'kucoinfutures - id: ' + id + ' not in headers.'
-        close(exchange)
+        if not is_sync():
+            close(exchange)
         return True
 
     def test_bitget(self):
         exchange = self.init_offline_exchange('bitget')
         req_headers = None
         id = 'p4sve'
-        options_string = str(exchange.options)
-        assert exchange.options['broker'] == id, 'bitget - id: ' + id + ' not in options: ' + options_string
+        assert exchange.options['broker'] == id, 'bitget - id: ' + id + ' not in options'
         try:
             exchange.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
             req_headers = exchange.last_request_headers
         assert req_headers['X-CHANNEL-API-CODE'] == id, 'bitget - id: ' + id + ' not in headers.'
-        close(exchange)
+        if not is_sync():
+            close(exchange)
         return True
 
     def test_mexc(self):
         exchange = self.init_offline_exchange('mexc')
         req_headers = None
         id = 'CCXT'
-        options_string = str(exchange.options)
-        assert exchange.options['broker'] == id, 'mexc - id: ' + id + ' not in options: ' + options_string
+        assert exchange.options['broker'] == id, 'mexc - id: ' + id + ' not in options'
         exchange.load_markets()
         try:
             exchange.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
             req_headers = exchange.last_request_headers
-        req_headers_string = str(req_headers) if req_headers is not None else 'undefined'
-        assert req_headers['source'] == id, 'mexc - id: ' + id + ' not in headers: ' + req_headers_string
-        close(exchange)
+        assert req_headers['source'] == id, 'mexc - id: ' + id + ' not in headers.'
+        if not is_sync():
+            close(exchange)
         return True
 
     def test_htx(self):
@@ -1414,7 +1296,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
-        close(exchange)
+        if not is_sync():
+            close(exchange)
         return True
 
     def test_woo(self):
@@ -1439,7 +1322,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
-        close(exchange)
+        if not is_sync():
+            close(exchange)
         return True
 
     def test_bitmart(self):
@@ -1453,7 +1337,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'
-        close(exchange)
+        if not is_sync():
+            close(exchange)
         return True
 
     def test_coinex(self):
@@ -1468,23 +1353,23 @@ 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
-        close(exchange)
+        if not is_sync():
+            close(exchange)
         return True
 
     def test_bingx(self):
         exchange = self.init_offline_exchange('bingx')
         req_headers = None
         id = 'CCXT'
-        options_string = str(exchange.options)
-        assert exchange.options['broker'] == id, 'bingx - id: ' + id + ' not in options: ' + options_string
+        assert exchange.options['broker'] == id, 'bingx - id: ' + id + ' not in options'
         try:
             exchange.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
             # we expect an error here, we're only interested in the headers
             req_headers = exchange.last_request_headers
-        req_headers_string = str(req_headers) if req_headers is not None else 'undefined'
-        assert req_headers['X-SOURCE-KEY'] == id, 'bingx - id: ' + id + ' not in headers: ' + req_headers_string
-        close(exchange)
+        assert req_headers['X-SOURCE-KEY'] == id, 'bingx - id: ' + id + ' not in headers.'
+        if not is_sync():
+            close(exchange)
 
     def test_phemex(self):
         exchange = self.init_offline_exchange('phemex')
@@ -1497,7 +1382,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
-        close(exchange)
+        if not is_sync():
+            close(exchange)
 
     def test_blofin(self):
         exchange = self.init_offline_exchange('blofin')
@@ -1510,7 +1396,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
-        close(exchange)
+        if not is_sync():
+            close(exchange)
 
     def test_hyperliquid(self):
         exchange = self.init_offline_exchange('hyperliquid')
@@ -1522,7 +1409,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
-        close(exchange)
+        if not is_sync():
+            close(exchange)
 
     def test_coinbaseinternational(self):
         exchange = self.init_offline_exchange('coinbaseinternational')
@@ -1536,13 +1424,181 @@ 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'
-        close(exchange)
+        if not is_sync():
+            close(exchange)
         return True
 
-# ***** AUTO-TRANSPILER-END *****
-# *******************************
+    def test_coinbase_advanced(self):
+        exchange = self.init_offline_exchange('coinbase')
+        id = 'ccxt'
+        assert exchange.options['brokerId'] == id, 'id not in options'
+        request = None
+        try:
+            exchange.create_order('BTC/USDC', 'limit', 'buy', 1, 20000)
+        except Exception as e:
+            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 is_sync():
+            close(exchange)
+        return True
 
+    def test_woofi_pro(self):
+        exchange = self.init_offline_exchange('woofipro')
+        exchange.secret = 'secretsecretsecretsecretsecretsecretsecrets'
+        id = 'CCXT'
+        exchange.load_markets()
+        request = None
+        try:
+            exchange.create_order('BTC/USDC:USDC', 'limit', 'buy', 1, 20000)
+        except Exception as e:
+            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 is_sync():
+            close(exchange)
+        return True
 
-if __name__ == '__main__':
-    symbol = argv.symbol if argv.symbol else None
-    (testMainClass().init(argv.exchange, symbol))
+    def test_oxfun(self):
+        exchange = self.init_offline_exchange('oxfun')
+        exchange.secret = 'secretsecretsecretsecretsecretsecretsecrets'
+        id = 1000
+        exchange.load_markets()
+        request = None
+        try:
+            exchange.create_order('BTC/USD:OX', 'limit', 'buy', 1, 20000)
+        except Exception as e:
+            request = json_parse(exchange.last_request_body)
+        orders = request['orders']
+        first = orders[0]
+        broker_id = first['source']
+        assert broker_id == id, 'oxfun - id: ' + str(id) + ' different from  broker_id: ' + str(broker_id)
+        return True
+
+    def test_xt(self):
+        exchange = self.init_offline_exchange('xt')
+        id = 'CCXT'
+        spot_order_request = None
+        try:
+            exchange.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
+        except Exception as e:
+            spot_order_request = json_parse(exchange.last_request_body)
+        spot_media = spot_order_request['media']
+        assert spot_media == id, 'xt - id: ' + id + ' different from swap tag: ' + spot_media
+        swap_order_request = None
+        try:
+            exchange.create_order('BTC/USDT:USDT', 'limit', 'buy', 1, 20000)
+        except Exception as e:
+            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 is_sync():
+            close(exchange)
+        return True
+
+    def test_vertex(self):
+        exchange = self.init_offline_exchange('vertex')
+        exchange.walletAddress = '0xc751489d24a33172541ea451bc253d7a9e98c781'
+        exchange.privateKey = 'c33b1eb4b53108bf52e10f636d8c1236c04c33a712357ba3543ab45f48a5cb0b'
+        exchange.options['v1contracts'] = {
+            'chain_id': '42161',
+            'endpoint_addr': '0xbbee07b3e8121227afcfe1e2b82772246226128e',
+            'book_addrs': ['0x0000000000000000000000000000000000000000', '0x70e5911371472e406f1291c621d1c8f207764d73', '0xf03f457a30e598d5020164a339727ef40f2b8fbc', '0x1c6281a78aa0ed88949c319cba5f0f0de2ce8353', '0xfe653438a1a4a7f56e727509c341d60a7b54fa91', '0xb6304e9a6ca241376a5fc9294daa8fca65ddcdcd', '0x01ec802ae0ab1b2cc4f028b9fe6eb954aef06ed1', '0x0000000000000000000000000000000000000000', '0x9c52d5c4df5a68955ad088a781b4ab364a861e9e', '0x0000000000000000000000000000000000000000', '0x2a3bcda1bb3ef649f3571c96c597c3d2b25edc79', '0x0000000000000000000000000000000000000000', '0x0492ff9807f82856781488015ef7aa5526c0edd6', '0x0000000000000000000000000000000000000000', '0xea884c82418ebc21cd080b8f40ecc4d06a6a6883', '0x0000000000000000000000000000000000000000', '0x5ecf68f983253a818ca8c17a56a4f2fb48d6ec6b', '0x0000000000000000000000000000000000000000', '0xba3f57a977f099905531f7c2f294aad7b56ed254', '0x0000000000000000000000000000000000000000', '0x0ac8c26d207d0c6aabb3644fea18f530c4d6fc8e', '0x0000000000000000000000000000000000000000', '0x8bd80ad7630b3864bed66cf28f548143ea43dc3b', '0x0000000000000000000000000000000000000000', '0x045391227fc4b2cdd27b95f066864225afc9314e', '0x0000000000000000000000000000000000000000', '0x7d512bef2e6cfd7e7f5f6b2f8027e3728eb7b6c3', '0x0000000000000000000000000000000000000000', '0x678a6c5003b56b5e9a81559e9a0df880407c796f', '0x0000000000000000000000000000000000000000', '0x14b5a17208fa98843cc602b3f74e31c95ded3567', '0xe442a89a07b3888ab10579fbb2824aeceff3a282', '0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000', '0xac28ac205275d7c2d6877bea8657cebe04fd9ae9', '0x0000000000000000000000000000000000000000', '0xed811409bfea901e75cb19ba347c08a154e860c9', '0x0000000000000000000000000000000000000000', '0x0f7afcb1612b305626cff84f84e4169ba2d0f12c', '0x0000000000000000000000000000000000000000', '0xe4b8d903db2ce2d3891ef04cfc3ac56330c1b0c3', '0x5f44362bad629846b7455ad9d36bbc3759a3ef62', '0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000', '0xa64e04ed4b223a71e524dc7ebb7f28e422ccfdde', '0x0000000000000000000000000000000000000000', '0x2ee573caab73c1d8cf0ca6bd3589b67de79628a4', '0x0000000000000000000000000000000000000000', '0x01bb96883a8a478d4410387d4aaf11067edc2c74', '0x0000000000000000000000000000000000000000', '0xe7ed0c559d905436a867cddf07e06921d572363c', '0x0000000000000000000000000000000000000000', '0xa94f9e3433c92a5cd1925494811a67b1943557d9', '0x0000000000000000000000000000000000000000', '0xa63de7f89ba1270b85f3dcc193ff1a1390a7c7c7', '0x0000000000000000000000000000000000000000', '0xc8b0b37dffe3a711a076dc86dd617cc203f36121', '0x0000000000000000000000000000000000000000', '0x646df48947ff785fe609969ff634e7be9d1c34cd', '0x0000000000000000000000000000000000000000', '0x42582b404b0bec4a266631a0e178840b107a0c69', '0x0000000000000000000000000000000000000000', '0x36a94bc3edb1b629d1413091e22dc65fa050f17f', '0x0000000000000000000000000000000000000000', '0xb398d00b5a336f0ad33cfb352fd7646171cec442', '0x0000000000000000000000000000000000000000', '0xb4bc3b00de98e1c0498699379f6607b1f00bd5a1', '0x0000000000000000000000000000000000000000', '0xfe8b7baf68952bac2c04f386223d2013c1b4c601', '0x0000000000000000000000000000000000000000', '0x9c8764ec71f175c97c6c2fd558eb6546fcdbea32', '0x0000000000000000000000000000000000000000', '0x94d31188982c8eccf243e555b22dc57de1dba4e1', '0x0000000000000000000000000000000000000000', '0x407c5e2fadd7555be927c028bc358daa907c797a', '0x0000000000000000000000000000000000000000', '0x7e97da2dbbbdd7fb313cf9dc0581ac7cec999c70', '0x0000000000000000000000000000000000000000', '0x7f8d2662f64dd468c423805f98a6579ad59b28fa', '0x0000000000000000000000000000000000000000', '0x3398adf63fed17cbadd6080a1fb771e6a2a55958', '0x0000000000000000000000000000000000000000', '0xba8910a1d7ab62129729047d453091a1e6356170', '0x0000000000000000000000000000000000000000', '0xdc054bce222fe725da0f17abcef38253bd8bb745', '0x0000000000000000000000000000000000000000', '0xca21693467d0a5ea9e10a5a7c5044b9b3837e694', '0x0000000000000000000000000000000000000000', '0xe0b02de2139256dbae55cf350094b882fbe629ea', '0x0000000000000000000000000000000000000000', '0x02c38368a6f53858aab5a3a8d91d73eb59edf9b9', '0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000', '0xfe8c4778843c3cb047ffe7c0c0154a724c05cab9', '0x0000000000000000000000000000000000000000', '0xe2e88862d9b7379e21c82fc4aec8d71bddbcdb4b', '0x0000000000000000000000000000000000000000', '0xbbaff9e73b30f9cea5c01481f12de75050947fd6', '0x0000000000000000000000000000000000000000', '0xa20f6f381fe0fec5a1035d37ebf8890726377ab9', '0x0000000000000000000000000000000000000000', '0xbad68032d012bf35d3a2a177b242e86684027ed0', '0x0000000000000000000000000000000000000000', '0x0e61ca37f0c67e8a8794e45e264970a2a23a513c', '0x0000000000000000000000000000000000000000', '0xa77b7048e378c5270b15918449ededf87c3a3db3', '0x0000000000000000000000000000000000000000', '0x15afca1e6f02b556fa6551021b3493a1e4a7f44f'],
+        }
+        id = 5930043274845996
+        exchange.load_markets()
+        request = None
+        try:
+            exchange.create_order('BTC/USDC:USDC', 'limit', 'buy', 1, 20000)
+        except Exception as e:
+            request = json_parse(exchange.last_request_body)
+        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 is_sync():
+            close(exchange)
+        return True
+
+    def test_paradex(self):
+        exchange = self.init_offline_exchange('paradex')
+        exchange.walletAddress = '0xc751489d24a33172541ea451bc253d7a9e98c781'
+        exchange.privateKey = 'c33b1eb4b53108bf52e10f636d8c1236c04c33a712357ba3543ab45f48a5cb0b'
+        exchange.options['authToken'] = 'token'
+        exchange.options['systemConfig'] = {
+            'starknet_gateway_url': 'https://potc-testnet-sepolia.starknet.io',
+            'starknet_fullnode_rpc_url': 'https://pathfinder.api.testnet.paradex.trade/rpc/v0_7',
+            'starknet_chain_id': 'PRIVATE_SN_POTC_SEPOLIA',
+            'block_explorer_url': 'https://voyager.testnet.paradex.trade/',
+            'paraclear_address': '0x286003f7c7bfc3f94e8f0af48b48302e7aee2fb13c23b141479ba00832ef2c6',
+            'paraclear_decimals': 8,
+            'paraclear_account_proxy_hash': '0x3530cc4759d78042f1b543bf797f5f3d647cde0388c33734cf91b7f7b9314a9',
+            'paraclear_account_hash': '0x41cb0280ebadaa75f996d8d92c6f265f6d040bb3ba442e5f86a554f1765244e',
+            'oracle_address': '0x2c6a867917ef858d6b193a0ff9e62b46d0dc760366920d631715d58baeaca1f',
+            'bridged_tokens': [{
+    'name': 'TEST USDC',
+    'symbol': 'USDC',
+    'decimals': 6,
+    'l1_token_address': '0x29A873159D5e14AcBd63913D4A7E2df04570c666',
+    'l1_bridge_address': '0x8586e05adc0C35aa11609023d4Ae6075Cb813b4C',
+    'l2_token_address': '0x6f373b346561036d98ea10fb3e60d2f459c872b1933b50b21fe6ef4fda3b75e',
+    'l2_bridge_address': '0x46e9237f5408b5f899e72125dd69bd55485a287aaf24663d3ebe00d237fc7ef',
+}],
+            'l1_core_contract_address': '0x582CC5d9b509391232cd544cDF9da036e55833Af',
+            'l1_operator_address': '0x11bACdFbBcd3Febe5e8CEAa75E0Ef6444d9B45FB',
+            'l1_chain_id': '11155111',
+            'liquidation_fee': '0.2',
+        }
+        req_headers = None
+        id = 'CCXT'
+        assert exchange.options['broker'] == id, 'paradex - id: ' + id + ' not in options'
+        exchange.load_markets()
+        try:
+            exchange.create_order('BTC/USD:USDC', 'limit', 'buy', 1, 20000)
+        except Exception as e:
+            req_headers = exchange.last_request_headers
+        assert req_headers['PARADEX-PARTNER'] == id, 'paradex - id: ' + id + ' not in headers'
+        if not is_sync():
+            close(exchange)
+        return True
+
+    def test_hashkey(self):
+        exchange = self.init_offline_exchange('hashkey')
+        req_headers = None
+        id = '10000700011'
+        try:
+            exchange.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
+        except Exception as e:
+            # 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 is_sync():
+            close(exchange)
+        return True
+
+    def test_coincatch(self):
+        exchange = self.init_offline_exchange('coincatch')
+        req_headers = None
+        id = '47cfy'
+        try:
+            exchange.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
+        except Exception as e:
+            # we expect an error here, we're only interested in the headers
+            req_headers = exchange.last_request_headers
+        assert req_headers['X-CHANNEL-API-CODE'] == id, 'coincatch - id: ' + id + ' not in headers.'
+        if not is_sync():
+            close(exchange)
+        return True
+
+    def test_defx(self):
+        exchange = self.init_offline_exchange('defx')
+        req_headers = None
+        try:
+            exchange.create_order('DOGE/USDC:USDC', 'limit', 'buy', 100, 1)
+        except Exception as e:
+            # we expect an error here, we're only interested in the headers
+            req_headers = exchange.last_request_headers
+        id = 'ccxt'
+        assert req_headers['X-DEFX-SOURCE'] == id, 'defx - id: ' + id + ' not in headers.'
+        if not is_sync():
+            close(exchange)
+        return True