Exchange stoploss function takes side

freqtrade/exchange/binance.py

@@ -25,20 +25,25 @@ class Binance(Exchange):
         "l2_limit_range": [5, 10, 20, 50, 100, 500, 1000],
     }
 
-    def stoploss_adjust(self, stop_loss: float, order: Dict) -> bool:
+    def stoploss_adjust(self, stop_loss: float, order: Dict, side: str) -> bool:
         """
         Verify stop_loss against stoploss-order value (limit or price)
         Returns True if adjustment is necessary.
+        :param side: "buy" or "sell"
         """
+        # TODO-mg: Short support
         return order['type'] == 'stop_loss_limit' and stop_loss > float(order['info']['stopPrice'])
 
     @retrier(retries=0)
-    def stoploss(self, pair: str, amount: float, stop_price: float, order_types: Dict) -> Dict:
+    def stoploss(self, pair: str, amount: float,
+                 stop_price: float, order_types: Dict, side: str) -> Dict:
         """
         creates a stoploss limit order.
         this stoploss-limit is binance-specific.
         It may work with a limited number of other exchanges, but this has not been tested yet.
+        :param side: "buy" or "sell"
         """
+        # TODO-mg: Short support
         # Limit price threshold: As limit price should always be below stop-price
         limit_price_pct = order_types.get('stoploss_on_exchange_limit_ratio', 0.99)
         rate = stop_price * limit_price_pct

freqtrade/exchange/exchange.py

@@ -802,14 +802,15 @@ class Exchange:
     ):
         raise OperationalException(f"Leverage is not available on {self.name} using freqtrade")
 
-    def stoploss_adjust(self, stop_loss: float, order: Dict) -> bool:
+    def stoploss_adjust(self, stop_loss: float, order: Dict, side: str) -> bool:
         """
         Verify stop_loss against stoploss-order value (limit or price)
         Returns True if adjustment is necessary.
         """
         raise OperationalException(f"stoploss is not implemented for {self.name}.")
 
-    def stoploss(self, pair: str, amount: float, stop_price: float, order_types: Dict) -> Dict:
+    def stoploss(self, pair: str, amount: float,
+                 stop_price: float, order_types: Dict, side: str) -> Dict:
         """
         creates a stoploss order.
         The precise ordertype is determined by the order_types dict or exchange default.

freqtrade/exchange/ftx.py

@@ -31,21 +31,25 @@ class Ftx(Exchange):
         return (parent_check and
                 market.get('spot', False) is True)
 
-    def stoploss_adjust(self, stop_loss: float, order: Dict) -> bool:
+    def stoploss_adjust(self, stop_loss: float, order: Dict, side: str) -> bool:
         """
         Verify stop_loss against stoploss-order value (limit or price)
         Returns True if adjustment is necessary.
         """
+        # TODO-mg: Short support
         return order['type'] == 'stop' and stop_loss > float(order['price'])
 
     @retrier(retries=0)
-    def stoploss(self, pair: str, amount: float, stop_price: float, order_types: Dict) -> Dict:
+    def stoploss(self, pair: str, amount: float,
+                 stop_price: float, order_types: Dict, side: str) -> Dict:
         """
         Creates a stoploss order.
         depending on order_types.stoploss configuration, uses 'market' or limit order.
 
         Limit orders are defined by having orderPrice set, otherwise a market order is used.
         """
+        # TODO-mg: Short support
+
         limit_price_pct = order_types.get('stoploss_on_exchange_limit_ratio', 0.99)
         limit_rate = stop_price * limit_price_pct
 

freqtrade/exchange/kraken.py

@@ -67,20 +67,23 @@ class Kraken(Exchange):
         except ccxt.BaseError as e:
             raise OperationalException(e) from e
 
-    def stoploss_adjust(self, stop_loss: float, order: Dict) -> bool:
+    def stoploss_adjust(self, stop_loss: float, order: Dict, side: str) -> bool:
         """
         Verify stop_loss against stoploss-order value (limit or price)
         Returns True if adjustment is necessary.
         """
+        # TODO-mg: Short support
         return (order['type'] in ('stop-loss', 'stop-loss-limit')
                 and stop_loss > float(order['price']))
 
     @retrier(retries=0)
-    def stoploss(self, pair: str, amount: float, stop_price: float, order_types: Dict) -> Dict:
+    def stoploss(self, pair: str, amount: float,
+                 stop_price: float, order_types: Dict, side: str) -> Dict:
         """
         Creates a stoploss market order.
         Stoploss market orders is the only stoploss type supported by kraken.
         """
+        # TODO-mg: Short support
         params = self._params.copy()
 
         if order_types.get('stoploss', 'market') == 'limit':