Method create_contract_order_request

python/ccxt/async_support/htx.py:5021–5172

@ignore helper function to build request :param str symbol: unified symbol of the market to create an order in :param str type: 'market' or 'limit' :param str side: 'buy' or 'sell' :param float amount: how much you want to trade in units of the base currency

(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={})

        return self.extend(request, params)

    def create_contract_order_request(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
        """
 @ignore
        helper function to build request
        :param str symbol: unified symbol of the market to create an order in
        :param str type: 'market' or 'limit'
        :param str side: 'buy' or 'sell'
        :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 str [params.timeInForce]: supports 'IOC' and 'FOK'
        :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 dict [params.takeProfit]: *takeProfit object in params, linear swap only* containing the triggerPrice at which the attached take profit order will be triggered
        :param float [params.takeProfit.triggerPrice]: take profit trigger price
        :param float [params.takeProfit.price]: take profit order price take profit orders
        :param str [params.takeProfit.type]: market is the default, limit, optimal_5, optimal_10, optimal_20
        :param dict [params.stopLoss]: *stopLoss object in params, linear swap only* containing the triggerPrice at which the attached stop loss order will be triggered
        :param float [params.stopLoss.triggerPrice]: stop loss trigger price
        :param float [params.stopLoss.price]: stop loss order price for stop loss orders
        :param str [params.stopLoss.type]: market is the default, limit, optimal_5, optimal_10, optimal_20
        :returns dict: request to be sent to the exchange
        """
        market = self.market(symbol)
        request = {
            'contract_code': market['id'],
            'volume': self.amount_to_precision(symbol, amount),
        }
        postOnly = None
        postOnly, params = self.handle_post_only(type == 'market', type == 'post_only', params)
        if postOnly:
            type = 'post_only'
        subType = None
        subType, params = self.handle_sub_type_and_params('createOrder', market, params)
        isLinear = (subType == 'linear')
        reduceOnly = self.safe_bool_2(params, 'reduceOnly', 'reduce_only', False)
        hedged = self.safe_bool(params, 'hedged', False)
        timeInForce = self.safe_string_lower_2(params, 'timeInForce', 'time_in_force', 'gtc')
        if isLinear:
            marginMode = None
            marginMode, params = self.handle_margin_mode_and_params('createOrder', params, 'cross')
            request['margin_mode'] = marginMode
            request['side'] = side
            if timeInForce is not None:
                request['time_in_force'] = timeInForce.lower()
            stopLoss = self.safe_dict(params, 'stopLoss')
            takeProfit = self.safe_dict(params, 'takeProfit')
            stopLossTriggerPriceAttached = self.safe_number(stopLoss, 'triggerPrice')
            stopLossOrderPrice = self.safe_number(stopLoss, 'price')
            stopLossType = self.safe_string(stopLoss, 'type')
            takeProfitTriggerPriceAttached = self.safe_number(takeProfit, 'triggerPrice')
            takeProfitOrderPrice = self.safe_number(takeProfit, 'price')
            takeProfitType = self.safe_string(takeProfit, 'type')
            # on htx for attached tpsl orders sl_order_price or tp_order_price need to be filled and the sl_trigger_price or tp_trigger_price are optional
            if stopLoss is not None:
                if stopLossTriggerPriceAttached is not None:
                    request['sl_trigger_price'] = self.price_to_precision(symbol, stopLossTriggerPriceAttached)
                if stopLossOrderPrice is not None: