ccxt 4.4.52__py2.py3-none-any.whl → 4.4.53__py2.py3-none-any.whl

ccxt/test/tests_sync.py

@@ -46,16 +46,16 @@ class testMainClass:
         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)
-            return
+            return True
         if self.response_tests:
             self.run_static_response_tests(exchange_id, symbol_argv)
-            return
+            return True
         if self.request_tests:
             self.run_static_request_tests(exchange_id, symbol_argv)  # symbol here is the testname
-            return
+            return True
         if self.id_tests:
             self.run_broker_id_tests()
-            return
+            return True
         new_line = '\n'
         dump(new_line + '' + new_line + '' + '[INFO] TESTING ', self.ext, {
             'exchange': exchange_id,
@@ -100,6 +100,7 @@ class testMainClass:
             self.test_files = get_test_files_sync(properties, self.ws_tests)
         else:
             self.test_files = get_test_files(properties, self.ws_tests)
+        return True
 
     def load_credentials_from_env(self, exchange):
         exchange_id = exchange.id
@@ -122,8 +123,12 @@ class testMainClass:
         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 {}
-        local_settings = io_file_read(keys_local) if keys_local_exists else {}
+        global_settings = {}
+        if keys_global_exists:
+            global_settings = io_file_read(keys_global)
+        local_settings = {}
+        if keys_local_exists:
+            local_settings = io_file_read(keys_local)
         all_settings = exchange.deep_extend(global_settings, local_settings)
         exchange_settings = exchange.safe_value(all_settings, exchange_id, {})
         if exchange_settings:
@@ -174,7 +179,7 @@ class testMainClass:
             exchange.options['checksum'] = False
         # todo: temporary skip for php
         if 'OrderBook' in method_name and self.ext == 'php':
-            return
+            return True
         skipped_properties_for_method = self.get_skips(exchange, method_name)
         is_load_markets = (method_name == 'loadMarkets')
         is_fetch_currencies = (method_name == 'fetchCurrencies')
@@ -182,7 +187,7 @@ class testMainClass:
         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
+            return True
         skip_message = None
         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)):
@@ -200,7 +205,7 @@ class testMainClass:
         if skip_message:
             if self.info:
                 dump(self.add_padding(skip_message, 25), name, method_name)
-            return
+            return True
         if self.info:
             args_stringified = '(' + exchange.json(args) + ')'  # args.join() breaks when we provide a list of symbols or multidimensional array; "args.toString()" breaks bcz of "array to string conversion"
             dump(self.add_padding('[INFO] TESTING', 25), name, method_name, args_stringified)
@@ -213,7 +218,7 @@ class testMainClass:
         # add to the list of successed tests
         if is_public:
             self.checked_public_tests[method_name] = True
-        return
+        return True
 
     def get_skips(self, exchange, method_name):
         final_skips = {}
@@ -282,10 +287,10 @@ class testMainClass:
                         is_on_maintenance = (isinstance(e, OnMaintenance))
                         is_exchange_not_available = (isinstance(e, ExchangeNotAvailable))
                         should_fail = None
-                        return_success = None
+                        ret_success = None
                         if is_load_markets:
                             # if "loadMarkets" does not succeed, we must return "false" to caller method, to stop tests continual
-                            return_success = False
+                            ret_success = False
                             # we might not break exchange tests, if exchange is on maintenance at this moment
                             if is_on_maintenance:
                                 should_fail = False
@@ -296,20 +301,19 @@ class testMainClass:
                             if is_exchange_not_available and not is_on_maintenance:
                                 # break exchange tests if "ExchangeNotAvailable" exception is thrown, but it's not maintenance
                                 should_fail = True
-                                return_success = False
+                                ret_success = False
                             else:
                                 # in all other cases of OperationFailed, show Warning, but don't mark test as failed
                                 should_fail = False
-                                return_success = True
+                                ret_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', ' | ', exchange.id, method_name, args_stringified, exception_message(e))
-                        return return_success
+                        return ret_success
                     else:
                         # wait and retry again
                         # (increase wait time on every retry)
                         exchange.sleep((i + 1) * 1000)
-                        continue
                 else:
                     # if it's loadMarkets, then fail test, because it's mandatory for tests
                     if is_load_markets:
@@ -373,6 +377,7 @@ class testMainClass:
                 tests['fetchPremiumIndexOHLCV'] = [symbol]
         self.public_tests = tests
         self.run_tests(exchange, tests, True)
+        return True
 
     def run_tests(self, exchange, tests, is_public_test):
         test_names = list(tests.keys())
@@ -397,6 +402,7 @@ class testMainClass:
             dump('[TEST_FAILURE]', exchange.id, test_prefix_string, 'Failed methods : ' + errors_string)
         if self.info:
             dump(self.add_padding('[INFO] END ' + test_prefix_string + ' ' + exchange.id, 25))
+        return True
 
     def load_exchange(self, exchange):
         result = self.test_safe('loadMarkets', exchange, [], True)
@@ -517,11 +523,12 @@ class testMainClass:
             if exchange.has['swap'] and swap_symbol is not None:
                 exchange.options['defaultType'] = 'swap'
                 self.run_private_tests(exchange, swap_symbol)
+        return True
 
     def run_private_tests(self, exchange, symbol):
         if not exchange.check_required_credentials(False):
             dump('[INFO] Skipping private tests', 'Keys not found')
-            return
+            return True
         code = self.get_exchange_code(exchange)
         # if (exchange.deepExtendedTest) {
         #     test ('InvalidNonce', exchange, symbol);
@@ -591,14 +598,14 @@ class testMainClass:
         proxy_test_name = self.proxy_test_file_name
         # todo: temporary skip for sync py
         if self.ext == 'py' and is_sync():
-            return
+            return True
         # try proxy several times
         max_retries = 3
         exception = None
         for j in range(0, max_retries):
             try:
                 self.test_method(proxy_test_name, exchange, [], True)
-                return   # if successfull, then end the test
+                return True   # if successfull, then end the test
             except Exception as e:
                 exception = e
                 exchange.sleep(j * 1000)
@@ -607,12 +614,13 @@ class testMainClass:
             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))
+            dump('[TEST_WARNING]' + error_message)
+        return True
 
     def start_test(self, exchange, symbol):
         # we do not need to test aliases
         if exchange.alias:
-            return
+            return True
         if self.sandbox or get_exchange_prop(exchange, 'sandbox'):
             exchange.set_sandbox_mode(True)
         try:
@@ -620,7 +628,7 @@ class testMainClass:
             if not result:
                 if not is_sync():
                     close(exchange)
-                return
+                return True
             # 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);
@@ -795,13 +803,15 @@ class testMainClass:
         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):
+        res = True
         try:
-            return self.assert_new_and_stored_output_inner(exchange, skip_keys, new_output, stored_output, strict_type_check, asserting_key)
+            res = 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
+        return res
 
     def var_to_string(self, obj=None):
         new_string = None
@@ -830,11 +840,11 @@ class testMainClass:
                 if (stored_url_query is None) and (new_url_query is None):
                     # might be a get request without any query parameters
                     # example: https://api.gateio.ws/api/v4/delivery/usdt/positions
-                    return
+                    return True
                 stored_url_params = self.urlencoded_to_dict(stored_url_query)
                 new_url_params = self.urlencoded_to_dict(new_url_query)
                 self.assert_new_and_stored_output(exchange, skip_keys, new_url_params, stored_url_params)
-                return
+                return True
         if type == 'json' and (stored_output is not None) and (new_output is not None):
             if isinstance(stored_output, str):
                 stored_output = json_parse(stored_output)
@@ -851,6 +861,7 @@ class testMainClass:
                 stored_output = self.urlencoded_to_dict(stored_output)
                 new_output = self.urlencoded_to_dict(new_output)
         self.assert_new_and_stored_output(exchange, skip_keys, new_output, stored_output)
+        return True
 
     def assert_static_response_output(self, exchange, skip_keys, computed_result, stored_result):
         self.assert_new_and_stored_output(exchange, skip_keys, computed_result, stored_result, False)
@@ -886,8 +897,9 @@ class testMainClass:
             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]' + '[' + exchange.id + ']' + '[' + method + ']' + '[' + data['description'] + ']' + str(e)
+            error_message = '[' + self.lang + '][STATIC_REQUEST]' + '[' + exchange.id + ']' + '[' + method + ']' + '[' + data['description'] + ']' + exception_message(e)
             dump('[TEST_FAILURE]' + error_message)
+        return True
 
     def test_response_statically(self, exchange, method, skip_keys, data):
         expected_result = exchange.safe_value(data, 'parsedResponse')
@@ -901,9 +913,10 @@ class testMainClass:
                 self.assert_static_response_output(mocked_exchange, skip_keys, unified_result_sync, expected_result)
         except Exception as e:
             self.response_tests_failed = True
-            error_message = '[' + self.lang + '][STATIC_RESPONSE]' + '[' + exchange.id + ']' + '[' + method + ']' + '[' + data['description'] + ']' + str(e)
+            error_message = '[' + self.lang + '][STATIC_RESPONSE]' + '[' + exchange.id + ']' + '[' + method + ']' + '[' + data['description'] + ']' + exception_message(e)
             dump('[TEST_FAILURE]' + error_message)
         set_fetch_response(exchange, None)  # reset state
+        return True
 
     def init_offline_exchange(self, exchange_name):
         markets = self.load_markets_from_file(exchange_name)
@@ -939,7 +952,8 @@ class testMainClass:
                 'leverageBrackets': {},
             },
         })
-        exchange.currencies = currencies  # not working in python if assigned  in the config dict
+        exchange.currencies = currencies
+        # not working in python if assigned  in the config dict
         return exchange
 
     def test_exchange_request_statically(self, exchange_name, exchange_data, test_name=None):
@@ -987,6 +1001,9 @@ class testMainClass:
                 is_disabled_c_sharp = exchange.safe_bool(result, 'disabledCS', False)
                 if is_disabled_c_sharp and (self.lang == 'C#'):
                     continue
+                is_disabled_go = exchange.safe_bool(result, 'disabledGO', False)
+                if is_disabled_go and (self.lang == 'GO'):
+                    continue
                 type = exchange.safe_string(exchange_data, 'outputType')
                 skip_keys = exchange.safe_value(exchange_data, 'skipKeys', [])
                 self.test_request_statically(exchange, method, result, type, skip_keys)
@@ -1038,6 +1055,9 @@ class testMainClass:
                     continue
                 if (test_name is not None) and (test_name != description):
                     continue
+                is_disabled_go = exchange.safe_bool(result, 'disabledGO', False)
+                if is_disabled_go and (self.lang == 'GO'):
+                    continue
                 skip_keys = exchange.safe_value(exchange_data, 'skipKeys', [])
                 self.test_response_statically(exchange, method, skip_keys, result)
                 # reset options
@@ -1062,12 +1082,13 @@ class testMainClass:
 
     def run_static_request_tests(self, target_exchange=None, test_name=None):
         self.run_static_tests('request', target_exchange, test_name)
+        return True
 
     def run_static_tests(self, type, target_exchange=None, test_name=None):
         folder = get_root_dir() + './ts/src/test/static/' + type + '/'
         static_data = self.load_static_data(folder, target_exchange)
         if static_data is None:
-            return
+            return True
         exchanges = list(static_data.keys())
         exchange = init_exchange('Exchange', {})  # tmp to do the calculations until we have the ast-transpiler transpiling this code
         promises = []
@@ -1092,7 +1113,7 @@ class testMainClass:
                 self.request_tests_failed = True
             else:
                 self.response_tests_failed = True
-            error_message = '[' + self.lang + '][STATIC_REQUEST]' + str(e)
+            error_message = '[' + self.lang + '][STATIC_REQUEST]' + exception_message(e)
             dump('[TEST_FAILURE]' + error_message)
         if self.request_tests_failed or self.response_tests_failed:
             exit_script(1)
@@ -1106,6 +1127,7 @@ class testMainClass:
         #  --- Init of mockResponses tests functions------------------------------------
         #  -----------------------------------------------------------------------------
         self.run_static_tests('response', exchange_name, test)
+        return True
 
     def run_broker_id_tests(self):
         #  -----------------------------------------------------------------------------
@@ -1116,6 +1138,7 @@ class testMainClass:
         success_message = '[' + self.lang + '][TEST_SUCCESS] brokerId tests passed.'
         dump('[INFO]' + success_message)
         exit_script(0)
+        return True
 
     def test_binance(self):
         exchange = self.init_offline_exchange('binance')
@@ -1369,6 +1392,7 @@ class testMainClass:
         assert req_headers['X-SOURCE-KEY'] == id, 'bingx - id: ' + id + ' not in headers.'
         if not is_sync():
             close(exchange)
+        return True
 
     def test_phemex(self):
         exchange = self.init_offline_exchange('phemex')
@@ -1383,6 +1407,7 @@ class testMainClass:
         assert client_order_id.startswith(id_string), 'phemex - clOrdID: ' + client_order_id + ' does not start with id: ' + id_string
         if not is_sync():
             close(exchange)
+        return True
 
     def test_blofin(self):
         exchange = self.init_offline_exchange('blofin')
@@ -1397,6 +1422,7 @@ class testMainClass:
         assert broker_id.startswith(id_string), 'blofin - brokerId: ' + broker_id + ' does not start with id: ' + id_string
         if not is_sync():
             close(exchange)
+        return True
 
     def test_hyperliquid(self):
         exchange = self.init_offline_exchange('hyperliquid')
@@ -1410,6 +1436,7 @@ class testMainClass:
         assert broker_id == id, 'hyperliquid - brokerId: ' + broker_id + ' does not start with id: ' + id
         if not is_sync():
             close(exchange)
+        return True
 
     def test_coinbaseinternational(self):
         exchange = self.init_offline_exchange('coinbaseinternational')

ccxt/timex.py

@@ -313,17 +313,20 @@ class timex(Exchange, ImplicitAPI):
                         'limit': 100,  # todo
                         'daysBack': 100000,  # todo
                         'untilDays': 100000,  # todo
+                        'symbolRequired': False,
                     },
                     'fetchOrder': {
                         'marginMode': False,
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': False,
                     },
                     'fetchOpenOrders': {
                         'marginMode': False,
                         'limit': 100,  # todo
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': False,
                     },
                     'fetchOrders': None,  # todo
                     'fetchClosedOrders': {
@@ -334,6 +337,7 @@ class timex(Exchange, ImplicitAPI):
                         'untilDays': 100000,  # todo
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': False,
                     },
                     'fetchOHLCV': {
                         'limit': None,

ccxt/tokocrypto.py

@@ -650,17 +650,20 @@ class tokocrypto(Exchange, ImplicitAPI):
                         'limit': 1000,
                         'daysBack': 100000,  # todo
                         'untilDays': 100000,  # todo
+                        'symbolRequired': True,
                     },
                     'fetchOrder': {
                         'marginMode': False,
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': False,
                     },
                     'fetchOpenOrders': {
                         'marginMode': False,
                         'limit': 1000,
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': True,
                     },
                     'fetchOrders': {
                         'marginMode': False,
@@ -669,6 +672,7 @@ class tokocrypto(Exchange, ImplicitAPI):
                         'untilDays': 100000,
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': True,
                     },
                     'fetchClosedOrders': {
                         'marginMode': False,
@@ -678,6 +682,7 @@ class tokocrypto(Exchange, ImplicitAPI):
                         'untilDays': 100000,  # todo
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': True,
                     },
                     'fetchOHLCV': {
                         'limit': 1000,

ccxt/tradeogre.py

@@ -195,12 +195,14 @@ class tradeogre(Exchange, ImplicitAPI):
                         'marginMode': False,
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': False,
                     },
                     'fetchOpenOrders': {
                         'marginMode': False,
                         'limit': None,
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': False,
                     },
                     'fetchOrders': None,
                     'fetchClosedOrders': None,

ccxt/upbit.py

@@ -5,7 +5,7 @@
 
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.upbit import ImplicitAPI
-from ccxt.base.types import Balances, Currency, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface, Transaction
+from ccxt.base.types import Balances, Currency, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, OrderBooks, Trade, TradingFeeInterface, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -202,12 +202,14 @@ class upbit(Exchange, ImplicitAPI):
                         'marginMode': False,
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': False,
                     },
                     'fetchOpenOrders': {
                         'marginMode': True,
                         'limit': 100,
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': False,
                     },
                     'fetchOrders': None,  # todo
                     'fetchClosedOrders': {
@@ -218,6 +220,7 @@ class upbit(Exchange, ImplicitAPI):
                         'untilDays': 7,
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': False,
                     },
                     'fetchOHLCV': {
                         'limit': 200,
@@ -588,7 +591,7 @@ class upbit(Exchange, ImplicitAPI):
         #
         return self.parse_balance(response)
 
-    def fetch_order_books(self, symbols: Strings = None, limit: Int = None, params={}):
+    def fetch_order_books(self, symbols: Strings = None, limit: Int = None, params={}) -> OrderBooks:
         """
 
         https://docs.upbit.com/reference/%ED%98%B8%EA%B0%80-%EC%A0%95%EB%B3%B4-%EC%A1%B0%ED%9A%8C

ccxt/vertex.py

@@ -361,17 +361,20 @@ class vertex(Exchange, ImplicitAPI):
                         'limit': 500,
                         'daysBack': 100000,  # todo
                         'untilDays': None,
+                        'symbolRequired': False,
                     },
                     'fetchOrder': {
                         'marginMode': False,
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': True,
                     },
                     'fetchOpenOrders': {
                         'marginMode': False,
                         'limit': 500,
                         'trigger': True,
                         'trailing': False,
+                        'symbolRequired': False,
                     },
                     'fetchOrders': None,  # todo, only for trigger
                     'fetchClosedOrders': None,  # todo through fetchOrders
@@ -2394,14 +2397,15 @@ class vertex(Exchange, ImplicitAPI):
             'digests': ids,
             'nonce': nonce,
         }
+        productIds = cancels['productIds']
         marketIdNum = self.parse_to_numeric(marketId)
         for i in range(0, len(ids)):
-            cancels['productIds'].append(marketIdNum)
+            productIds.append(marketIdNum)
         request = {
             'cancel_orders': {
                 'tx': {
                     'sender': cancels['sender'],
-                    'productIds': cancels['productIds'],
+                    'productIds': productIds,
                     'digests': cancels['digests'],
                     'nonce': self.number_to_string(cancels['nonce']),
                 },

ccxt/wavesexchange.py

@@ -388,17 +388,20 @@ class wavesexchange(Exchange, ImplicitAPI):
                         'limit': 100,  # todo
                         'daysBack': 100000,  # todo
                         'untilDays': 100000,  # todo
+                        'symbolRequired': False,
                     },
                     'fetchOrder': {
                         'marginMode': False,
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': False,
                     },
                     'fetchOpenOrders': {
                         'marginMode': False,
                         'limit': 100,  # todo
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': False,
                     },
                     'fetchOrders': {
                         'marginMode': False,
@@ -407,6 +410,7 @@ class wavesexchange(Exchange, ImplicitAPI):
                         'untilDays': None,
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': True,
                     },  # todo
                     'fetchClosedOrders': {
                         'marginMode': False,
@@ -416,6 +420,7 @@ class wavesexchange(Exchange, ImplicitAPI):
                         'untilDays': 100000,  # todo
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': False,
                     },
                     'fetchOHLCV': {
                         'limit': None,  # todo
@@ -754,6 +759,7 @@ class wavesexchange(Exchange, ImplicitAPI):
             raise AuthenticationError(self.id + ' apiKey must be a base58 encoded public key')
         if len(hexSecretKeyBytes) != 64:
             raise AuthenticationError(self.id + ' secret must be a base58 encoded private key')
+        return True
 
     def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
         query = self.omit(params, self.extract_params(path))
@@ -1007,6 +1013,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         :param int [since]: timestamp in ms of the earliest candle to fetch
         :param int [limit]: the maximum amount of candles to fetch
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param int [params.until]: timestamp in ms of the latest candle to fetch
         :returns int[][]: A list of candles ordered, open, high, low, close, volume
         """
         self.load_markets()
@@ -1017,19 +1024,29 @@ class wavesexchange(Exchange, ImplicitAPI):
             'interval': self.safe_string(self.timeframes, timeframe, timeframe),
         }
         allowedCandles = self.safe_integer(self.options, 'allowedCandles', 1440)
+        until = self.safe_integer(params, 'until')
+        untilIsDefined = until is not None
         if limit is None:
             limit = allowedCandles
         limit = min(allowedCandles, limit)
         duration = self.parse_timeframe(timeframe) * 1000
         if since is None:
-            durationRoundedTimestamp = self.parse_to_int(self.milliseconds() / duration) * duration
+            now = self.milliseconds()
+            timeEnd = until if untilIsDefined else now
+            durationRoundedTimestamp = self.parse_to_int(timeEnd / duration) * duration
             delta = (limit - 1) * duration
             timeStart = durationRoundedTimestamp - delta
             request['timeStart'] = str(timeStart)
+            if untilIsDefined:
+                request['timeEnd'] = str(until)
         else:
             request['timeStart'] = str(since)
-            timeEnd = self.sum(since, duration * limit)
-            request['timeEnd'] = str(timeEnd)
+            if untilIsDefined:
+                request['timeEnd'] = str(until)
+            else:
+                timeEnd = self.sum(since, duration * limit)
+                request['timeEnd'] = str(timeEnd)
+        params = self.omit(params, 'until')
         response = self.publicGetCandlesBaseIdQuoteId(self.extend(request, params))
         #
         #     {

ccxt/wazirx.py

@@ -250,6 +250,7 @@ class wazirx(Exchange, ImplicitAPI):
                         'limit': None,
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': True,
                     },
                     'fetchOrders': {
                         'marginMode': False,
@@ -258,6 +259,7 @@ class wazirx(Exchange, ImplicitAPI):
                         'untilDays': 100000,  # todo
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': True,
                     },
                     'fetchClosedOrders': None,
                     'fetchOHLCV': {

ccxt/whitebit.py

@@ -322,6 +322,7 @@ class whitebit(Exchange, ImplicitAPI):
                         'limit': 100,
                         'daysBack': None,
                         'untilDays': None,
+                        'symbolRequired': False,
                     },
                     'fetchOrder': None,
                     'fetchOpenOrders': {
@@ -329,6 +330,7 @@ class whitebit(Exchange, ImplicitAPI):
                         'limit': 100,
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': False,
                     },
                     'fetchOrders': None,  # todo
                     'fetchClosedOrders': {
@@ -339,6 +341,7 @@ class whitebit(Exchange, ImplicitAPI):
                         'untilDays': None,
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': False,
                     },
                     'fetchOHLCV': {
                         'limit': 1440,
@@ -1314,11 +1317,9 @@ class whitebit(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
-        req = {
-            'cost': cost,
-        }
+        params['cost'] = cost
         # only buy side is supported
-        return self.create_order(symbol, 'market', side, 0, None, self.extend(req, params))
+        return self.create_order(symbol, 'market', side, 0, None, params)
 
     def create_market_buy_order_with_cost(self, symbol: str, cost: float, params={}) -> Order:
         """