ccxt 4.4.63__py2.py3-none-any.whl → 4.4.68__py2.py3-none-any.whl

ccxt/async_support/gate.py

@@ -1947,7 +1947,11 @@ class gate(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         symbols = self.market_symbols(symbols)
-        request, query = self.prepare_request(None, 'swap', params)
+        market = None
+        if symbols is not None:
+            firstSymbol = self.safe_string(symbols, 0)
+            market = self.market(firstSymbol)
+        request, query = self.prepare_request(market, 'swap', params)
         response = await self.publicFuturesGetSettleContracts(self.extend(request, query))
         #
         #    [

ccxt/async_support/htx.py

@@ -910,6 +910,7 @@ class htx(Exchange, ImplicitAPI):
                     '1041': InvalidOrder,  # {"status":"error","err_code":1041,"err_msg":"The order amount exceeds the limit(170000Cont), please modify and order again.","ts":1643802784940}
                     '1047': InsufficientFunds,  # {"status":"error","err_code":1047,"err_msg":"Insufficient margin available.","ts":1643802672652}
                     '1048': InsufficientFunds,  # {"status":"error","err_code":1048,"err_msg":"Insufficient close amount available.","ts":1652772408864}
+                    '1061': OrderNotFound,  # {"status":"ok","data":{"errors":[{"order_id":"1349442392365359104","err_code":1061,"err_msg":"The order does not exist."}],"successes":""},"ts":1741773744526}
                     '1051': InvalidOrder,  # {"status":"error","err_code":1051,"err_msg":"No orders to cancel.","ts":1652552125876}
                     '1066': BadSymbol,  # {"status":"error","err_code":1066,"err_msg":"The symbol field cannot be empty. Please re-enter.","ts":1640550819147}
                     '1067': InvalidOrder,  # {"status":"error","err_code":1067,"err_msg":"The client_order_id field is invalid. Please re-enter.","ts":1643802119413}
@@ -6757,14 +6758,17 @@ class htx(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         symbols = self.market_symbols(symbols)
-        options = self.safe_value(self.options, 'fetchFundingRates', {})
-        defaultSubType = self.safe_string(self.options, 'defaultSubType', 'inverse')
-        subType = self.safe_string(options, 'subType', defaultSubType)
-        subType = self.safe_string(params, 'subType', subType)
+        defaultSubType = self.safe_string(self.options, 'defaultSubType', 'linear')
+        subType = None
+        subType, params = self.handle_option_and_params(params, 'fetchFundingRates', 'subType', defaultSubType)
+        if symbols is not None:
+            firstSymbol = self.safe_string(symbols, 0)
+            market = self.market(firstSymbol)
+            isLinear = market['linear']
+            subType = 'linear' if isLinear else 'inverse'
         request: dict = {
             # 'contract_code': market['id'],
         }
-        params = self.omit(params, 'subType')
         response = None
         if subType == 'linear':
             response = await self.contractPublicGetLinearSwapApiV1SwapBatchFundingRate(self.extend(request, params))
@@ -7032,6 +7036,7 @@ class htx(Exchange, ImplicitAPI):
         if 'status' in response:
             #
             #     {"status":"error","err-code":"order-limitorder-amount-min-error","err-msg":"limit order amount error, min: `0.001`","data":null}
+            #     {"status":"ok","data":{"errors":[{"order_id":"1349442392365359104","err_code":1061,"err_msg":"The order does not exist."}],"successes":""},"ts":1741773744526}
             #
             status = self.safe_string(response, 'status')
             if status == 'error':
@@ -7047,6 +7052,15 @@ class htx(Exchange, ImplicitAPI):
             feedback = self.id + ' ' + body
             code = self.safe_string(response, 'code')
             self.throw_exactly_matched_exception(self.exceptions['exact'], code, feedback)
+        data = self.safe_dict(response, 'data')
+        errorsList = self.safe_list(data, 'errors')
+        if errorsList is not None:
+            first = self.safe_dict(errorsList, 0)
+            errcode = self.safe_string(first, 'err_code')
+            errmessage = self.safe_string(first, 'err_msg')
+            feedBack = self.id + ' ' + body
+            self.throw_exactly_matched_exception(self.exceptions['exact'], errcode, feedBack)
+            self.throw_exactly_matched_exception(self.exceptions['exact'], errmessage, feedBack)
         return None
 
     async def fetch_funding_history(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):

ccxt/async_support/hyperliquid.py

@@ -61,6 +61,7 @@ class hyperliquid(Exchange, ImplicitAPI):
                 'createStopOrder': True,
                 'createTriggerOrder': True,
                 'editOrder': True,
+                'editOrders': True,
                 'fetchAccounts': False,
                 'fetchBalance': True,
                 'fetchBorrowInterest': False,
@@ -1356,7 +1357,7 @@ class hyperliquid(Exchange, ImplicitAPI):
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
-        order, globalParams = self.parse_create_order_args(symbol, type, side, amount, price, params)
+        order, globalParams = self.parse_create_edit_order_args(None, symbol, type, side, amount, price, params)
         orders = await self.create_orders([order], globalParams)
         return orders[0]
 
@@ -1710,74 +1711,97 @@ class hyperliquid(Exchange, ImplicitAPI):
         #
         return response
 
-    def edit_order_request(self, id: str, symbol: str, type: str, side: str, amount: Num = None, price: Num = None, params={}):
+    def edit_orders_request(self, orders, params={}):
         self.check_required_credentials()
-        if id is None:
-            raise ArgumentsRequired(self.id + ' editOrder() requires an id argument')
-        market = self.market(symbol)
-        type = type.upper()
-        isMarket = (type == 'MARKET')
-        side = side.upper()
-        isBuy = (side == 'BUY')
-        defaultSlippage = self.safe_string(self.options, 'defaultSlippage')
-        slippage = self.safe_string(params, 'slippage', defaultSlippage)
-        defaultTimeInForce = 'ioc' if (isMarket) else 'gtc'
-        postOnly = self.safe_bool(params, 'postOnly', False)
-        if postOnly:
-            defaultTimeInForce = 'alo'
-        timeInForce = self.safe_string_lower(params, 'timeInForce', defaultTimeInForce)
-        timeInForce = self.capitalize(timeInForce)
-        clientOrderId = self.safe_string_2(params, 'clientOrderId', 'client_id')
-        triggerPrice = self.safe_string_2(params, 'triggerPrice', 'stopPrice')
-        stopLossPrice = self.safe_string(params, 'stopLossPrice', triggerPrice)
-        takeProfitPrice = self.safe_string(params, 'takeProfitPrice')
-        isTrigger = (stopLossPrice or takeProfitPrice)
-        params = self.omit(params, ['slippage', 'timeInForce', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice', 'clientOrderId', 'client_id'])
-        px = str(price)
-        if isMarket:
-            px = str(Precise.string_mul(price), Precise.string_add('1', slippage)) if (isBuy) else str(Precise.string_mul(price), Precise.string_sub('1', slippage))
-        else:
-            px = self.price_to_precision(symbol, str(price))
-        sz = self.amount_to_precision(symbol, amount)
-        reduceOnly = self.safe_bool(params, 'reduceOnly', False)
-        orderType: dict = {}
-        if isTrigger:
-            isTp = False
-            if takeProfitPrice is not None:
-                triggerPrice = self.price_to_precision(symbol, takeProfitPrice)
-                isTp = True
+        hasClientOrderId = False
+        for i in range(0, len(orders)):
+            rawOrder = orders[i]
+            orderParams = self.safe_dict(rawOrder, 'params', {})
+            clientOrderId = self.safe_string_2(orderParams, 'clientOrderId', 'client_id')
+            if clientOrderId is not None:
+                hasClientOrderId = True
+        if hasClientOrderId:
+            for i in range(0, len(orders)):
+                rawOrder = orders[i]
+                orderParams = self.safe_dict(rawOrder, 'params', {})
+                clientOrderId = self.safe_string_2(orderParams, 'clientOrderId', 'client_id')
+                if clientOrderId is None:
+                    raise ArgumentsRequired(self.id + ' editOrders() all orders must have clientOrderId if at least one has a clientOrderId')
+        params = self.omit(params, ['slippage', 'clientOrderId', 'client_id', 'slippage', 'triggerPrice', 'stopPrice', 'stopLossPrice', 'takeProfitPrice', 'timeInForce'])
+        modifies = []
+        for i in range(0, len(orders)):
+            rawOrder = orders[i]
+            id = self.safe_string(rawOrder, 'id')
+            marketId = self.safe_string(rawOrder, 'symbol')
+            market = self.market(marketId)
+            symbol = market['symbol']
+            type = self.safe_string_upper(rawOrder, 'type')
+            isMarket = (type == 'MARKET')
+            side = self.safe_string_upper(rawOrder, 'side')
+            isBuy = (side == 'BUY')
+            amount = self.safe_string(rawOrder, 'amount')
+            price = self.safe_string(rawOrder, 'price')
+            orderParams = self.safe_dict(rawOrder, 'params', {})
+            defaultSlippage = self.safe_string(self.options, 'defaultSlippage')
+            slippage = self.safe_string(orderParams, 'slippage', defaultSlippage)
+            defaultTimeInForce = 'ioc' if (isMarket) else 'gtc'
+            postOnly = self.safe_bool(orderParams, 'postOnly', False)
+            if postOnly:
+                defaultTimeInForce = 'alo'
+            timeInForce = self.safe_string_lower(orderParams, 'timeInForce', defaultTimeInForce)
+            timeInForce = self.capitalize(timeInForce)
+            clientOrderId = self.safe_string_2(orderParams, 'clientOrderId', 'client_id')
+            triggerPrice = self.safe_string_2(orderParams, 'triggerPrice', 'stopPrice')
+            stopLossPrice = self.safe_string(orderParams, 'stopLossPrice', triggerPrice)
+            takeProfitPrice = self.safe_string(orderParams, 'takeProfitPrice')
+            isTrigger = (stopLossPrice or takeProfitPrice)
+            reduceOnly = self.safe_bool(orderParams, 'reduceOnly', False)
+            orderParams = self.omit(orderParams, ['slippage', 'timeInForce', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice', 'clientOrderId', 'client_id', 'postOnly', 'reduceOnly'])
+            px = str(price)
+            if isMarket:
+                px = str(Precise.string_mul(price), Precise.string_add('1', slippage)) if (isBuy) else str(Precise.string_mul(price), Precise.string_sub('1', slippage))
             else:
-                triggerPrice = self.price_to_precision(symbol, stopLossPrice)
-            orderType['trigger'] = {
-                'isMarket': isMarket,
-                'triggerPx': triggerPrice,
-                'tpsl': 'tp' if (isTp) else 'sl',
+                px = self.price_to_precision(symbol, str(price))
+            sz = self.amount_to_precision(symbol, amount)
+            orderType: dict = {}
+            if isTrigger:
+                isTp = False
+                if takeProfitPrice is not None:
+                    triggerPrice = self.price_to_precision(symbol, takeProfitPrice)
+                    isTp = True
+                else:
+                    triggerPrice = self.price_to_precision(symbol, stopLossPrice)
+                orderType['trigger'] = {
+                    'isMarket': isMarket,
+                    'triggerPx': triggerPrice,
+                    'tpsl': 'tp' if (isTp) else 'sl',
+                }
+            else:
+                orderType['limit'] = {
+                    'tif': timeInForce,
+                }
+            if triggerPrice is None:
+                triggerPrice = '0'
+            orderReq: dict = {
+                'a': self.parse_to_int(market['baseId']),
+                'b': isBuy,
+                'p': px,
+                's': sz,
+                'r': reduceOnly,
+                't': orderType,
+                # 'c': clientOrderId,
             }
-        else:
-            orderType['limit'] = {
-                'tif': timeInForce,
+            if clientOrderId is not None:
+                orderReq['c'] = clientOrderId
+            modifyReq: dict = {
+                'oid': self.parse_to_int(id),
+                'order': orderReq,
             }
-        if triggerPrice is None:
-            triggerPrice = '0'
+            modifies.append(modifyReq)
         nonce = self.milliseconds()
-        orderReq: dict = {
-            'a': self.parse_to_int(market['baseId']),
-            'b': isBuy,
-            'p': px,
-            's': sz,
-            'r': reduceOnly,
-            't': orderType,
-            # 'c': clientOrderId,
-        }
-        if clientOrderId is not None:
-            orderReq['c'] = clientOrderId
-        modifyReq: dict = {
-            'oid': self.parse_to_int(id),
-            'order': orderReq,
-        }
         modifyAction: dict = {
             'type': 'batchModify',
-            'modifies': [modifyReq],
+            'modifies': modifies,
         }
         vaultAddress = self.format_vault_address(self.safe_string(params, 'vaultAddress'))
         signature = self.sign_l1_action(modifyAction, nonce, vaultAddress)
@@ -1796,7 +1820,6 @@ class hyperliquid(Exchange, ImplicitAPI):
         """
         edit a trade order
 
-        https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#modify-an-order
         https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#modify-multiple-orders
 
         :param str id: cancel order id
@@ -1815,8 +1838,24 @@ class hyperliquid(Exchange, ImplicitAPI):
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
-        market = self.market(symbol)
-        request = self.edit_order_request(id, symbol, type, side, amount, price, params)
+        if id is None:
+            raise ArgumentsRequired(self.id + ' editOrder() requires an id argument')
+        order, globalParams = self.parse_create_edit_order_args(id, symbol, type, side, amount, price, params)
+        orders = await self.edit_orders([order], globalParams)
+        return orders[0]
+
+    async def edit_orders(self, orders: List[OrderRequest], params={}):
+        """
+        edit a list of trade orders
+
+        https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#modify-multiple-orders
+
+        :param Array orders: list of orders to create, each object should contain the parameters required by createOrder, namely symbol, type, side, amount, price and params
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        request = self.edit_orders_request(orders, params)
         response = await self.privatePostExchange(request)
         #
         #     {
@@ -1856,8 +1895,7 @@ class hyperliquid(Exchange, ImplicitAPI):
         responseObject = self.safe_dict(response, 'response', {})
         dataObject = self.safe_dict(responseObject, 'data', {})
         statuses = self.safe_list(dataObject, 'statuses', [])
-        first = self.safe_dict(statuses, 0, {})
-        return self.parse_order(first, market)
+        return self.parse_orders(statuses)
 
     async def fetch_funding_rate_history(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
@@ -3387,7 +3425,7 @@ class hyperliquid(Exchange, ImplicitAPI):
                 return byType[type]
         return self.safe_value(config, 'cost', 1)
 
-    def parse_create_order_args(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
+    def parse_create_edit_order_args(self, id: Str, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
         market = self.market(symbol)
         vaultAddress = self.safe_string(params, 'vaultAddress')
         params = self.omit(params, 'vaultAddress')
@@ -3403,4 +3441,6 @@ class hyperliquid(Exchange, ImplicitAPI):
         globalParams = {}
         if vaultAddress is not None:
             globalParams['vaultAddress'] = vaultAddress
+        if id is not None:
+            order['id'] = id
         return [order, globalParams]

ccxt/async_support/luno.py

@@ -5,7 +5,7 @@
 
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.luno import ImplicitAPI
-from ccxt.base.types import Account, Any, Balances, Currency, Int, LedgerEntry, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface
+from ccxt.base.types import Account, Any, Balances, Currency, DepositAddress, Int, LedgerEntry, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ArgumentsRequired
@@ -35,6 +35,7 @@ class luno(Exchange, ImplicitAPI):
                 'cancelOrder': True,
                 'closeAllPositions': False,
                 'closePosition': False,
+                'createDepositAddress': True,
                 'createOrder': True,
                 'createReduceOnlyOrder': False,
                 'fetchAccounts': True,
@@ -43,6 +44,7 @@ class luno(Exchange, ImplicitAPI):
                 'fetchClosedOrders': True,
                 'fetchCrossBorrowRate': False,
                 'fetchCrossBorrowRates': False,
+                'fetchDepositAddress': True,
                 'fetchFundingHistory': False,
                 'fetchFundingRate': False,
                 'fetchFundingRateHistory': False,
@@ -1158,6 +1160,116 @@ class luno(Exchange, ImplicitAPI):
             'fee': None,
         }, currency)
 
+    async def create_deposit_address(self, code: str, params={}) -> DepositAddress:
+        """
+        create a currency deposit address
+
+        https://www.luno.com/en/developers/api#tag/Receive/operation/createFundingAddress
+
+        :param str code: unified currency code of the currency for the deposit address
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.name]: an optional name for the new address
+        :param int [params.account_id]: an optional account id for the new address
+        :returns dict: an `address structure <https://docs.ccxt.com/#/?id=address-structure>`
+        """
+        await self.load_markets()
+        currency = self.currency(code)
+        request: dict = {
+            'asset': currency['id'],
+        }
+        response = await self.privatePostFundingAddress(self.extend(request, params))
+        #
+        #     {
+        #         "account_id": "string",
+        #         "address": "string",
+        #         "address_meta": [
+        #             {
+        #                 "label": "string",
+        #                 "value": "string"
+        #             }
+        #         ],
+        #         "asset": "string",
+        #         "assigned_at": 0,
+        #         "name": "string",
+        #         "network": 0,
+        #         "qr_code_uri": "string",
+        #         "receive_fee": "string",
+        #         "total_received": "string",
+        #         "total_unconfirmed": "string"
+        #     }
+        #
+        return self.parse_deposit_address(response, currency)
+
+    async def fetch_deposit_address(self, code: str, params={}) -> DepositAddress:
+        """
+        fetch the deposit address for a currency associated with self account
+
+        https://www.luno.com/en/developers/api#tag/Receive/operation/getFundingAddress
+
+        :param str code: unified currency code
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.address]: a specific cryptocurrency address to retrieve
+        :returns dict: an `address structure <https://docs.ccxt.com/#/?id=address-structure>`
+        """
+        await self.load_markets()
+        currency = self.currency(code)
+        request: dict = {
+            'asset': currency['id'],
+        }
+        response = await self.privateGetFundingAddress(self.extend(request, params))
+        #
+        #     {
+        #         "account_id": "string",
+        #         "address": "string",
+        #         "address_meta": [
+        #             {
+        #                 "label": "string",
+        #                 "value": "string"
+        #             }
+        #         ],
+        #         "asset": "string",
+        #         "assigned_at": 0,
+        #         "name": "string",
+        #         "network": 0,
+        #         "qr_code_uri": "string",
+        #         "receive_fee": "string",
+        #         "total_received": "string",
+        #         "total_unconfirmed": "string"
+        #     }
+        #
+        return self.parse_deposit_address(response, currency)
+
+    def parse_deposit_address(self, depositAddress, currency: Currency = None) -> DepositAddress:
+        #
+        #     {
+        #         "account_id": "string",
+        #         "address": "string",
+        #         "address_meta": [
+        #             {
+        #                 "label": "string",
+        #                 "value": "string"
+        #             }
+        #         ],
+        #         "asset": "string",
+        #         "assigned_at": 0,
+        #         "name": "string",
+        #         "network": 0,
+        #         "qr_code_uri": "string",
+        #         "receive_fee": "string",
+        #         "total_received": "string",
+        #         "total_unconfirmed": "string"
+        #     }
+        #
+        currencyId = self.safe_string_upper(depositAddress, 'currency')
+        code = self.safe_currency_code(currencyId, currency)
+        return {
+            'info': depositAddress,
+            'currency': code,
+            'network': None,
+            'address': self.safe_string(depositAddress, 'address'),
+            'tag': self.safe_string(depositAddress, 'name'),
+        }
+
     def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
         url = self.urls['api'][api] + '/' + self.version + '/' + self.implode_params(path, params)
         query = self.omit(params, self.extract_params(path))

ccxt/async_support/paradex.py

@@ -1170,6 +1170,10 @@ class paradex(Exchange, ImplicitAPI):
         average = self.omit_zero(self.safe_string(order, 'avg_fill_price'))
         remaining = self.omit_zero(self.safe_string(order, 'remaining_size'))
         lastUpdateTimestamp = self.safe_integer(order, 'last_updated_at')
+        flags = self.safe_list(order, 'flags', [])
+        reduceOnly = None
+        if 'REDUCE_ONLY' in flags:
+            reduceOnly = True
         return self.safe_order({
             'id': orderId,
             'clientOrderId': clientOrderId,
@@ -1182,7 +1186,7 @@ class paradex(Exchange, ImplicitAPI):
             'type': self.parse_order_type(orderType),
             'timeInForce': self.parse_time_in_force(self.safe_string(order, 'instrunction')),
             'postOnly': None,
-            'reduceOnly': None,
+            'reduceOnly': reduceOnly,
             'side': side,
             'price': price,
             'triggerPrice': self.safe_string(order, 'trigger_price'),
@@ -1250,6 +1254,8 @@ class paradex(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param float [params.stopPrice]: alias for triggerPrice
         :param float [params.triggerPrice]: The price a trigger order is triggered at
+        :param float [params.stopLossPrice]: the price that a stop loss order is triggered at
+        :param float [params.takeProfitPrice]: the price that a take profit order is triggered at
         :param str [params.timeInForce]: "GTC", "IOC", or "POST_ONLY"
         :param bool [params.postOnly]: True or False
         :param bool [params.reduceOnly]: Ensures that the executed order does not flip the opened position.
@@ -1265,11 +1271,15 @@ class paradex(Exchange, ImplicitAPI):
         request: dict = {
             'market': market['id'],
             'side': orderSide,
-            'type': orderType,  # LIMIT/MARKET/STOP_LIMIT/STOP_MARKET
-            'size': self.amount_to_precision(symbol, amount),
+            'type': orderType,  # LIMIT/MARKET/STOP_LIMIT/STOP_MARKET,STOP_LOSS_MARKET,STOP_LOSS_LIMIT,TAKE_PROFIT_MARKET,TAKE_PROFIT_LIMIT
         }
         triggerPrice = self.safe_string_2(params, 'triggerPrice', 'stopPrice')
+        stopLossPrice = self.safe_string(params, 'stopLossPrice')
+        takeProfitPrice = self.safe_string(params, 'takeProfitPrice')
         isMarket = orderType == 'MARKET'
+        isTakeProfitOrder = (takeProfitPrice is not None)
+        isStopLossOrder = (stopLossPrice is not None)
+        isStopOrder = (triggerPrice is not None) or isTakeProfitOrder or isStopLossOrder
         timeInForce = self.safe_string_upper(params, 'timeInForce')
         postOnly = self.is_post_only(isMarket, None, params)
         if not isMarket:
@@ -1277,22 +1287,51 @@ class paradex(Exchange, ImplicitAPI):
                 request['instruction'] = 'POST_ONLY'
             elif timeInForce == 'ioc':
                 request['instruction'] = 'IOC'
-        if reduceOnly:
-            request['flags'] = [
-                'REDUCE_ONLY',
-            ]
         if price is not None:
             request['price'] = self.price_to_precision(symbol, price)
         clientOrderId = self.safe_string_n(params, ['clOrdID', 'clientOrderId', 'client_order_id'])
         if clientOrderId is not None:
             request['client_id'] = clientOrderId
-        if triggerPrice is not None:
+        sizeString = '0'
+        stopPrice = None
+        if isStopOrder:
+            # flags: Reduce_Only must be provided for TPSL orders.
             if isMarket:
-                request['type'] = 'STOP_MARKET'
+                if isStopLossOrder:
+                    stopPrice = self.price_to_precision(symbol, stopLossPrice)
+                    reduceOnly = True
+                    request['type'] = 'STOP_LOSS_MARKET'
+                elif isTakeProfitOrder:
+                    stopPrice = self.price_to_precision(symbol, takeProfitPrice)
+                    reduceOnly = True
+                    request['type'] = 'TAKE_PROFIT_MARKET'
+                else:
+                    stopPrice = self.price_to_precision(symbol, triggerPrice)
+                    sizeString = self.amount_to_precision(symbol, amount)
+                    request['type'] = 'STOP_MARKET'
             else:
-                request['type'] = 'STOP_LIMIT'
-            request['trigger_price'] = self.price_to_precision(symbol, triggerPrice)
-        params = self.omit(params, ['reduceOnly', 'reduce_only', 'clOrdID', 'clientOrderId', 'client_order_id', 'postOnly', 'timeInForce', 'stopPrice', 'triggerPrice'])
+                if isStopLossOrder:
+                    stopPrice = self.price_to_precision(symbol, stopLossPrice)
+                    reduceOnly = True
+                    request['type'] = 'STOP_LOSS_LIMIT'
+                elif isTakeProfitOrder:
+                    stopPrice = self.price_to_precision(symbol, takeProfitPrice)
+                    reduceOnly = True
+                    request['type'] = 'TAKE_PROFIT_LIMIT'
+                else:
+                    stopPrice = self.price_to_precision(symbol, triggerPrice)
+                    sizeString = self.amount_to_precision(symbol, amount)
+                    request['type'] = 'STOP_LIMIT'
+        else:
+            sizeString = self.amount_to_precision(symbol, amount)
+        if stopPrice is not None:
+            request['trigger_price'] = stopPrice
+        request['size'] = sizeString
+        if reduceOnly:
+            request['flags'] = [
+                'REDUCE_ONLY',
+            ]
+        params = self.omit(params, ['reduceOnly', 'reduce_only', 'clOrdID', 'clientOrderId', 'client_order_id', 'postOnly', 'timeInForce', 'stopPrice', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice'])
         account = await self.retrieve_account()
         now = self.nonce()
         orderReq = {