Add stoploss support for huobi

freqtrade/exchange/huobi.py

@@ -2,7 +2,12 @@
 import logging
 from typing import Dict
 
+import ccxt
+
+from freqtrade.exceptions import (DDosProtection, InsufficientFundsError, InvalidOrderException,
+                                  OperationalException, TemporaryError)
 from freqtrade.exchange import Exchange
+from freqtrade.exchange.common import retrier
 
 
 logger = logging.getLogger(__name__)
@@ -15,5 +20,75 @@ class Huobi(Exchange):
     """
 
     _ft_has: Dict = {
+        "stoploss_on_exchange": True,
         "ohlcv_candle_limit": 2000,
     }
+
+    def stoploss_adjust(self, stop_loss: float, order: Dict) -> bool:
+        """
+        Verify stop_loss against stoploss-order value (limit or price)
+        Returns True if adjustment is necessary.
+        """
+        return order['type'] == 'stop' and stop_loss > float(order['stopPrice'])
+
+    @retrier(retries=0)
+    def stoploss(self, pair: str, amount: float, stop_price: float, order_types: Dict) -> Dict:
+        """
+        creates a stoploss limit order.
+        this stoploss-limit is huobi-specific.
+        TODO: Compare this with other stoploss implementations -
+        """
+        # 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
+
+        ordertype = "stop-limit"
+
+        stop_price = self.price_to_precision(pair, stop_price)
+
+        # Ensure rate is less than stop price
+        if stop_price <= rate:
+            raise OperationalException(
+                'In stoploss limit order, stop price should be more than limit price')
+
+        if self._config['dry_run']:
+            dry_order = self.create_dry_run_order(
+                pair, ordertype, "sell", amount, stop_price)
+            return dry_order
+
+        try:
+            params = self._params.copy()
+            params.update({
+                "stop-price": stop_price,
+                "operator": "lte",
+                })
+
+            amount = self.amount_to_precision(pair, amount)
+
+            rate = self.price_to_precision(pair, rate)
+
+            order = self._api.create_order(symbol=pair, type=ordertype, side='sell',
+                                           amount=amount, price=rate, params=params)
+            logger.info('stoploss limit order added for %s. '
+                        'stop price: %s. limit: %s', pair, stop_price, rate)
+            self._log_exchange_response('create_stoploss_order', order)
+            return order
+        except ccxt.InsufficientFunds as e:
+            raise InsufficientFundsError(
+                f'Insufficient funds to create {ordertype} sell order on market {pair}. '
+                f'Tried to sell amount {amount} at rate {rate}. '
+                f'Message: {e}') from e
+        except ccxt.InvalidOrder as e:
+            # Errors:
+            # `Order would trigger immediately.`
+            raise InvalidOrderException(
+                f'Could not create {ordertype} sell order on market {pair}. '
+                f'Tried to sell amount {amount} at rate {rate}. '
+                f'Message: {e}') from e
+        except ccxt.DDoSProtection as e:
+            raise DDosProtection(e) from e
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not place sell order due to {e.__class__.__name__}. Message: {e}') from e
+        except ccxt.BaseError as e:
+            raise OperationalException(e) from e