Merge pull request #8360 from freqtrade/okx_stop

Okx stoploss on exchange

freqtrade/exchange/okx.py

@@ -1,14 +1,16 @@
 import logging
-from typing import Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 import ccxt
 
 from freqtrade.constants import BuySell
 from freqtrade.enums import CandleType, MarginMode, TradingMode
 from freqtrade.enums.pricetype import PriceType
-from freqtrade.exceptions import DDosProtection, OperationalException, TemporaryError
+from freqtrade.exceptions import (DDosProtection, OperationalException, RetryableOrderError,
+                                  TemporaryError)
 from freqtrade.exchange import Exchange, date_minus_candles
 from freqtrade.exchange.common import retrier
+from freqtrade.misc import safe_value_fallback2
 
 
 logger = logging.getLogger(__name__)
@@ -24,11 +26,13 @@ class Okx(Exchange):
         "ohlcv_candle_limit": 100,  # Warning, special case with data prior to X months
         "mark_ohlcv_timeframe": "4h",
         "funding_fee_timeframe": "8h",
+        "stoploss_order_types": {"limit": "limit"},
+        "stoploss_on_exchange": True,
     }
     _ft_has_futures: Dict = {
         "tickers_have_quoteVolume": False,
         "fee_cost_in_contracts": True,
-        "stop_price_type_field": "tpTriggerPxType",
+        "stop_price_type_field": "slTriggerPxType",
         "stop_price_type_value_mapping": {
             PriceType.LAST: "last",
             PriceType.MARK: "index",
@@ -157,3 +161,78 @@ class Okx(Exchange):
 
         pair_tiers = self._leverage_tiers[pair]
         return pair_tiers[-1]['maxNotional'] / leverage
+
+    def _get_stop_params(self, side: BuySell, ordertype: str, stop_price: float) -> Dict:
+
+        params = self._params.copy()
+        # Verify if stopPrice works for your exchange!
+        params.update({'stopLossPrice': stop_price})
+
+        if self.trading_mode == TradingMode.FUTURES and self.margin_mode:
+            params['tdMode'] = self.margin_mode.value
+            params['posSide'] = self._get_posSide(side, True)
+        return params
+
+    def stoploss_adjust(self, stop_loss: float, order: Dict, side: str) -> bool:
+        """
+        OKX uses non-default stoploss price naming.
+        """
+        if not self._ft_has.get('stoploss_on_exchange'):
+            raise OperationalException(f"stoploss is not implemented for {self.name}.")
+
+        return (
+            order.get('stopLossPrice', None) is None
+            or ((side == "sell" and stop_loss > float(order['stopLossPrice'])) or
+                (side == "buy" and stop_loss < float(order['stopLossPrice'])))
+        )
+
+    def fetch_stoploss_order(self, order_id: str, pair: str, params: Dict = {}) -> Dict:
+        if self._config['dry_run']:
+            return self.fetch_dry_run_order(order_id)
+
+        try:
+            params1 = {'stop': True}
+            order_reg = self._api.fetch_order(order_id, pair, params=params1)
+            self._log_exchange_response('fetch_stoploss_order', order_reg)
+            return order_reg
+        except ccxt.OrderNotFound:
+            pass
+        params2 = {'stop': True, 'ordType': 'conditional'}
+        for method in (self._api.fetch_open_orders, self._api.fetch_closed_orders,
+                       self._api.fetch_canceled_orders):
+            try:
+                orders = method(pair, params=params2)
+                orders_f = [order for order in orders if order['id'] == order_id]
+                if orders_f:
+                    order = orders_f[0]
+                    if (order['status'] == 'closed'
+                            and (real_order_id := order.get('info', {}).get('ordId')) is not None):
+                        # Once a order triggered, we fetch the regular followup order.
+                        order_reg = self.fetch_order(real_order_id, pair)
+                        self._log_exchange_response('fetch_stoploss_order1', order_reg)
+                        order_reg['id_stop'] = order_reg['id']
+                        order_reg['id'] = order_id
+                        order_reg['type'] = 'stoploss'
+                        order_reg['status_stop'] = 'triggered'
+                        return order_reg
+                    order['type'] = 'stoploss'
+                    return order
+            except ccxt.BaseError:
+                pass
+        raise RetryableOrderError(
+                f'StoplossOrder not found (pair: {pair} id: {order_id}).')
+
+    def get_order_id_conditional(self, order: Dict[str, Any]) -> str:
+        if order['type'] == 'stop':
+            return safe_value_fallback2(order, order, 'id_stop', 'id')
+        return order['id']
+
+    def cancel_stoploss_order(self, order_id: str, pair: str, params: Dict = {}) -> Dict:
+        params1 = {'stop': True}
+        # 'ordType': 'conditional'
+        #
+        return self.cancel_order(
+            order_id=order_id,
+            pair=pair,
+            params=params1,
+        )