ccxt 4.2.30__py2.py3-none-any.whl → 4.2.34__py2.py3-none-any.whl

ccxt/test/test_sync.py

@@ -26,7 +26,7 @@ import ccxt.pro as ccxtpro  # noqa: E402
 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 ExchangeError
 from ccxt.base.errors import ExchangeNotAvailable
 from ccxt.base.errors import OnMaintenance
 from ccxt.base.errors import AuthenticationError
@@ -127,6 +127,7 @@ class baseMainTestClass():
     response_tests_failed = False
     response_tests = False
     ws_tests = False
+    load_keys = False
     skipped_methods = {}
     check_public_tests = {}
     test_files = {}
@@ -145,6 +146,9 @@ 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)
 
@@ -269,6 +273,7 @@ class testMainClass(baseMainTestClass):
         self.private_test = get_cli_arg_value('--private')
         self.private_test_only = get_cli_arg_value('--privateOnly')
         self.sandbox = get_cli_arg_value('--sandbox')
+        self.load_keys = get_cli_arg_value('--loadKeys')
         self.ws_tests = get_cli_arg_value('--ws')
 
     def init(self, exchange_id, symbol_argv):
@@ -287,11 +292,12 @@ class testMainClass(baseMainTestClass):
             self.run_broker_id_tests()
             return
         symbol_str = symbol_argv if symbol_argv is not None else 'all'
-        dump(self.new_line + '' + self.new_line + '' + '[INFO] TESTING ', self.ext, {
+        exchange_object = {
             'exchange': exchange_id,
             'symbol': symbol_str,
             'isWs': self.ws_tests,
-        }, self.new_line)
+        }
+        dump(self.new_line + '' + self.new_line + '' + '[INFO] TESTING ', self.ext, json_stringify(exchange_object), self.new_line)
         exchange_args = {
             'verbose': self.verbose,
             'debug': self.debug,
@@ -299,6 +305,8 @@ class testMainClass(baseMainTestClass):
             'timeout': 30000,
         }
         exchange = init_exchange(exchange_id, exchange_args, self.ws_tests)
+        if exchange.alias:
+            exit_script(0)
         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)
@@ -372,7 +380,7 @@ class testMainClass(baseMainTestClass):
         # others
         timeout = exchange.safe_value(skipped_settings_for_exchange, 'timeout')
         if timeout is not None:
-            exchange.timeout = timeout
+            exchange.timeout = exchange.parse_to_int(timeout)
         if get_cli_arg_value('--useProxy'):
             exchange.http_proxy = exchange.safe_string(skipped_settings_for_exchange, 'httpProxy')
             exchange.https_proxy = exchange.safe_string(skipped_settings_for_exchange, 'httpsProxy')
@@ -444,6 +452,7 @@ class testMainClass(baseMainTestClass):
         # if it was passed successfully, add to the list of successfull tests
         if is_public:
             self.checked_public_tests[method_name] = True
+        return
 
     def test_safe(self, method_name, exchange, args=[], is_public=False):
         # `testSafe` method does not throw an exception, instead mutes it. The reason we
@@ -504,6 +513,7 @@ class testMainClass(baseMainTestClass):
                     else:
                         dump('[TEST_FAILURE]', exception_message(e), self.exchange_hint(exchange), method_name, args_stringified)
                         return False
+        return True
 
     def run_public_tests(self, exchange, symbol):
         tests = {
@@ -700,7 +710,7 @@ class testMainClass(baseMainTestClass):
             dump('[INFO] Skipping private tests', 'Keys not found')
             return
         code = self.get_exchange_code(exchange)
-        # if (exchange.extendedTest) {
+        # if (exchange.deepExtendedTest) {
         #     test ('InvalidNonce', exchange, symbol);
         #     test ('OrderNotFound', exchange, symbol);
         #     test ('InvalidOrder', exchange, symbol);
@@ -777,7 +787,7 @@ class testMainClass(baseMainTestClass):
                 exception = e
         # if exception was set, then throw it
         if exception:
-            raise ExchangeError('[TEST_FAILURE] Failed ' + proxy_test_name + ' : ' + exception_message(exception))
+            error_message = '[TEST_FAILURE] Failed ' + proxy_test_name + ' : ' + exception_message(exception)
 
     def start_test(self, exchange, symbol):
         # we do not need to test aliases
@@ -880,9 +890,9 @@ class testMainClass(baseMainTestClass):
 
     def assert_new_and_stored_output(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
+            return True
         if not new_output and not stored_output:
-            return
+            return True
         if (isinstance(stored_output, dict)) and (isinstance(new_output, dict)):
             stored_output_keys = list(stored_output.keys())
             new_output_keys = list(new_output.keys())
@@ -914,7 +924,7 @@ class testMainClass(baseMainTestClass):
             new_output_string = str(sanitized_new_output) if sanitized_new_output else 'undefined'
             stored_output_string = str(sanitized_stored_output) if sanitized_stored_output else 'undefined'
             message_error = 'output value mismatch:' + new_output_string + ' != ' + stored_output_string
-            if strict_type_check:
+            if strict_type_check and (self.lang != 'C#'):
                 # upon building the request we want strict type check to make sure all the types are correct
                 # 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)
@@ -923,11 +933,34 @@ class testMainClass(baseMainTestClass):
                 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
                 if is_boolean or is_string or is_undefined:
-                    self.assert_static_error(new_output_string == stored_output_string, message_error, stored_output, new_output, asserting_key)
+                    if self.lang == 'C#':
+                        # tmp c# number comparsion
+                        is_number = False
+                        try:
+                            exchange.parse_to_numeric(sanitized_new_output)
+                            is_number = True
+                        except Exception as e:
+                            # if we can't parse it to number, then it's not a number
+                            is_number = False
+                        if is_number:
+                            self.assert_static_error(exchange.parse_to_numeric(sanitized_new_output) == exchange.parse_to_numeric(sanitized_stored_output), message_error, stored_output, new_output, asserting_key)
+                            return True
+                        else:
+                            self.assert_static_error(convert_ascii(new_output_string) == convert_ascii(stored_output_string), message_error, stored_output, new_output, asserting_key)
+                            return True
+                    else:
+                        self.assert_static_error(convert_ascii(new_output_string) == convert_ascii(stored_output_string), message_error, stored_output, new_output, asserting_key)
+                        return True
                 else:
-                    numeric_new_output = exchange.parse_to_numeric(new_output_string)
-                    numeric_stored_output = exchange.parse_to_numeric(stored_output_string)
-                    self.assert_static_error(numeric_new_output == numeric_stored_output, message_error, stored_output, new_output, asserting_key)
+                    if self.lang == 'C#':
+                        stringified_new_output = exchange.number_to_string(sanitized_new_output)
+                        stringified_stored_output = exchange.number_to_string(sanitized_stored_output)
+                        self.assert_static_error(str(stringified_new_output) == str(stringified_stored_output), message_error, stored_output, new_output, asserting_key)
+                    else:
+                        numeric_new_output = exchange.parse_to_numeric(new_output_string)
+                        numeric_stored_output = exchange.parse_to_numeric(stored_output_string)
+                        self.assert_static_error(numeric_new_output == numeric_stored_output, message_error, stored_output, new_output, asserting_key)
+        return True   # c# requ
 
     def assert_static_request_output(self, exchange, type, skip_keys, stored_url, request_url, stored_output, new_output):
         if stored_url != request_url:
@@ -951,12 +984,12 @@ class testMainClass(baseMainTestClass):
                 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
-        if type == 'json':
+        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)
             if isinstance(new_output, str):
                 new_output = json_parse(new_output)
-        elif type == 'urlencoded':
+        elif type == 'urlencoded' and (stored_output is not None) and (new_output is not None):
             stored_output = self.urlencoded_to_dict(stored_output)
             new_output = self.urlencoded_to_dict(new_output)
         elif type == 'both':
@@ -1070,8 +1103,9 @@ class testMainClass(baseMainTestClass):
                 skip_keys = exchange.safe_value(exchange_data, 'skipKeys', [])
                 self.test_method_statically(exchange, method, result, type, skip_keys)
                 # reset options
-                exchange.options = old_exchange_options
+                exchange.options = exchange.deep_extend(old_exchange_options, {})
         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)
@@ -1091,16 +1125,20 @@ class testMainClass(baseMainTestClass):
                 is_disabled = exchange.safe_value(result, 'disabled', False)
                 if is_disabled:
                     continue
+                is_disabled_c_sharp = exchange.safe_value(result, 'disabledCS', False)
+                if is_disabled_c_sharp and (self.lang == 'C#'):
+                    continue
                 is_disabled_php = exchange.safe_value(result, 'disabledPHP', False)
-                if is_disabled_php and (self.ext == 'php'):
+                if is_disabled_php and (self.lang == 'PHP'):
                     continue
                 if (test_name is not None) and (test_name != description):
                     continue
                 skip_keys = exchange.safe_value(exchange_data, 'skipKeys', [])
                 self.test_response_statically(exchange, method, skip_keys, result)
                 # reset options
-                exchange.options = old_exchange_options
+                exchange.options = exchange.deep_extend(old_exchange_options, {})
         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):
         sum = 0
@@ -1170,7 +1208,7 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             spot_order_request = self.urlencoded_to_dict(exchange.last_request_body)
         client_order_id = spot_order_request['newClientOrderId']
-        assert client_order_id.startswith(spot_id), 'spot clientOrderId does not start with spotId'
+        assert client_order_id.startswith(str(spot_id)), 'spot clientOrderId does not start with spotId'
         swap_id = 'x-xcKtGhcu'
         swap_order_request = None
         try:
@@ -1183,10 +1221,11 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             swap_inverse_order_request = self.urlencoded_to_dict(exchange.last_request_body)
         client_order_id_spot = swap_order_request['newClientOrderId']
-        assert client_order_id_spot.startswith(swap_id), 'swap clientOrderId does not start with swapId'
+        assert client_order_id_spot.startswith(str(swap_id)), 'swap clientOrderId does not start with swapId'
         client_order_id_inverse = swap_inverse_order_request['newClientOrderId']
-        assert client_order_id_inverse.startswith(swap_id), 'swap clientOrderIdInverse does not start with swapId'
+        assert client_order_id_inverse.startswith(str(swap_id)), 'swap clientOrderIdInverse does not start with swapId'
         close(exchange)
+        return True
 
     def test_okx(self):
         exchange = self.init_offline_exchange('okx')
@@ -1197,7 +1236,7 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             spot_order_request = json_parse(exchange.last_request_body)
         client_order_id = spot_order_request[0]['clOrdId']  # returns order inside array
-        assert client_order_id.startswith(id), 'spot clientOrderId does not start with id'
+        assert client_order_id.startswith(str(id)), 'spot clientOrderId does not start with id'
         assert spot_order_request[0]['tag'] == id, 'id different from spot tag'
         swap_order_request = None
         try:
@@ -1205,9 +1244,10 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             swap_order_request = json_parse(exchange.last_request_body)
         client_order_id_spot = swap_order_request[0]['clOrdId']
-        assert client_order_id_spot.startswith(id), 'swap clientOrderId does not start with id'
+        assert client_order_id_spot.startswith(str(id)), 'swap clientOrderId does not start with id'
         assert swap_order_request[0]['tag'] == id, 'id different from swap tag'
         close(exchange)
+        return True
 
     def test_cryptocom(self):
         exchange = self.init_offline_exchange('cryptocom')
@@ -1220,6 +1260,7 @@ class testMainClass(baseMainTestClass):
             request = json_parse(exchange.last_request_body)
         assert request['params']['broker_id'] == id, 'id different from  broker_id'
         close(exchange)
+        return True
 
     def test_bybit(self):
         exchange = self.init_offline_exchange('bybit')
@@ -1233,6 +1274,7 @@ class testMainClass(baseMainTestClass):
             req_headers = exchange.last_request_headers
         assert req_headers['Referer'] == id, 'id not in headers'
         close(exchange)
+        return True
 
     def test_kucoin(self):
         exchange = self.init_offline_exchange('kucoin')
@@ -1247,19 +1289,21 @@ class testMainClass(baseMainTestClass):
         id = 'ccxt'
         assert req_headers['KC-API-PARTNER'] == id, 'id not in headers'
         close(exchange)
+        return True
 
     def test_kucoinfutures(self):
-        kucoin = self.init_offline_exchange('kucoinfutures')
+        exchange = self.init_offline_exchange('kucoinfutures')
         req_headers = None
         id = 'ccxtfutures'
-        assert kucoin.options['partner']['future']['id'] == id, 'id not in options'
-        assert kucoin.options['partner']['future']['key'] == '1b327198-f30c-4f14-a0ac-918871282f15', 'key not in options'
+        assert exchange.options['partner']['future']['id'] == id, 'id not in options'
+        assert exchange.options['partner']['future']['key'] == '1b327198-f30c-4f14-a0ac-918871282f15', 'key not in options'
         try:
-            kucoin.create_order('BTC/USDT:USDT', 'limit', 'buy', 1, 20000)
+            exchange.create_order('BTC/USDT:USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
-            req_headers = kucoin.last_request_headers
+            req_headers = exchange.last_request_headers
         assert req_headers['KC-API-PARTNER'] == id, 'id not in headers'
-        close(kucoin)
+        close(exchange)
+        return True
 
     def test_bitget(self):
         exchange = self.init_offline_exchange('bitget')
@@ -1272,6 +1316,7 @@ class testMainClass(baseMainTestClass):
             req_headers = exchange.last_request_headers
         assert req_headers['X-CHANNEL-API-CODE'] == id, 'id not in headers'
         close(exchange)
+        return True
 
     def test_mexc(self):
         exchange = self.init_offline_exchange('mexc')
@@ -1285,6 +1330,7 @@ class testMainClass(baseMainTestClass):
             req_headers = exchange.last_request_headers
         assert req_headers['source'] == id, 'id not in headers'
         close(exchange)
+        return True
 
     def test_htx(self):
         exchange = self.init_offline_exchange('htx')
@@ -1296,7 +1342,7 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             spot_order_request = json_parse(exchange.last_request_body)
         client_order_id = spot_order_request['client-order-id']
-        assert client_order_id.startswith(id), 'spot clientOrderId does not start with id'
+        assert client_order_id.startswith(str(id)), 'spot clientOrderId does not start with id'
         # swap test
         swap_order_request = None
         try:
@@ -1309,10 +1355,11 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             swap_inverse_order_request = json_parse(exchange.last_request_body)
         client_order_id_spot = swap_order_request['channel_code']
-        assert client_order_id_spot.startswith(id), 'swap channel_code does not start with id'
+        assert client_order_id_spot.startswith(str(id)), 'swap channel_code does not start with id'
         client_order_id_inverse = swap_inverse_order_request['channel_code']
-        assert client_order_id_inverse.startswith(id), 'swap inverse channel_code does not start with id'
+        assert client_order_id_inverse.startswith(str(id)), 'swap inverse channel_code does not start with id'
         close(exchange)
+        return True
 
     def test_woo(self):
         exchange = self.init_offline_exchange('woo')
@@ -1324,7 +1371,7 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             spot_order_request = self.urlencoded_to_dict(exchange.last_request_body)
         broker_id = spot_order_request['broker_id']
-        assert broker_id.startswith(id), 'broker_id does not start with id'
+        assert broker_id.startswith(str(id)), 'broker_id does not start with id'
         # swap test
         stop_order_request = None
         try:
@@ -1334,8 +1381,9 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             stop_order_request = json_parse(exchange.last_request_body)
         client_order_id_spot = stop_order_request['brokerId']
-        assert client_order_id_spot.startswith(id), 'brokerId does not start with id'
+        assert client_order_id_spot.startswith(str(id)), 'brokerId does not start with id'
         close(exchange)
+        return True
 
     def test_bitmart(self):
         exchange = self.init_offline_exchange('bitmart')
@@ -1349,6 +1397,7 @@ class testMainClass(baseMainTestClass):
             req_headers = exchange.last_request_headers
         assert req_headers['X-BM-BROKER-ID'] == id, 'id not in headers'
         close(exchange)
+        return True
 
     def test_coinex(self):
         exchange = self.init_offline_exchange('coinex')
@@ -1360,8 +1409,9 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             spot_order_request = json_parse(exchange.last_request_body)
         client_order_id = spot_order_request['client_id']
-        assert client_order_id.startswith(id), 'clientOrderId does not start with id'
+        assert client_order_id.startswith(str(id)), 'clientOrderId does not start with id'
         close(exchange)
+        return True
 
     def test_bingx(self):
         exchange = self.init_offline_exchange('bingx')
@@ -1385,7 +1435,7 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             request = json_parse(exchange.last_request_body)
         client_order_id = request['clOrdID']
-        assert client_order_id.startswith(id), 'clOrdID does not start with id'
+        assert client_order_id.startswith(str(id)), 'clOrdID does not start with id'
         close(exchange)
 
 # ***** AUTO-TRANSPILER-END *****

ccxt/timex.py

@@ -109,7 +109,7 @@ class timex(Exchange, ImplicitAPI):
                     'rest': 'https://plasma-relay-backend.timex.io',
                 },
                 'www': 'https://timex.io',
-                'doc': 'https://docs.timex.io',
+                'doc': 'https://plasma-relay-backend.timex.io/swagger-ui/index.html',
                 'referral': 'https://timex.io/?refcode=1x27vNkTbP1uwkCck',
             },
             'api': {
@@ -686,7 +686,7 @@ class timex(Exchange, ImplicitAPI):
         #
         return self.parse_balance(response)
 
-    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
+    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: float = None, params={}):
         """
         create a trade order
         :param str symbol: unified symbol of the market to create an order in

ccxt/tokocrypto.py

@@ -1335,9 +1335,9 @@ class tokocrypto(Exchange, ImplicitAPI):
         #         "timestamp":1659666786943
         #     }
         #
-        return self.parse_balance(response, type, marginMode)
+        return self.parse_balance_custom(response, type, marginMode)
 
-    def parse_balance(self, response, type=None, marginMode=None):
+    def parse_balance_custom(self, response, type=None, marginMode=None):
         timestamp = self.safe_integer(response, 'updateTime')
         result = {
             'info': response,
@@ -1537,7 +1537,7 @@ class tokocrypto(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
+    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: float = None, params={}):
         """
         create a trade order
         :see: https://www.tokocrypto.com/apidocs/#new-order--signed
@@ -2217,7 +2217,7 @@ class tokocrypto(Exchange, ImplicitAPI):
             'fee': fee,
         }
 
-    def withdraw(self, code: str, amount, address, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address, tag=None, params={}):
         """
         :see: https://www.tokocrypto.com/apidocs/#withdraw-signed
         make a withdrawal

ccxt/upbit.py

@@ -984,7 +984,7 @@ class upbit(Exchange, ImplicitAPI):
         #
         return self.parse_ohlcvs(response, market, timeframe, since, limit)
 
-    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
+    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: float = None, params={}):
         """
         create a trade order
         :see: https://docs.upbit.com/reference/%EC%A3%BC%EB%AC%B8%ED%95%98%EA%B8%B0
@@ -1640,7 +1640,7 @@ class upbit(Exchange, ImplicitAPI):
             raise AddressPending(self.id + ' is generating ' + code + ' deposit address, call fetchDepositAddress or createDepositAddress one more time later to retrieve the generated address')
         return self.parse_deposit_address(response)
 
-    def withdraw(self, code: str, amount, address, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address, tag=None, params={}):
         """
         :see: https://docs.upbit.com/reference/디지털자산-출금하기
         :see: https://docs.upbit.com/reference/%EC%9B%90%ED%99%94-%EC%B6%9C%EA%B8%88%ED%95%98%EA%B8%B0

ccxt/wavesexchange.py

@@ -1198,7 +1198,8 @@ class wavesexchange(Exchange, ImplicitAPI):
         # precise.decimals should be integer
         precise.decimals = self.parse_to_int(Precise.string_sub(self.number_to_string(precise.decimals), self.number_to_string(scale)))
         precise.reduce()
-        return precise
+        stringValue = str(precise)
+        return stringValue
 
     def currency_from_precision(self, currency, amount):
         scale = self.currencies[currency]['precision']
@@ -1223,7 +1224,7 @@ class wavesexchange(Exchange, ImplicitAPI):
             return {'WAVES': 1}
         return rates
 
-    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
+    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: float = None, params={}):
         """
         create a trade order
         :param str symbol: unified symbol of the market to create an order in
@@ -2288,7 +2289,7 @@ class wavesexchange(Exchange, ImplicitAPI):
             raise ExchangeError(self.id + ' ' + body)
         return None
 
-    def withdraw(self, code: str, amount, address, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address, tag=None, params={}):
         """
         make a withdrawal
         :param str code: unified currency code

ccxt/wazirx.py

@@ -774,7 +774,7 @@ class wazirx(Exchange, ImplicitAPI):
         response = self.privateDeleteOrder(self.extend(request, params))
         return self.parse_order(response)
 
-    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
+    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: float = None, params={}):
         """
         :see: https://docs.wazirx.com/#new-order-trade
         create a trade order

ccxt/whitebit.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.whitebit import ImplicitAPI
 import hashlib
-from ccxt.base.types import Balances, Currency, Int, MarketType, Market, Order, OrderBook, OrderSide, OrderType, Str, Bool, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Int, MarketType, Market, Order, TransferEntry, OrderBook, OrderSide, OrderType, Str, Bool, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied
@@ -32,7 +32,7 @@ class whitebit(Exchange, ImplicitAPI):
             'name': 'WhiteBit',
             'version': 'v4',
             'countries': ['EE'],
-            'rateLimit': 500,
+            'rateLimit': 50,
             'pro': True,
             'has': {
                 'CORS': None,
@@ -1129,7 +1129,7 @@ class whitebit(Exchange, ImplicitAPI):
         #
         return self.safe_integer(response, 'time')
 
-    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
+    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: float = None, params={}):
         """
         create a trade order
         :see: https://docs.whitebit.com/private/http-trade-v4/#create-limit-order
@@ -1594,7 +1594,7 @@ class whitebit(Exchange, ImplicitAPI):
             'info': response,
         }
 
-    def set_leverage(self, leverage, symbol: Str = None, params={}):
+    def set_leverage(self, leverage: Int, symbol: Str = None, params={}):
         """
         set the level of leverage for a market
         :see: https://docs.whitebit.com/private/http-trade-v4/#change-collateral-account-leverage
@@ -1616,7 +1616,7 @@ class whitebit(Exchange, ImplicitAPI):
         #         "leverage": 5
         #     }
 
-    def transfer(self, code: str, amount, fromAccount, toAccount, params={}):
+    def transfer(self, code: str, amount: float, fromAccount, toAccount, params={}) -> TransferEntry:
         """
         transfer currency internally between wallets on the same account
         :see: https://docs.whitebit.com/private/http-main-v4/#transfer-between-main-and-trade-balances
@@ -1661,7 +1661,7 @@ class whitebit(Exchange, ImplicitAPI):
             'status': None,
         }
 
-    def withdraw(self, code: str, amount, address, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address, tag=None, params={}):
         """
         make a withdrawal
         :see: https://docs.whitebit.com/private/http-main-v4/#create-withdraw-request

ccxt/woo.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.woo import ImplicitAPI
 import hashlib
-from ccxt.base.types import Balances, Currency, Int, MarketType, Market, Order, OrderBook, OrderSide, OrderType, Num, Str, Bool, Strings, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Int, MarketType, Market, Order, TransferEntry, OrderBook, OrderSide, OrderType, Num, Str, Bool, Strings, Trade, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ArgumentsRequired
@@ -796,7 +796,7 @@ class woo(Exchange, ImplicitAPI):
         params['trailingTriggerPrice'] = trailingTriggerPrice
         return self.create_order(symbol, type, side, amount, price, params)
 
-    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
+    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: float = None, params={}):
         """
         create a trade order
         :see: https://docs.woo.org/#send-order
@@ -833,7 +833,7 @@ class woo(Exchange, ImplicitAPI):
         stopLoss = self.safe_value(params, 'stopLoss')
         takeProfit = self.safe_value(params, 'takeProfit')
         algoType = self.safe_string(params, 'algoType')
-        trailingTriggerPrice = self.safe_string_2(params, 'trailingTriggerPrice', 'activatedPrice', price)
+        trailingTriggerPrice = self.safe_string_2(params, 'trailingTriggerPrice', 'activatedPrice', self.number_to_string(price))
         trailingAmount = self.safe_string_2(params, 'trailingAmount', 'callbackValue')
         trailingPercent = self.safe_string_2(params, 'trailingPercent', 'callbackRate')
         isTrailingAmountOrder = trailingAmount is not None
@@ -1920,7 +1920,7 @@ class woo(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    def transfer(self, code: str, amount, fromAccount, toAccount, params={}):
+    def transfer(self, code: str, amount: float, fromAccount, toAccount, params={}) -> TransferEntry:
         """
         transfer currency internally between wallets on the same account
         :param str code: unified currency code
@@ -2038,7 +2038,7 @@ class woo(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    def withdraw(self, code: str, amount, address, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address, tag=None, params={}):
         """
         make a withdrawal
         :param str code: unified currency code
@@ -2444,7 +2444,7 @@ class woo(Exchange, ImplicitAPI):
             'leverage': leverage,
         }
 
-    def set_leverage(self, leverage, symbol: Str = None, params={}):
+    def set_leverage(self, leverage: Int, symbol: Str = None, params={}):
         self.load_markets()
         if (leverage < 1) or (leverage > 20):
             raise BadRequest(self.id + ' leverage should be between 1 and 20')

ccxt/yobit.py

@@ -749,7 +749,7 @@ class yobit(Exchange, ImplicitAPI):
             }
         return result
 
-    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
+    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: float = None, params={}):
         """
         :see: https://yobit.net/en/api
         create a trade order
@@ -1125,14 +1125,32 @@ class yobit(Exchange, ImplicitAPI):
         address = self.safe_string(response['return'], 'address')
         self.check_address(address)
         return {
+            'id': None,
             'currency': code,
             'address': address,
             'tag': None,
             'network': None,
             'info': response,
+            'txid': None,
+            'type': None,
+            'amount': None,
+            'status': None,
+            'timestamp': None,
+            'datetime': None,
+            'addressFrom': None,
+            'addressTo': None,
+            'tagFrom': None,
+            'tagTo': None,
+            'updated': None,
+            'comment': None,
+            'fee': {
+                'currency': None,
+                'cost': None,
+                'rate': None,
+            },
         }
 
-    def withdraw(self, code: str, amount, address, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address, tag=None, params={}):
         """
         :see: https://yobit.net/en/api
         make a withdrawal
@@ -1159,6 +1177,27 @@ class yobit(Exchange, ImplicitAPI):
         return {
             'info': response,
             'id': None,
+            'txid': None,
+            'type': None,
+            'currency': None,
+            'network': None,
+            'amount': None,
+            'status': None,
+            'timestamp': None,
+            'datetime': None,
+            'address': None,
+            'addressFrom': None,
+            'addressTo': None,
+            'tag': None,
+            'tagFrom': None,
+            'tagTo': None,
+            'updated': None,
+            'comment': None,
+            'fee': {
+                'currency': None,
+                'cost': None,
+                'rate': None,
+            },
         }
 
     def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):