ccxt 4.4.40__py2.py3-none-any.whl → 4.4.42__py2.py3-none-any.whl

ccxt/async_support/gate.py

@@ -3916,7 +3916,7 @@ class gate(Exchange, ImplicitAPI):
         :param float amount: the amount of currency to trade
         :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 at which a trigger order is triggered at
+        :param float [params.triggerPrice]: The price at which a trigger order is triggered at
         :param str [params.timeInForce]: "GTC", "IOC", or "PO"
         :param float [params.stopLossPrice]: The price at which a stop loss order is triggered at
         :param float [params.takeProfitPrice]: The price at which a take profit order is triggered at
@@ -4664,7 +4664,6 @@ class gate(Exchange, ImplicitAPI):
             'reduceOnly': self.safe_value(order, 'is_reduce_only'),
             'side': side,
             'price': price,
-            'stopPrice': triggerPrice,
             'triggerPrice': triggerPrice,
             'average': average,
             'amount': Precise.string_abs(amount),
@@ -6488,7 +6487,7 @@ class gate(Exchange, ImplicitAPI):
         #        ...
         #    ]
         #
-        return self.parse_open_interests(response, market, since, limit)
+        return self.parse_open_interests_history(response, market, since, limit)
 
     def parse_open_interest(self, interest, market: Market = None):
         #

ccxt/async_support/gemini.py

@@ -1301,7 +1301,6 @@ class gemini(Exchange, ImplicitAPI):
             'postOnly': postOnly,
             'side': side,
             'price': price,
-            'stopPrice': None,
             'triggerPrice': None,
             'average': average,
             'cost': None,
@@ -1432,12 +1431,12 @@ class gemini(Exchange, ImplicitAPI):
         }
         type = self.safe_string(params, 'type', type)
         params = self.omit(params, 'type')
-        rawStopPrice = self.safe_string_2(params, 'stop_price', 'stopPrice')
+        triggerPrice = self.safe_string_n(params, ['stop_price', 'stopPrice'])
         params = self.omit(params, ['stop_price', 'stopPrice', 'type'])
         if type == 'stopLimit':
-            raise ArgumentsRequired(self.id + ' createOrder() requires a stopPrice parameter or a stop_price parameter for ' + type + ' orders')
-        if rawStopPrice is not None:
-            request['stop_price'] = self.price_to_precision(symbol, rawStopPrice)
+            raise ArgumentsRequired(self.id + ' createOrder() requires a triggerPrice parameter or a stop_price parameter for ' + type + ' orders')
+        if triggerPrice is not None:
+            request['stop_price'] = self.price_to_precision(symbol, triggerPrice)
             request['type'] = 'exchange stop limit'
         else:
             # No options can be applied to stop-limit orders at self time.

ccxt/async_support/hashkey.py

@@ -361,6 +361,84 @@ class hashkey(Exchange, ImplicitAPI):
                 },
                 'defaultNetwork': 'ERC20',
             },
+            'features': {
+                'default': {
+                    'sandbox': True,
+                    'createOrder': {
+                        'marginMode': False,
+                        'triggerPrice': False,
+                        'triggerPriceType': None,
+                        'triggerDirection': False,
+                        'stopLossPrice': False,
+                        'takeProfitPrice': False,
+                        'attachedStopLossTakeProfit': None,
+                        'timeInForce': {
+                            'IOC': True,
+                            'FOK': True,
+                            'PO': True,
+                            'GTD': False,
+                        },
+                        'hedged': False,
+                        'trailing': False,
+                        # exchange-supported features
+                        # 'marketBuyRequiresPrice': False,
+                        # 'marketBuyByCost': False,
+                        # 'selfTradePrevention': True,
+                        # 'twap': False,
+                        # 'iceberg': False,
+                        # 'oco': False,
+                    },
+                    'createOrders': {
+                        'max': 20,
+                    },
+                    'fetchMyTrades': {
+                        'marginMode': False,
+                        'limit': 1000,
+                        'daysBack': 30,
+                        'untilDays': 30,
+                    },
+                    'fetchOrder': {
+                        'marginMode': False,
+                        'trigger': False,
+                        'trailing': False,
+                    },
+                    'fetchOpenOrders': {
+                        'marginMode': False,
+                        'limit': 1000,
+                        'trigger': False,
+                        'trailing': False,
+                    },
+                    'fetchOrders': None,
+                    'fetchClosedOrders': None,  # todo
+                    'fetchOHLCV': {
+                        'limit': 1000,
+                    },
+                },
+                'spot': {
+                    'extends': 'default',
+                },
+                'forDerivatives': {
+                    'extends': 'default',
+                    'createOrder': {
+                        'triggerPrice': True,
+                        'selfTradePrevention': True,
+                    },
+                    'fetchOpenOrders': {
+                        'trigger': True,
+                        'limit': 500,
+                    },
+                },
+                'swap': {
+                    'linear': {
+                        'extends': 'forDerivatives',
+                    },
+                    'inverse': None,
+                },
+                'future': {
+                    'linear': None,
+                    'inverse': None,
+                },
+            },
             'commonCurrencies': {},
             'exceptions': {
                 'exact': {
@@ -582,11 +660,7 @@ class hashkey(Exchange, ImplicitAPI):
         :param str [params.symbol]: the id of the market to fetch
         :returns dict[]: an array of objects representing market data
         """
-        symbol: Str = None
         request: dict = {}
-        symbol, params = self.handle_option_and_params(params, 'fetchMarkets', 'symbol')
-        if symbol is not None:
-            request['symbol'] = symbol
         response = await self.publicGetApiV1ExchangeInfo(self.extend(request, params))
         #
         #     {
@@ -1254,10 +1328,6 @@ class hashkey(Exchange, ImplicitAPI):
         if marketType == 'spot':
             if market is not None:
                 request['symbol'] = market['id']
-            clientOrderId: Str = None
-            clientOrderId, params = self.handle_option_and_params(params, methodName, 'clientOrderId')
-            if clientOrderId is not None:
-                request['clientOrderId'] = clientOrderId
             if accountId is not None:
                 request['accountId'] = accountId
             response = await self.privateGetApiV1AccountTrades(self.extend(request, params))
@@ -1601,10 +1671,6 @@ class hashkey(Exchange, ImplicitAPI):
         await self.load_markets()
         symbols = self.market_symbols(symbols)
         request: dict = {}
-        symbol: Str = None
-        symbol, params = self.handle_option_and_params(params, 'fetchLastPrices', 'symbol')
-        if symbol is not None:
-            request['symbol'] = symbol
         response = await self.publicGetQuoteV1TickerPrice(self.extend(request, params))
         #
         #     [
@@ -1662,10 +1728,6 @@ class hashkey(Exchange, ImplicitAPI):
             balance = self.safe_dict(response, 0, {})
             return self.parse_swap_balance(balance)
         elif marketType == 'spot':
-            accountId: Str = None
-            accountId, params = self.handle_option_and_params(params, methodName, 'accountId')
-            if accountId is not None:
-                request['accountId'] = accountId
             response = await self.privateGetApiV1Account(self.extend(request, params))
             #
             #     {
@@ -1931,18 +1993,10 @@ class hashkey(Exchange, ImplicitAPI):
         }
         if tag is not None:
             request['addressExt'] = tag
-        clientOrderId: Str = None
-        clientOrderId, params = self.handle_option_and_params(params, 'withdraw', 'clientOrderId')
-        if clientOrderId is not None:
-            request['clientOrderId'] = clientOrderId
         networkCode: Str = None
         networkCode, params = self.handle_network_code_and_params(params)
         if networkCode is not None:
             request['chainType'] = self.network_code_to_id(networkCode)
-        platform: Str = None
-        platform, params = self.handle_option_and_params(params, 'withdraw', 'platform')
-        if platform is not None:
-            request['platform'] = platform
         response = await self.privatePostApiV1AccountWithdraw(self.extend(request, params))
         #
         #     {
@@ -2081,14 +2135,6 @@ class hashkey(Exchange, ImplicitAPI):
             'fromAccountId': fromAccount,
             'toAccountId': toAccount,
         }
-        clientOrderId: Str = None
-        clientOrderId, params = self.handle_option_and_params(params, 'transfer', 'clientOrderId')
-        if clientOrderId is not None:
-            request['clientOrderId'] = clientOrderId
-        remark: Str = None
-        remark, params = self.handle_option_and_params(params, 'transfer', 'remark')
-        if remark is not None:
-            request['remark'] = remark
         response = await self.privatePostApiV1AccountAssetTransfer(self.extend(request, params))
         #
         #     {
@@ -2926,10 +2972,6 @@ class hashkey(Exchange, ImplicitAPI):
         if marketType == 'spot':
             if clientOrderId is not None:
                 request['origClientOrderId'] = clientOrderId
-            accountId: Str = None
-            accountId, params = self.handle_option_and_params(params, methodName, 'accountId')
-            if accountId is not None:
-                request['accountId'] = accountId
             response = await self.privateGetApiV1SpotOrder(self.extend(request, params))
             #
             #     {
@@ -3065,14 +3107,6 @@ class hashkey(Exchange, ImplicitAPI):
                 request['symbol'] = market['id']
             if limit is not None:
                 request['limit'] = limit
-            orderId: Str = None
-            orderId, params = self.handle_option_and_params(params, methodName, 'orderId')
-            if orderId is not None:
-                request['orderId'] = orderId
-            side: Str = None
-            side, params = self.handle_option_and_params(params, methodName, 'side')
-            if side is not None:
-                request['side'] = side.upper()
             response = await self.privateGetApiV1SpotOpenOrders(self.extend(request, params))
             #
             #     [
@@ -3138,10 +3172,6 @@ class hashkey(Exchange, ImplicitAPI):
             request['type'] = 'LIMIT'
         if limit is not None:
             request['limit'] = limit
-        fromOrderId: Str = None
-        fromOrderId, params = self.handle_option_and_params(params, methodName, 'fromOrderId')
-        if fromOrderId is not None:
-            request['fromOrderId'] = fromOrderId
         response = None
         accountId: Str = None
         accountId, params = self.handle_option_and_params(params, methodName, 'accountId')
@@ -3240,14 +3270,6 @@ class hashkey(Exchange, ImplicitAPI):
         if marketType == 'spot':
             if market is not None:
                 request['symbol'] = market['id']
-            orderId: Str = None
-            orderId, params = self.handle_option_and_params(params, methodName, 'orderId')
-            if orderId is not None:
-                request['orderId'] = orderId
-            side: Str = None
-            side, params = self.handle_option_and_params(params, methodName, 'side')
-            if side is not None:
-                request['side'] = side.upper()
             if accountId is not None:
                 request['accountId'] = accountId
             response = await self.privateGetApiV1SpotTradeOrders(self.extend(request, params))
@@ -3290,10 +3312,6 @@ class hashkey(Exchange, ImplicitAPI):
                 request['type'] = 'STOP'
             else:
                 request['type'] = 'LIMIT'
-            fromOrderId: Str = None
-            fromOrderId, params = self.handle_option_and_params(params, methodName, 'fromOrderId')
-            if fromOrderId is not None:
-                request['fromOrderId'] = fromOrderId
             if accountId is not None:
                 request['subAccountId'] = accountId
                 response = await self.privateGetApiV1FuturesSubAccountHistoryOrders(self.extend(request, params))
@@ -3477,7 +3495,6 @@ class hashkey(Exchange, ImplicitAPI):
         feeCurrncyId = self.safe_string(order, 'feeCoin')
         if feeCurrncyId == '':
             feeCurrncyId = None
-        triggerPrice = self.omit_zero(self.safe_string(order, 'stopPrice'))
         return self.safe_order({
             'id': self.safe_string(order, 'orderId'),
             'clientOrderId': self.safe_string(order, 'clientOrderId'),
@@ -3495,8 +3512,7 @@ class hashkey(Exchange, ImplicitAPI):
             'amount': self.omit_zero(self.safe_string(order, 'origQty')),
             'filled': self.safe_string(order, 'executedQty'),
             'remaining': None,
-            'stopPrice': triggerPrice,
-            'triggerPrice': triggerPrice,
+            'triggerPrice': self.omit_zero(self.safe_string(order, 'stopPrice')),
             'takeProfitPrice': None,
             'stopLossPrice': None,
             'cost': self.omit_zero(self.safe_string_2(order, 'cumulativeQuoteQty', 'cummulativeQuoteQty')),
@@ -3730,10 +3746,6 @@ class hashkey(Exchange, ImplicitAPI):
         request: dict = {
             'symbol': market['id'],
         }
-        side: Str = None
-        side, params = self.handle_option_and_params(params, methodName, 'side')
-        if side is not None:
-            request['side'] = side.upper()
         response = await self.privateGetApiV1FuturesPositions(self.extend(request, params))
         #
         #     [

ccxt/async_support/hitbtc.py

@@ -92,6 +92,7 @@ class hitbtc(Exchange, ImplicitAPI):
                 'fetchOHLCV': True,
                 'fetchOpenInterest': True,
                 'fetchOpenInterestHistory': False,
+                'fetchOpenInterests': True,
                 'fetchOpenOrder': True,
                 'fetchOpenOrders': True,
                 'fetchOrder': True,
@@ -2254,7 +2255,7 @@ class hitbtc(Exchange, ImplicitAPI):
             elif type == 'market':
                 request['type'] = 'stopMarket'
         elif (type == 'stopLimit') or (type == 'stopMarket') or (type == 'takeProfitLimit') or (type == 'takeProfitMarket'):
-            raise ExchangeError(self.id + ' createOrder() requires a stopPrice parameter for stop-loss and take-profit orders')
+            raise ExchangeError(self.id + ' createOrder() requires a triggerPrice parameter for stop-loss and take-profit orders')
         params = self.omit(params, ['triggerPrice', 'timeInForce', 'stopPrice', 'stop_price', 'reduceOnly', 'postOnly'])
         if marketType == 'swap':
             # set default margin mode to cross
@@ -2363,7 +2364,6 @@ class hitbtc(Exchange, ImplicitAPI):
         postOnly = self.safe_value(order, 'post_only')
         timeInForce = self.safe_string(order, 'time_in_force')
         rawTrades = self.safe_value(order, 'trades')
-        stopPrice = self.safe_string(order, 'stop_price')
         return self.safe_order({
             'info': order,
             'id': id,
@@ -2387,8 +2387,7 @@ class hitbtc(Exchange, ImplicitAPI):
             'average': average,
             'trades': rawTrades,
             'fee': None,
-            'stopPrice': stopPrice,
-            'triggerPrice': stopPrice,
+            'triggerPrice': self.safe_string(order, 'stop_price'),
             'takeProfitPrice': None,
             'stopLossPrice': None,
         }, market)
@@ -2954,7 +2953,7 @@ class hitbtc(Exchange, ImplicitAPI):
         datetime = self.safe_string(interest, 'timestamp')
         value = self.safe_number(interest, 'open_interest')
         return self.safe_open_interest({
-            'symbol': market['symbol'],
+            'symbol': self.safe_symbol(None, market),
             'openInterestAmount': None,
             'openInterestValue': value,
             'timestamp': self.parse8601(datetime),
@@ -2962,6 +2961,49 @@ class hitbtc(Exchange, ImplicitAPI):
             'info': interest,
         }, market)
 
+    async def fetch_open_interests(self, symbols: Strings = None, params={}):
+        """
+        Retrieves the open interest for a list of symbols
+
+        https://api.hitbtc.com/#futures-info
+
+        :param str[] [symbols]: a list of unified CCXT market symbols
+        :param dict [params]: exchange specific parameters
+        :returns dict[]: a list of `open interest structures <https://docs.ccxt.com/#/?id=open-interest-structure>`
+        """
+        await self.load_markets()
+        request: dict = {}
+        symbols = self.market_symbols(symbols)
+        marketIds = None
+        if symbols is not None:
+            marketIds = self.market_ids(symbols)
+            request['symbols'] = ','.join(marketIds)
+        response = await self.publicGetPublicFuturesInfo(self.extend(request, params))
+        #
+        #     {
+        #         "BTCUSDT_PERP": {
+        #             "contract_type": "perpetual",
+        #             "mark_price": "97291.83",
+        #             "index_price": "97298.61",
+        #             "funding_rate": "-0.000183473092423284",
+        #             "open_interest": "94.1503",
+        #             "next_funding_time": "2024-12-20T08:00:00.000Z",
+        #             "indicative_funding_rate": "-0.00027495203277752",
+        #             "premium_index": "-0.000789474900583786",
+        #             "avg_premium_index": "-0.000683473092423284",
+        #             "interest_rate": "0.0001",
+        #             "timestamp": "2024-12-20T04:57:33.693Z"
+        #         }
+        #     }
+        #
+        results = []
+        markets = list(response.keys())
+        for i in range(0, len(markets)):
+            marketId = markets[i]
+            marketInner = self.safe_market(marketId)
+            results.append(self.parse_open_interest(response[marketId], marketInner))
+        return self.filter_by_array(results, 'symbol', symbols)
+
     async def fetch_open_interest(self, symbol: str, params={}):
         """
         Retrieves the open interest of a derivative trading pair

ccxt/async_support/hollaex.py

@@ -1098,7 +1098,6 @@ class hollaex(Exchange, ImplicitAPI):
         type = self.safe_string(order, 'type')
         side = self.safe_string(order, 'side')
         price = self.safe_string(order, 'price')
-        stopPrice = self.safe_string(order, 'stop')
         amount = self.safe_string(order, 'size')
         filled = self.safe_string(order, 'filled')
         status = self.parse_order_status(self.safe_string(order, 'status'))
@@ -1117,8 +1116,7 @@ class hollaex(Exchange, ImplicitAPI):
             'postOnly': postOnly,
             'side': side,
             'price': price,
-            'stopPrice': stopPrice,
-            'triggerPrice': stopPrice,
+            'triggerPrice': self.safe_string(order, 'stop'),
             'amount': amount,
             'filled': filled,
             'remaining': None,
@@ -1156,7 +1154,7 @@ class hollaex(Exchange, ImplicitAPI):
             # 'stop': float(self.price_to_precision(symbol, stopPrice)),
             # 'meta': {},  # other options such
         }
-        stopPrice = self.safe_number_n(params, ['triggerPrice', 'stopPrice', 'stop'])
+        triggerPrice = self.safe_number_n(params, ['triggerPrice', 'stopPrice', 'stop'])
         meta = self.safe_value(params, 'meta', {})
         exchangeSpecificParam = self.safe_bool(meta, 'post_only', False)
         isMarketOrder = type == 'market'
@@ -1164,8 +1162,8 @@ class hollaex(Exchange, ImplicitAPI):
         if not isMarketOrder:
             convertedPrice = float(self.price_to_precision(symbol, price))
             request['price'] = self.normalize_number_if_needed(convertedPrice)
-        if stopPrice is not None:
-            request['stop'] = self.normalize_number_if_needed(float(self.price_to_precision(symbol, stopPrice)))
+        if triggerPrice is not None:
+            request['stop'] = self.normalize_number_if_needed(float(self.price_to_precision(symbol, triggerPrice)))
         if postOnly:
             request['meta'] = {'post_only': True}
         params = self.omit(params, ['postOnly', 'timeInForce', 'stopPrice', 'triggerPrice', 'stop'])

ccxt/async_support/htx.py

@@ -4970,7 +4970,6 @@ class htx(Exchange, ImplicitAPI):
                 'cost': feeCost,
                 'currency': feeCurrency,
             }
-        stopPrice = self.safe_string_2(order, 'stop-price', 'trigger_price')
         average = self.safe_string(order, 'trade_avg_price')
         trades = self.safe_value(order, 'trades')
         reduceOnlyInteger = self.safe_integer(order, 'reduce_only')
@@ -4990,8 +4989,7 @@ class htx(Exchange, ImplicitAPI):
             'postOnly': None,
             'side': side,
             'price': price,
-            'stopPrice': stopPrice,
-            'triggerPrice': stopPrice,
+            'triggerPrice': self.safe_string_2(order, 'stop-price', 'trigger_price'),
             'average': average,
             'cost': cost,
             'amount': amount,
@@ -8004,7 +8002,7 @@ class htx(Exchange, ImplicitAPI):
         #
         data = self.safe_value(response, 'data')
         tick = self.safe_list(data, 'tick')
-        return self.parse_open_interests(tick, market, since, limit)
+        return self.parse_open_interests_history(tick, market, since, limit)
 
     async def fetch_open_interest(self, symbol: str, params={}):
         """

ccxt/async_support/huobijp.py

@@ -1295,7 +1295,6 @@ class huobijp(Exchange, ImplicitAPI):
             'postOnly': None,
             'side': side,
             'price': price,
-            'stopPrice': None,
             'triggerPrice': None,
             'average': None,
             'cost': cost,

ccxt/async_support/hyperliquid.py

@@ -95,8 +95,9 @@ class hyperliquid(Exchange, ImplicitAPI):
                 'fetchMyLiquidations': False,
                 'fetchMyTrades': True,
                 'fetchOHLCV': True,
-                'fetchOpenInterest': False,
+                'fetchOpenInterest': True,
                 'fetchOpenInterestHistory': False,
+                'fetchOpenInterests': True,
                 'fetchOpenOrders': True,
                 'fetchOrder': True,
                 'fetchOrderBook': True,
@@ -3132,6 +3133,64 @@ class hyperliquid(Exchange, ImplicitAPI):
         withdrawals = self.filter_by_array(records, 'type', ['withdraw'], False)
         return self.parse_transactions(withdrawals, None, since, limit)
 
+    async def fetch_open_interests(self, symbols: Strings = None, params={}):
+        """
+        Retrieves the open interest for a list of symbols
+        :param str[] [symbols]: Unified CCXT market symbol
+        :param dict [params]: exchange specific parameters
+        :returns dict} an open interest structure{@link https://docs.ccxt.com/#/?id=open-interest-structure:
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols)
+        swapMarkets = await self.fetch_swap_markets()
+        result = self.parse_open_interests(swapMarkets)
+        return self.filter_by_array(result, 'symbol', symbols)
+
+    async def fetch_open_interest(self, symbol: str, params={}):
+        """
+        retrieves the open interest of a contract trading pair
+        :param str symbol: unified CCXT market symbol
+        :param dict [params]: exchange specific parameters
+        :returns dict: an `open interest structure <https://docs.ccxt.com/#/?id=open-interest-structure>`
+        """
+        symbol = self.symbol(symbol)
+        await self.load_markets()
+        ois = await self.fetch_open_interests([symbol], params)
+        return ois[symbol]
+
+    def parse_open_interest(self, interest, market: Market = None):
+        #
+        #  {
+        #      szDecimals: '2',
+        #      name: 'HYPE',
+        #      maxLeverage: '3',
+        #      funding: '0.00014735',
+        #      openInterest: '14677900.74',
+        #      prevDayPx: '26.145',
+        #      dayNtlVlm: '299643445.12560016',
+        #      premium: '0.00081613',
+        #      oraclePx: '27.569',
+        #      markPx: '27.63',
+        #      midPx: '27.599',
+        #      impactPxs: ['27.5915', '27.6319'],
+        #      dayBaseVlm: '10790652.83',
+        #      baseId: 159
+        #  }
+        #
+        interest = self.safe_dict(interest, 'info', {})
+        coin = self.safe_string(interest, 'name')
+        marketId = None
+        if coin is not None:
+            marketId = self.coin_to_market_id(coin)
+        return self.safe_open_interest({
+            'symbol': self.safe_symbol(marketId),
+            'openInterestAmount': self.safe_number(interest, 'openInterest'),
+            'openInterestValue': None,
+            'timestamp': None,
+            'datetime': None,
+            'info': interest,
+        }, market)
+
     def extract_type_from_delta(self, data=[]):
         records = []
         for i in range(0, len(data)):

ccxt/async_support/idex.py

@@ -1098,7 +1098,6 @@ class idex(Exchange, ImplicitAPI):
             'postOnly': None,
             'side': side,
             'price': price,
-            'stopPrice': None,
             'triggerPrice': None,
             'amount': amount,
             'cost': None,
@@ -1163,11 +1162,12 @@ class idex(Exchange, ImplicitAPI):
             'takeProfit': 5,
             'takeProfitLimit': 6,
         }
-        stopPriceString = None
-        if (type == 'stopLossLimit') or (type == 'takeProfitLimit') or ('stopPrice' in params):
-            if not ('stopPrice' in params):
-                raise BadRequest(self.id + ' createOrder() stopPrice is a required parameter for ' + type + 'orders')
-            stopPriceString = self.price_to_precision(symbol, params['stopPrice'])
+        triggerPrice = self.safe_string(params, 'triggerPrice', 'stopPrice')
+        triggerPriceString = None
+        if (type == 'stopLossLimit') or (type == 'takeProfitLimit'):
+            if triggerPrice is None:
+                raise BadRequest(self.id + ' createOrder() triggerPrice is a required parameter for ' + type + 'orders')
+            triggerPriceString = self.price_to_precision(symbol, triggerPrice)
         limitTypeEnums: dict = {
             'limit': 1,
             'limitMaker': 2,
@@ -1245,7 +1245,7 @@ class idex(Exchange, ImplicitAPI):
             encodedPrice = self.encode(priceString)
             byteArray.append(encodedPrice)
         if type in stopLossTypeEnums:
-            encodedPrice = self.encode(stopPriceString or priceString)
+            encodedPrice = self.encode(triggerPriceString or priceString)
             byteArray.append(encodedPrice)
         clientOrderId = self.safe_string(params, 'clientOrderId')
         if clientOrderId is not None:
@@ -1275,7 +1275,7 @@ class idex(Exchange, ImplicitAPI):
         if limitOrder:
             request['parameters']['price'] = priceString
         if type in stopLossTypeEnums:
-            request['parameters']['stopPrice'] = stopPriceString or priceString
+            request['parameters']['stopPrice'] = triggerPriceString or priceString
         if amountEnum == 0:
             request['parameters']['quantity'] = amountString
         else:

ccxt/async_support/independentreserve.py

@@ -437,7 +437,6 @@ class independentreserve(Exchange, ImplicitAPI):
             'postOnly': None,
             'side': side,
             'price': self.safe_string(order, 'Price'),
-            'stopPrice': None,
             'triggerPrice': None,
             'cost': self.safe_string(order, 'Value'),
             'average': self.safe_string(order, 'AvgPrice'),

ccxt/async_support/indodax.py

@@ -713,7 +713,6 @@ class indodax(Exchange, ImplicitAPI):
             'postOnly': None,
             'side': side,
             'price': price,
-            'stopPrice': None,
             'triggerPrice': None,
             'cost': cost,
             'average': None,