ccxt 4.4.34__py2.py3-none-any.whl → 4.4.36__py2.py3-none-any.whl

ccxt/async_support/deribit.py

@@ -220,6 +220,7 @@ class deribit(Exchange, ImplicitAPI):
                         'enable_api_key': 1,
                         'get_access_log': 1,
                         'get_account_summary': 1,
+                        'get_account_summaries': 1,
                         'get_affiliate_program_info': 1,
                         'get_email_language': 1,
                         'get_new_announcements': 1,
@@ -931,13 +932,20 @@ class deribit(Exchange, ImplicitAPI):
         result: dict = {
             'info': balance,
         }
-        currencyId = self.safe_string(balance, 'currency')
-        currencyCode = self.safe_currency_code(currencyId)
-        account = self.account()
-        account['free'] = self.safe_string(balance, 'available_funds')
-        account['used'] = self.safe_string(balance, 'maintenance_margin')
-        account['total'] = self.safe_string(balance, 'equity')
-        result[currencyCode] = account
+        summaries = []
+        if 'summaries' in balance:
+            summaries = self.safe_list(balance, 'summaries')
+        else:
+            summaries = [balance]
+        for i in range(0, len(summaries)):
+            data = summaries[i]
+            currencyId = self.safe_string(data, 'currency')
+            currencyCode = self.safe_currency_code(currencyId)
+            account = self.account()
+            account['free'] = self.safe_string(data, 'available_funds')
+            account['used'] = self.safe_string(data, 'maintenance_margin')
+            account['total'] = self.safe_string(data, 'equity')
+            result[currencyCode] = account
         return self.safe_balance(result)
 
     async def fetch_balance(self, params={}) -> Balances:
@@ -945,17 +953,24 @@ class deribit(Exchange, ImplicitAPI):
         query for balance and get the amount of funds available for trading or funds locked in orders
 
         https://docs.deribit.com/#private-get_account_summary
+        https://docs.deribit.com/#private-get_account_summaries
 
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.code]: unified currency code of the currency for the balance, if defined 'privateGetGetAccountSummary' will be used, otherwise 'privateGetGetAccountSummaries' will be used
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
         """
         await self.load_markets()
-        code = self.code_from_options('fetchBalance', params)
-        currency = self.currency(code)
+        code = self.safe_string(params, 'code')
+        params = self.omit(params, 'code')
         request: dict = {
-            'currency': currency['id'],
         }
-        response = await self.privateGetGetAccountSummary(self.extend(request, params))
+        if code is not None:
+            request['currency'] = self.currency_id(code)
+        response = None
+        if code is None:
+            response = await self.privateGetGetAccountSummaries(params)
+        else:
+            response = await self.privateGetGetAccountSummary(self.extend(request, params))
         #
         #     {
         #         "jsonrpc": "2.0",
@@ -998,7 +1013,7 @@ class deribit(Exchange, ImplicitAPI):
         #         "testnet": False
         #     }
         #
-        result = self.safe_value(response, 'result', {})
+        result = self.safe_dict(response, 'result', {})
         return self.parse_balance(result)
 
     async def create_deposit_address(self, code: str, params={}):

ccxt/async_support/gate.py

@@ -240,6 +240,7 @@ class gate(Exchange, ImplicitAPI):
                             '{settle}/contract_stats': 1,
                             '{settle}/index_constituents/{index}': 1,
                             '{settle}/liq_orders': 1,
+                            '{settle}/risk_limit_tiers': 1,
                         },
                     },
                     'delivery': {
@@ -281,6 +282,7 @@ class gate(Exchange, ImplicitAPI):
                     'withdrawals': {
                         'post': {
                             'withdrawals': 20,  # 1r/s cost = 20 / 1 = 20
+                            'push': 1,
                         },
                         'delete': {
                             'withdrawals/{withdrawal_id}': 1,
@@ -292,6 +294,7 @@ class gate(Exchange, ImplicitAPI):
                             'withdrawals': 1,
                             'deposits': 1,
                             'sub_account_transfers': 1,
+                            'order_status': 1,
                             'withdraw_status': 1,
                             'sub_account_balances': 2.5,
                             'sub_account_margin_balances': 2.5,
@@ -302,6 +305,7 @@ class gate(Exchange, ImplicitAPI):
                             'total_balance': 2.5,
                             'small_balance': 1,
                             'small_balance_history': 1,
+                            'push': 1,
                         },
                         'post': {
                             'transfers': 2.5,  # 8r/s cost = 20 / 8 = 2.5
@@ -344,11 +348,14 @@ class gate(Exchange, ImplicitAPI):
                             'risk_units': 20 / 15,
                             'unified_mode': 20 / 15,
                             'loan_margin_tiers': 20 / 15,
+                            'leverage/user_currency_config': 20 / 15,
+                            'leverage/user_currency_setting': 20 / 15,
                         },
                         'post': {
                             'account_mode': 20 / 15,
                             'loans': 200 / 15,  # 15r/10s cost = 20 / 1.5 = 13.33
                             'portfolio_calculator': 20 / 15,
+                            'leverage/user_currency_setting': 20 / 15,
                         },
                         'put': {
                             'unified_mode': 20 / 15,
@@ -528,9 +535,13 @@ class gate(Exchange, ImplicitAPI):
                             'orders': 20 / 15,
                             'orders/{order_id}': 20 / 15,
                             'my_trades': 20 / 15,
+                            'mmp': 20 / 15,
                         },
                         'post': {
                             'orders': 20 / 15,
+                            'countdown_cancel_all': 20 / 15,
+                            'mmp': 20 / 15,
+                            'mmp/reset': 20 / 15,
                         },
                         'delete': {
                             'orders': 20 / 15,
@@ -574,6 +585,7 @@ class gate(Exchange, ImplicitAPI):
                             'multi_collateral/currencies': 20 / 15,
                             'multi_collateral/ltv': 20 / 15,
                             'multi_collateral/fixed_rate': 20 / 15,
+                            'multi_collateral/current_rate': 20 / 15,
                         },
                         'post': {
                             'collateral/orders': 20 / 15,
@@ -587,8 +599,10 @@ class gate(Exchange, ImplicitAPI):
                     'account': {
                         'get': {
                             'detail': 20 / 15,
+                            'rate_limit': 20 / 15,
                             'stp_groups': 20 / 15,
                             'stp_groups/{stp_id}/users': 20 / 15,
+                            'stp_groups/debit_fee': 20 / 15,
                         },
                         'post': {
                             'stp_groups': 20 / 15,
@@ -709,6 +723,110 @@ class gate(Exchange, ImplicitAPI):
                     },
                 },
             },
+            'features': {
+                'spot': {
+                    'sandbox': True,
+                    'createOrder': {
+                        'marginMode': True,
+                        'triggerPrice': True,
+                        'triggerDirection': True,  # todo: implementation edit needed
+                        'triggerPriceType': None,
+                        'stopLossPrice': True,
+                        'takeProfitPrice': True,
+                        'attachedStopLossTakeProfit': None,
+                        'timeInForce': {
+                            'GTC': True,
+                            'IOC': True,
+                            'FOK': True,
+                            'PO': True,
+                            'GTD': False,
+                        },
+                        'hedged': False,
+                        'trailing': False,
+                        # exchange-specific features
+                        'iceberg': True,
+                        'selfTradePrevention': True,
+                    },
+                    'createOrders': {
+                        'max': 40,  # NOTE! max 10 per symbol
+                    },
+                    'fetchMyTrades': {
+                        'marginMode': True,
+                        'limit': 1000,
+                        'daysBack': None,
+                        'untilDays': 30,
+                    },
+                    'fetchOrder': {
+                        'marginMode': False,
+                        'trigger': True,
+                        'trailing': False,
+                    },
+                    'fetchOpenOrders': {
+                        'marginMode': True,
+                        'trigger': True,
+                        'trailing': False,
+                        'limit': 100,
+                    },
+                    'fetchOrders': None,
+                    'fetchClosedOrders': {
+                        'marginMode': True,
+                        'trigger': True,
+                        'trailing': False,
+                        'limit': 100,
+                        'untilDays': 30,
+                        'daysBackClosed': None,
+                        'daysBackCanceled': None,
+                    },
+                    'fetchOHLCV': {
+                        'limit': 1000,
+                    },
+                },
+                'forDerivatives': {
+                    'extends': 'spot',
+                    'createOrder': {
+                        'marginMode': False,
+                        'triggerPriceType': {
+                            'last': True,
+                            'mark': True,
+                            'index': True,
+                        },
+                    },
+                    'createOrders': {
+                        'max': 10,
+                    },
+                    'fetchMyTrades': {
+                        'marginMode': False,
+                        'untilDays': None,
+                    },
+                    'fetchOpenOrders': {
+                        'marginMode': False,
+                    },
+                    'fetchClosedOrders': {
+                        'marginMode': False,
+                        'untilDays': None,
+                        'limit': 1000,
+                    },
+                    'fetchOHLCV': {
+                        'limit': 1999,
+                    },
+                },
+                'swap': {
+                    'linear': {
+                        'extends': 'forDerivatives',
+                    },
+                    'inverse': {
+                        'extends': 'forDerivatives',
+                    },
+                },
+                'future': {
+                    'linear': {
+                        'extends': 'forDerivatives',
+                    },
+                    'inverse': {
+                        'extends': 'forDerivatives',
+                    },
+                },
+            },
             'precisionMode': TICK_SIZE,
             'fees': {
                 'trading': {
@@ -1533,22 +1651,22 @@ class gate(Exchange, ImplicitAPI):
                 request['settle'] = settle
         return [request, params]
 
-    def spot_order_prepare_request(self, market=None, stop=False, params={}):
+    def spot_order_prepare_request(self, market=None, trigger=False, params={}):
         """
  @ignore
         Fills request params currency_pair, market and account where applicable for spot order methods like fetchOpenOrders, cancelAllOrders
         :param dict market: CCXT market
-        :param bool stop: True if for a stop order
+        :param bool trigger: True if for a trigger order
         :param dict [params]: request parameters
         :returns: the api request object, and the new params object with non-needed parameters removed
         """
-        marginMode, query = self.get_margin_mode(stop, params)
+        marginMode, query = self.get_margin_mode(trigger, params)
         request: dict = {}
-        if not stop:
+        if not trigger:
             if market is None:
-                raise ArgumentsRequired(self.id + ' spotOrderPrepareRequest() requires a market argument for non-stop orders')
+                raise ArgumentsRequired(self.id + ' spotOrderPrepareRequest() requires a market argument for non-trigger orders')
             request['account'] = marginMode
-            request['currency_pair'] = market['id']  # Should always be set for non-stop
+            request['currency_pair'] = market['id']  # Should always be set for non-trigger
         return [request, query]
 
     def multi_order_spot_prepare_request(self, market=None, trigger=False, params={}):
@@ -1556,7 +1674,7 @@ class gate(Exchange, ImplicitAPI):
  @ignore
         Fills request params currency_pair, market and account where applicable for spot order methods like fetchOpenOrders, cancelAllOrders
         :param dict market: CCXT market
-        :param bool stop: True if for a stop order
+        :param bool trigger: True if for a trigger order
         :param dict [params]: request parameters
         :returns: the api request object, and the new params object with non-needed parameters removed
         """
@@ -1566,17 +1684,17 @@ class gate(Exchange, ImplicitAPI):
         }
         if market is not None:
             if trigger:
-                # gate spot and margin stop orders use the term market instead of currency_pair, and normal instead of spot. Neither parameter is used when fetching/cancelling a single order. They are used for creating a single stop order, but createOrder does not call self method
+                # gate spot and margin trigger orders use the term market instead of currency_pair, and normal instead of spot. Neither parameter is used when fetching/cancelling a single order. They are used for creating a single trigger order, but createOrder does not call self method
                 request['market'] = market['id']
             else:
                 request['currency_pair'] = market['id']
         return [request, query]
 
-    def get_margin_mode(self, stop, params):
+    def get_margin_mode(self, trigger, params):
         """
  @ignore
         Gets the margin type for self api call
-        :param bool stop: True if for a stop order
+        :param bool trigger: True if for a trigger order
         :param dict [params]: Request params
         :returns: The marginMode and the updated request params with marginMode removed, marginMode value is the value that can be read by the "account" property specified in gates api docs
         """
@@ -1589,12 +1707,12 @@ class gate(Exchange, ImplicitAPI):
             marginMode = 'margin'
         elif marginMode == '':
             marginMode = 'spot'
-        if stop:
+        if trigger:
             if marginMode == 'spot':
-                # gate spot stop orders use the term normal instead of spot
+                # gate spot trigger orders use the term normal instead of spot
                 marginMode = 'normal'
             if marginMode == 'cross_margin':
-                raise BadRequest(self.id + ' getMarginMode() does not support stop orders for cross margin')
+                raise BadRequest(self.id + ' getMarginMode() does not support trigger orders for cross margin')
         isUnifiedAccount = False
         isUnifiedAccount, params = self.handle_option_and_params(params, 'getMarginMode', 'unifiedAccount')
         if isUnifiedAccount:
@@ -2990,7 +3108,6 @@ class gate(Exchange, ImplicitAPI):
             request['limit'] = limit
         response = None
         if market['contract']:
-            maxLimit = 1999
             isMark = (price == 'mark')
             isIndex = (price == 'index')
             if isMark or isIndex:
@@ -3307,7 +3424,7 @@ class gate(Exchange, ImplicitAPI):
                 params = self.omit(params, 'order_id')
         else:
             if market is not None:
-                request['currency_pair'] = market['id']  # Should always be set for non-stop
+                request['currency_pair'] = market['id']  # Should always be set for non-trigger
             marginMode, params = self.get_margin_mode(False, params)
             request['account'] = marginMode
         if limit is not None:
@@ -3826,8 +3943,8 @@ class gate(Exchange, ImplicitAPI):
         takeProfitPrice = self.safe_value(params, 'takeProfitPrice')
         isStopLossOrder = stopLossPrice is not None
         isTakeProfitOrder = takeProfitPrice is not None
-        isStopOrder = isStopLossOrder or isTakeProfitOrder
-        nonTriggerOrder = not isStopOrder and (trigger is None)
+        isTpsl = isStopLossOrder or isTakeProfitOrder
+        nonTriggerOrder = not isTpsl and (trigger is None)
         orderRequest = self.create_order_request(symbol, type, side, amount, price, params)
         response = None
         if market['spot'] or market['margin']:
@@ -3976,7 +4093,7 @@ class gate(Exchange, ImplicitAPI):
         takeProfitPrice = self.safe_value(params, 'takeProfitPrice')
         isStopLossOrder = stopLossPrice is not None
         isTakeProfitOrder = takeProfitPrice is not None
-        isStopOrder = isStopLossOrder or isTakeProfitOrder
+        isTpsl = isStopLossOrder or isTakeProfitOrder
         if isStopLossOrder and isTakeProfitOrder:
             raise ExchangeError(self.id + ' createOrder() stopLossPrice and takeProfitPrice cannot both be defined')
         reduceOnly = self.safe_value(params, 'reduceOnly')
@@ -4012,7 +4129,7 @@ class gate(Exchange, ImplicitAPI):
                 signedAmount = Precise.string_neg(amountToPrecision) if (side == 'sell') else amountToPrecision
                 amount = int(signedAmount)
         request = None
-        nonTriggerOrder = not isStopOrder and (trigger is None)
+        nonTriggerOrder = not isTpsl and (trigger is None)
         if nonTriggerOrder:
             if contract:
                 # contract order
@@ -4562,7 +4679,7 @@ class gate(Exchange, ImplicitAPI):
 
     def fetch_order_request(self, id: str, symbol: Str = None, params={}):
         market = None if (symbol is None) else self.market(symbol)
-        stop = self.safe_bool_n(params, ['trigger', 'is_stop_order', 'stop'], False)
+        trigger = self.safe_bool_n(params, ['trigger', 'is_stop_order', 'stop'], False)
         params = self.omit(params, ['is_stop_order', 'stop', 'trigger'])
         clientOrderId = self.safe_string_2(params, 'text', 'clientOrderId')
         orderId = id
@@ -4573,7 +4690,7 @@ class gate(Exchange, ImplicitAPI):
             orderId = clientOrderId
         type, query = self.handle_market_type_and_params('fetchOrder', market, params)
         contract = (type == 'swap') or (type == 'future') or (type == 'option')
-        request, requestParams = self.prepare_request(market, type, query) if contract else self.spot_order_prepare_request(market, stop, query)
+        request, requestParams = self.prepare_request(market, type, query) if contract else self.spot_order_prepare_request(market, trigger, query)
         request['order_id'] = str(orderId)
         return [request, requestParams]
 
@@ -4601,21 +4718,21 @@ class gate(Exchange, ImplicitAPI):
         market = None if (symbol is None) else self.market(symbol)
         result = self.handle_market_type_and_params('fetchOrder', market, params)
         type = self.safe_string(result, 0)
-        stop = self.safe_bool_n(params, ['trigger', 'is_stop_order', 'stop'], False)
+        trigger = self.safe_bool_n(params, ['trigger', 'is_stop_order', 'stop'], False)
         request, requestParams = self.fetch_order_request(id, symbol, params)
         response = None
         if type == 'spot' or type == 'margin':
-            if stop:
+            if trigger:
                 response = await self.privateSpotGetPriceOrdersOrderId(self.extend(request, requestParams))
             else:
                 response = await self.privateSpotGetOrdersOrderId(self.extend(request, requestParams))
         elif type == 'swap':
-            if stop:
+            if trigger:
                 response = await self.privateFuturesGetSettlePriceOrdersOrderId(self.extend(request, requestParams))
             else:
                 response = await self.privateFuturesGetSettleOrdersOrderId(self.extend(request, requestParams))
         elif type == 'future':
-            if stop:
+            if trigger:
                 response = await self.privateDeliveryGetSettlePriceOrdersOrderId(self.extend(request, requestParams))
             else:
                 response = await self.privateDeliveryGetSettleOrdersOrderId(self.extend(request, requestParams))
@@ -4636,7 +4753,7 @@ class gate(Exchange, ImplicitAPI):
         :param int [since]: the earliest time in ms to fetch open orders for
         :param int [limit]: the maximum number of  open orders structures to retrieve
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :param bool [params.stop]: True for fetching stop orders
+        :param bool [params.trigger]: True for fetching trigger orders
         :param str [params.type]: spot, margin, swap or future, if not provided self.options['defaultType'] is used
         :param str [params.marginMode]: 'cross' or 'isolated' - marginMode for type='margin', if not provided self.options['defaultMarginMode'] is used
         :param bool [params.unifiedAccount]: set to True for fetching unified account orders
@@ -4661,7 +4778,7 @@ class gate(Exchange, ImplicitAPI):
         :param int [since]: the earliest time in ms to fetch orders for
         :param int [limit]: the maximum number of order structures to retrieve
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :param bool [params.stop]: True for fetching stop orders
+        :param bool [params.trigger]: True for fetching trigger orders
         :param str [params.type]: spot, swap or future, if not provided self.options['defaultType'] is used
         :param str [params.marginMode]: 'cross' or 'isolated' - marginMode for margin trading if not provided self.options['defaultMarginMode'] is used
         :param boolean [params.historical]: *swap only* True for using historical endpoint
@@ -4835,7 +4952,7 @@ class gate(Exchange, ImplicitAPI):
         #        }
         #    ]
         #
-        # spot stop
+        # spot trigger
         #
         #    [
         #        {
@@ -4930,31 +5047,31 @@ class gate(Exchange, ImplicitAPI):
         :param str id: Order id
         :param str symbol: Unified market symbol
         :param dict [params]: Parameters specified by the exchange api
-        :param bool [params.stop]: True if the order to be cancelled is a trigger order
+        :param bool [params.trigger]: True if the order to be cancelled is a trigger order
         :param bool [params.unifiedAccount]: set to True for canceling unified account orders
         :returns: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
         await self.load_unified_status()
         market = None if (symbol is None) else self.market(symbol)
-        stop = self.safe_bool_n(params, ['is_stop_order', 'stop', 'trigger'], False)
+        trigger = self.safe_bool_n(params, ['is_stop_order', 'stop', 'trigger'], False)
         params = self.omit(params, ['is_stop_order', 'stop', 'trigger'])
         type, query = self.handle_market_type_and_params('cancelOrder', market, params)
-        request, requestParams = self.spot_order_prepare_request(market, stop, query) if (type == 'spot' or type == 'margin') else self.prepare_request(market, type, query)
+        request, requestParams = self.spot_order_prepare_request(market, trigger, query) if (type == 'spot' or type == 'margin') else self.prepare_request(market, type, query)
         request['order_id'] = id
         response = None
         if type == 'spot' or type == 'margin':
-            if stop:
+            if trigger:
                 response = await self.privateSpotDeletePriceOrdersOrderId(self.extend(request, requestParams))
             else:
                 response = await self.privateSpotDeleteOrdersOrderId(self.extend(request, requestParams))
         elif type == 'swap':
-            if stop:
+            if trigger:
                 response = await self.privateFuturesDeleteSettlePriceOrdersOrderId(self.extend(request, requestParams))
             else:
                 response = await self.privateFuturesDeleteSettleOrdersOrderId(self.extend(request, requestParams))
         elif type == 'future':
-            if stop:
+            if trigger:
                 response = await self.privateDeliveryDeleteSettlePriceOrdersOrderId(self.extend(request, requestParams))
             else:
                 response = await self.privateDeliveryDeleteSettleOrdersOrderId(self.extend(request, requestParams))
@@ -5144,23 +5261,23 @@ class gate(Exchange, ImplicitAPI):
         await self.load_markets()
         await self.load_unified_status()
         market = None if (symbol is None) else self.market(symbol)
-        stop = self.safe_bool_2(params, 'stop', 'trigger')
+        trigger = self.safe_bool_2(params, 'stop', 'trigger')
         params = self.omit(params, ['stop', 'trigger'])
         type, query = self.handle_market_type_and_params('cancelAllOrders', market, params)
-        request, requestParams = self.multi_order_spot_prepare_request(market, stop, query) if (type == 'spot') else self.prepare_request(market, type, query)
+        request, requestParams = self.multi_order_spot_prepare_request(market, trigger, query) if (type == 'spot') else self.prepare_request(market, type, query)
         response = None
         if type == 'spot' or type == 'margin':
-            if stop:
+            if trigger:
                 response = await self.privateSpotDeletePriceOrders(self.extend(request, requestParams))
             else:
                 response = await self.privateSpotDeleteOrders(self.extend(request, requestParams))
         elif type == 'swap':
-            if stop:
+            if trigger:
                 response = await self.privateFuturesDeleteSettlePriceOrders(self.extend(request, requestParams))
             else:
                 response = await self.privateFuturesDeleteSettleOrders(self.extend(request, requestParams))
         elif type == 'future':
-            if stop:
+            if trigger:
                 response = await self.privateDeliveryDeleteSettlePriceOrders(self.extend(request, requestParams))
             else:
                 response = await self.privateDeliveryDeleteSettleOrders(self.extend(request, requestParams))

ccxt/async_support/htx.py

@@ -5092,17 +5092,23 @@ class htx(Exchange, ImplicitAPI):
                 params = self.omit(params, ['clientOrderId'])
             if type == 'limit' or type == 'ioc' or type == 'fok' or type == 'post_only':
                 request['price'] = self.price_to_precision(symbol, price)
+        reduceOnly = self.safe_bool_2(params, 'reduceOnly', 'reduce_only', False)
         if not isStopLossTriggerOrder and not isTakeProfitTriggerOrder:
-            reduceOnly = self.safe_value_2(params, 'reduceOnly', 'reduce_only', False)
             if reduceOnly:
                 request['reduce_only'] = 1
             request['lever_rate'] = self.safe_integer_n(params, ['leverRate', 'lever_rate', 'leverage'], 1)
             if not isTrailingPercentOrder:
                 request['order_price_type'] = type
+        hedged = self.safe_bool(params, 'hedged', False)
+        if hedged:
+            if reduceOnly:
+                request['offset'] = 'close'
+            else:
+                request['offset'] = 'open'
         broker = self.safe_value(self.options, 'broker', {})
         brokerId = self.safe_string(broker, 'id')
         request['channel_code'] = brokerId
-        params = self.omit(params, ['reduceOnly', 'triggerPrice', 'stopPrice', 'stopLossPrice', 'takeProfitPrice', 'triggerType', 'leverRate', 'timeInForce', 'leverage', 'trailingPercent', 'trailingTriggerPrice'])
+        params = self.omit(params, ['reduceOnly', 'triggerPrice', 'stopPrice', 'stopLossPrice', 'takeProfitPrice', 'triggerType', 'leverRate', 'timeInForce', 'leverage', 'trailingPercent', 'trailingTriggerPrice', 'hedged'])
         return self.extend(request, params)
 
     async def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
@@ -5116,6 +5122,8 @@ class htx(Exchange, ImplicitAPI):
         https://huobiapi.github.io/docs/usdt_swap/v1/en/#cross-place-trigger-order      # usdt-m swap cross trigger
         https://huobiapi.github.io/docs/usdt_swap/v1/en/#isolated-place-an-order        # usdt-m swap isolated
         https://huobiapi.github.io/docs/usdt_swap/v1/en/#isolated-place-trigger-order   # usdt-m swap isolated trigger
+        https://huobiapi.github.io/docs/usdt_swap/v1/en/#isolated-set-a-take-profit-and-stop-loss-order-for-an-existing-position
+        https://huobiapi.github.io/docs/usdt_swap/v1/en/#cross-set-a-take-profit-and-stop-loss-order-for-an-existing-position
         https://huobiapi.github.io/docs/dm/v1/en/#place-an-order                        # coin-m futures
         https://huobiapi.github.io/docs/dm/v1/en/#place-trigger-order                   # coin-m futures contract trigger
 
@@ -5137,6 +5145,7 @@ class htx(Exchange, ImplicitAPI):
         :param float [params.cost]: *spot market buy only* the quote quantity that can be used alternative for the amount
         :param float [params.trailingPercent]: *contract only* the percent to trail away from the current market price
         :param float [params.trailingTriggerPrice]: *contract only* the price to trigger a trailing order, default uses the price argument
+        :param bool [params.hedged]: *contract only* True for hedged mode, False for one way mode, default is False
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()