ccxt 4.4.23__py2.py3-none-any.whl → 4.4.25__py2.py3-none-any.whl

ccxt/htx.py

@@ -4904,15 +4904,15 @@ class htx(Exchange, ImplicitAPI):
         orderType = type.replace('buy-', '')
         orderType = orderType.replace('sell-', '')
         options = self.safe_value(self.options, market['type'], {})
-        stopPrice = self.safe_string_2(params, 'stopPrice', 'stop-price')
-        if stopPrice is None:
+        triggerPrice = self.safe_string_n(params, ['triggerPrice', 'stopPrice', 'stop-price'])
+        if triggerPrice is None:
             stopOrderTypes = self.safe_value(options, 'stopOrderTypes', {})
             if orderType in stopOrderTypes:
-                raise ArgumentsRequired(self.id + ' createOrder() requires a stopPrice or a stop-price parameter for a stop order')
+                raise ArgumentsRequired(self.id + ' createOrder() requires a triggerPrice for a stop order')
         else:
             defaultOperator = 'lte' if (side == 'sell') else 'gte'
             stopOperator = self.safe_string(params, 'operator', defaultOperator)
-            request['stop-price'] = self.price_to_precision(symbol, stopPrice)
+            request['stop-price'] = self.price_to_precision(symbol, triggerPrice)
             request['operator'] = stopOperator
             if (orderType == 'limit') or (orderType == 'limit-fok'):
                 orderType = 'stop-' + orderType
@@ -4970,7 +4970,7 @@ class htx(Exchange, ImplicitAPI):
         limitOrderTypes = self.safe_value(options, 'limitOrderTypes', {})
         if orderType in limitOrderTypes:
             request['price'] = self.price_to_precision(symbol, price)
-        params = self.omit(params, ['stopPrice', 'stop-price', 'clientOrderId', 'client-order-id', 'operator', 'timeInForce'])
+        params = self.omit(params, ['triggerPrice', 'stopPrice', 'stop-price', 'clientOrderId', 'client-order-id', 'operator', 'timeInForce'])
         return self.extend(request, params)
 
     def create_contract_order_request(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
@@ -5003,16 +5003,16 @@ class htx(Exchange, ImplicitAPI):
             type = 'fok'
         elif timeInForce == 'IOC':
             type = 'ioc'
-        triggerPrice = self.safe_number_2(params, 'stopPrice', 'trigger_price')
+        triggerPrice = self.safe_number_n(params, ['triggerPrice', 'stopPrice', 'trigger_price'])
         stopLossTriggerPrice = self.safe_number_2(params, 'stopLossPrice', 'sl_trigger_price')
         takeProfitTriggerPrice = self.safe_number_2(params, 'takeProfitPrice', 'tp_trigger_price')
         trailingPercent = self.safe_string_2(params, 'trailingPercent', 'callback_rate')
         trailingTriggerPrice = self.safe_number(params, 'trailingTriggerPrice', price)
         isTrailingPercentOrder = trailingPercent is not None
-        isStop = triggerPrice is not None
+        isTrigger = triggerPrice is not None
         isStopLossTriggerOrder = stopLossTriggerPrice is not None
         isTakeProfitTriggerOrder = takeProfitTriggerPrice is not None
-        if isStop:
+        if isTrigger:
             triggerType = self.safe_string_2(params, 'triggerType', 'trigger_type', 'le')
             request['trigger_type'] = triggerType
             request['trigger_price'] = self.price_to_precision(symbol, triggerPrice)
@@ -5051,7 +5051,7 @@ class htx(Exchange, ImplicitAPI):
         broker = self.safe_value(self.options, 'broker', {})
         brokerId = self.safe_string(broker, 'id')
         request['channel_code'] = brokerId
-        params = self.omit(params, ['reduceOnly', 'stopPrice', 'stopLossPrice', 'takeProfitPrice', 'triggerType', 'leverRate', 'timeInForce', 'leverage', 'trailingPercent', 'trailingTriggerPrice'])
+        params = self.omit(params, ['reduceOnly', 'triggerPrice', 'stopPrice', 'stopLossPrice', 'takeProfitPrice', 'triggerType', 'leverRate', 'timeInForce', 'leverage', 'trailingPercent', 'trailingTriggerPrice'])
         return self.extend(request, params)
 
     def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
@@ -5072,7 +5072,7 @@ class htx(Exchange, ImplicitAPI):
         :param float amount: how much you want to trade in units of the base currency
         :param float [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :param float [params.stopPrice]: the price a trigger order is triggered at
+        :param float [params.triggerPrice]: the price a trigger order is triggered at
         :param str [params.triggerType]: *contract trigger orders only* ge: greater than or equal to, le: less than or equal to
         :param float [params.stopLossPrice]: *contract only* the price a stop-loss order is triggered at
         :param float [params.takeProfitPrice]: *contract only* the price a take-profit order is triggered at
@@ -5088,12 +5088,12 @@ class htx(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        triggerPrice = self.safe_number_2(params, 'stopPrice', 'trigger_price')
+        triggerPrice = self.safe_number_n(params, ['triggerPrice', 'stopPrice', 'trigger_price'])
         stopLossTriggerPrice = self.safe_number_2(params, 'stopLossPrice', 'sl_trigger_price')
         takeProfitTriggerPrice = self.safe_number_2(params, 'takeProfitPrice', 'tp_trigger_price')
         trailingPercent = self.safe_number(params, 'trailingPercent')
         isTrailingPercentOrder = trailingPercent is not None
-        isStop = triggerPrice is not None
+        isTrigger = triggerPrice is not None
         isStopLossTriggerOrder = stopLossTriggerPrice is not None
         isTakeProfitTriggerOrder = takeProfitTriggerPrice is not None
         response = None
@@ -5109,7 +5109,7 @@ class htx(Exchange, ImplicitAPI):
                 marginMode, contractRequest = self.handle_margin_mode_and_params('createOrder', contractRequest)
                 marginMode = 'cross' if (marginMode is None) else marginMode
                 if marginMode == 'isolated':
-                    if isStop:
+                    if isTrigger:
                         response = self.contractPrivatePostLinearSwapApiV1SwapTriggerOrder(contractRequest)
                     elif isStopLossTriggerOrder or isTakeProfitTriggerOrder:
                         response = self.contractPrivatePostLinearSwapApiV1SwapTpslOrder(contractRequest)
@@ -5118,7 +5118,7 @@ class htx(Exchange, ImplicitAPI):
                     else:
                         response = self.contractPrivatePostLinearSwapApiV1SwapOrder(contractRequest)
                 elif marginMode == 'cross':
-                    if isStop:
+                    if isTrigger:
                         response = self.contractPrivatePostLinearSwapApiV1SwapCrossTriggerOrder(contractRequest)
                     elif isStopLossTriggerOrder or isTakeProfitTriggerOrder:
                         response = self.contractPrivatePostLinearSwapApiV1SwapCrossTpslOrder(contractRequest)
@@ -5131,7 +5131,7 @@ class htx(Exchange, ImplicitAPI):
                 if offset is None:
                     raise ArgumentsRequired(self.id + ' createOrder() requires an extra parameter params["offset"] to be set to "open" or "close" when placing orders in inverse markets')
                 if market['swap']:
-                    if isStop:
+                    if isTrigger:
                         response = self.contractPrivatePostSwapApiV1SwapTriggerOrder(contractRequest)
                     elif isStopLossTriggerOrder or isTakeProfitTriggerOrder:
                         response = self.contractPrivatePostSwapApiV1SwapTpslOrder(contractRequest)
@@ -5140,7 +5140,7 @@ class htx(Exchange, ImplicitAPI):
                     else:
                         response = self.contractPrivatePostSwapApiV1SwapOrder(contractRequest)
                 elif market['future']:
-                    if isStop:
+                    if isTrigger:
                         response = self.contractPrivatePostApiV1ContractTriggerOrder(contractRequest)
                     elif isStopLossTriggerOrder or isTakeProfitTriggerOrder:
                         response = self.contractPrivatePostApiV1ContractTpslOrder(contractRequest)

ccxt/hyperliquid.py

@@ -2138,7 +2138,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'notional': self.safe_number(entry, 'positionValue'),
             'leverage': self.safe_number(leverage, 'value'),
             'collateral': self.safe_number(entry, 'marginUsed'),
-            'initialMargin': initialMargin,
+            'initialMargin': self.parse_number(initialMargin),
             'maintenanceMargin': None,
             'initialMarginPercentage': None,
             'maintenanceMarginPercentage': None,

ccxt/kucoin.py

@@ -222,6 +222,7 @@ class kucoin(Exchange, ImplicitAPI):
                         'market/orderbook/level{level}': 3,  # 3SW
                         'market/orderbook/level2': 3,  # 3SW
                         'market/orderbook/level3': 3,  # 3SW
+                        'hf/accounts/opened': 2,  #
                         'hf/orders/active': 2,  # 2SW
                         'hf/orders/active/symbols': 2,  # 2SW
                         'hf/margin/order/active/symbols': 2,  # 2SW
@@ -651,7 +652,7 @@ class kucoin(Exchange, ImplicitAPI):
                 'FUD': 'FTX Users\' Debt',
             },
             'options': {
-                'hf': False,
+                'hf': None,  # would be auto set to `true/false` after first load
                 'version': 'v1',
                 'symbolSeparator': '-',
                 'fetchMyTradesMethod': 'private_get_fills',
@@ -1083,7 +1084,8 @@ class kucoin(Exchange, ImplicitAPI):
         #                 "enableTrading": True
         #             },
         #
-        requestMarginables = self.check_required_credentials(False)
+        credentialsSet = self.check_required_credentials(False)
+        requestMarginables = credentialsSet and self.safe_bool(params, 'marginables', True)
         if requestMarginables:
             promises.append(self.privateGetMarginSymbols(params))  # cross margin symbols
             #
@@ -1146,6 +1148,9 @@ class kucoin(Exchange, ImplicitAPI):
             #                     "makerCoefficient": "1"  # Maker Fee Coefficient
             #                 }
             #
+        if credentialsSet:
+            # load migration status for account
+            promises.append(self.load_migration_status())
         responses = promises
         symbolsData = self.safe_list(responses[0], 'data')
         crossData = self.safe_dict(responses[1], 'data', {}) if requestMarginables else {}
@@ -1232,14 +1237,16 @@ class kucoin(Exchange, ImplicitAPI):
         return result
 
     def load_migration_status(self, force: bool = False):
-        if not ('hfMigrated' in self.options) or (self.options['hfMigrated'] is None) or force:
-            result: dict = self.privateGetMigrateUserAccountStatus()
-            data: dict = self.safe_dict(result, 'data', {})
-            status: Int = self.safe_integer(data, 'status')
-            self.options['hfMigrated'] = (status == 2)
+        """
+        loads the migration status for the account(hf or not)
+        :see: https://www.kucoin.com/docs/rest/spot-trading/spot-hf-trade-pro-account/get-user-type
+        """
+        if not ('hf' in self.options) or (self.options['hf'] is None) or force:
+            result: dict = self.privateGetHfAccountsOpened()
+            self.options['hf'] = self.safe_bool(result, 'data')
 
     def handle_hf_and_params(self, params={}):
-        migrated: Bool = self.safe_bool_2(self.options, 'hfMigrated', 'hf', False)
+        migrated: Bool = self.safe_bool(self.options, 'hf', False)
         loadedHf: Bool = None
         if migrated is not None:
             if migrated:

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.23'
+__version__ = '4.4.25'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/kucoin.py

@@ -1088,7 +1088,8 @@ class kucoin(ccxt.async_support.kucoin):
             self.myTrades = ArrayCacheBySymbolById(limit)
         data = self.safe_dict(message, 'data')
         parsed = self.parse_ws_trade(data)
-        self.myTrades.append(parsed)
+        myTrades = self.myTrades
+        myTrades.append(parsed)
         messageHash = 'myTrades'
         client.resolve(self.myTrades, messageHash)
         symbolSpecificMessageHash = messageHash + ':' + parsed['symbol']

ccxt/pro/onetrading.py

@@ -965,7 +965,8 @@ class onetrading(ccxt.async_support.onetrading):
         if updateType == 'TRADE_SETTLED':
             parsed = self.parse_trade(update)
             symbol = self.safe_string(parsed, 'symbol', '')
-            self.myTrades.append(parsed)
+            myTrades = self.myTrades
+            myTrades.append(parsed)
             client.resolve(self.myTrades, 'myTrades:' + symbol)
             client.resolve(self.myTrades, 'myTrades')
 

ccxt/test/tests_async.py

@@ -639,9 +639,10 @@ class testMainClass:
         #  -----------------------------------------------------------------------------
         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):
@@ -752,9 +753,17 @@ class testMainClass:
                 # 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

ccxt/test/tests_sync.py

@@ -636,9 +636,10 @@ class testMainClass:
         #  -----------------------------------------------------------------------------
         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):
@@ -749,9 +750,17 @@ class testMainClass:
                 # 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

ccxt/woofipro.py

@@ -133,7 +133,7 @@ class woofipro(Exchange, ImplicitAPI):
                 '1y': '1y',
             },
             'urls': {
-                'logo': 'https://github.com/ccxt/ccxt/assets/43336371/b1e7b348-a0fc-4605-8b7f-91176958fd69',
+                'logo': 'https://github.com/user-attachments/assets/9ba21b8a-a9c7-4770-b7f1-ce3bcbde68c1',
                 'api': {
                     'public': 'https://api-evm.orderly.org',
                     'private': 'https://api-evm.orderly.org',

ccxt/xt.py

@@ -1698,6 +1698,9 @@ class xt(Exchange, ImplicitAPI):
         market = self.safe_market(marketId, market, '_', marketType)
         symbol = market['symbol']
         timestamp = self.safe_integer(ticker, 't')
+        percentage = self.safe_string_2(ticker, 'cr', 'r')
+        if percentage is not None:
+            percentage = Precise.string_mul(percentage, '100')
         return self.safe_ticker({
             'symbol': symbol,
             'timestamp': timestamp,
@@ -1714,7 +1717,7 @@ class xt(Exchange, ImplicitAPI):
             'last': self.safe_string(ticker, 'c'),
             'previousClose': None,
             'change': self.safe_number(ticker, 'cv'),
-            'percentage': self.safe_number_2(ticker, 'cr', 'r'),
+            'percentage': self.parse_number(percentage),
             'average': None,
             'baseVolume': None,
             'quoteVolume': self.safe_number_2(ticker, 'a', 'v'),

ccxt/yobit.py

@@ -1124,7 +1124,7 @@ class yobit(Exchange, ImplicitAPI):
         ids = list(trades.keys())
         result = []
         for i in range(0, len(ids)):
-            id = ids[i]
+            id = self.safe_string(ids, i)
             trade = self.parse_trade(self.extend(trades[id], {
                 'trade_id': id,
             }), market)