Merge branch 'freqtrade:develop' into plot_hyperopt_stats

freqtrade/constants.py

@@ -140,7 +140,7 @@ CONF_SCHEMA = {
             'minProperties': 1
         },
         'amount_reserve_percent': {'type': 'number', 'minimum': 0.0, 'maximum': 0.5},
-        'stoploss': {'type': 'number', 'maximum': 0, 'exclusiveMaximum': True},
+        'stoploss': {'type': 'number', 'maximum': 0, 'exclusiveMaximum': True, 'minimum': -1},
         'trailing_stop': {'type': 'boolean'},
         'trailing_stop_positive': {'type': 'number', 'minimum': 0, 'maximum': 1},
         'trailing_stop_positive_offset': {'type': 'number', 'minimum': 0, 'maximum': 1},

freqtrade/exchange/exchange.py

@@ -9,7 +9,7 @@ import logging
 from copy import deepcopy
 from datetime import datetime, timedelta, timezone
 from math import ceil
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Coroutine, Dict, List, Optional, Tuple
 
 import arrow
 import ccxt
@@ -1371,6 +1371,22 @@ class Exchange:
         data = sorted(data, key=lambda x: x[0])
         return pair, timeframe, data
 
+    def _build_coroutine(self, pair: str, timeframe: str, since_ms: Optional[int]) -> Coroutine:
+        if not since_ms and self.required_candle_call_count > 1:
+            # Multiple calls for one pair - to get more history
+            one_call = timeframe_to_msecs(timeframe) * self.ohlcv_candle_limit(timeframe)
+            move_to = one_call * self.required_candle_call_count
+            now = timeframe_to_next_date(timeframe)
+            since_ms = int((now - timedelta(seconds=move_to // 1000)).timestamp() * 1000)
+
+        if since_ms:
+            return self._async_get_historic_ohlcv(
+                pair, timeframe, since_ms=since_ms, raise_=True)
+        else:
+            # One call ... "regular" refresh
+            return self._async_get_candle_history(
+                pair, timeframe, since_ms=since_ms)
+
     def refresh_latest_ohlcv(self, pair_list: ListPairsWithTimeframes, *,
                              since_ms: Optional[int] = None, cache: bool = True
                              ) -> Dict[Tuple[str, str], DataFrame]:
@@ -1389,22 +1405,15 @@ class Exchange:
         cached_pairs = []
         # Gather coroutines to run
         for pair, timeframe in set(pair_list):
+            if timeframe not in self.timeframes:
+                logger.warning(
+                    f"Cannot download ({pair}, {timeframe}) combination as this timeframe is "
+                    f"not available on {self.name}. Available timeframes are "
+                    f"{', '.join(self.timeframes)}.")
+                continue
             if ((pair, timeframe) not in self._klines or not cache
                     or self._now_is_time_to_refresh(pair, timeframe)):
-                if not since_ms and self.required_candle_call_count > 1:
-                    # Multiple calls for one pair - to get more history
-                    one_call = timeframe_to_msecs(timeframe) * self.ohlcv_candle_limit(timeframe)
-                    move_to = one_call * self.required_candle_call_count
-                    now = timeframe_to_next_date(timeframe)
-                    since_ms = int((now - timedelta(seconds=move_to // 1000)).timestamp() * 1000)
-
-                if since_ms:
-                    input_coroutines.append(self._async_get_historic_ohlcv(
-                        pair, timeframe, since_ms=since_ms, raise_=True))
-                else:
-                    # One call ... "regular" refresh
-                    input_coroutines.append(self._async_get_candle_history(
-                        pair, timeframe, since_ms=since_ms))
+                input_coroutines.append(self._build_coroutine(pair, timeframe, since_ms))
             else:
                 logger.debug(
                     "Using cached candle (OHLCV) data for pair %s, timeframe %s ...",

freqtrade/freqtradebot.py

@@ -873,11 +873,15 @@ class FreqtradeBot(LoggingMixin):
             stop_price = trade.open_rate * (1 + stoploss)
 
             if self.create_stoploss_order(trade=trade, stop_price=stop_price):
+                # The above will return False if the placement failed and the trade was force-sold.
+                # in which case the trade will be closed - which we must check below.
                 trade.stoploss_last_update = datetime.utcnow()
                 return False
 
         # If stoploss order is canceled for some reason we add it
-        if stoploss_order and stoploss_order['status'] in ('canceled', 'cancelled'):
+        if (trade.is_open
+                and stoploss_order
+                and stoploss_order['status'] in ('canceled', 'cancelled')):
             if self.create_stoploss_order(trade=trade, stop_price=trade.stop_loss):
                 return False
             else:
@@ -887,7 +891,7 @@ class FreqtradeBot(LoggingMixin):
         # Finally we check if stoploss on exchange should be moved up because of trailing.
         # Triggered Orders are now real orders - so don't replace stoploss anymore
         if (
-            stoploss_order
+            trade.is_open and stoploss_order
             and stoploss_order.get('status_stop') != 'triggered'
             and (self.config.get('trailing_stop', False)
                  or self.config.get('use_custom_stoploss', False))
@@ -907,7 +911,9 @@ class FreqtradeBot(LoggingMixin):
         :param order: Current on exchange stoploss order
         :return: None
         """
-        if self.exchange.stoploss_adjust(trade.stop_loss, order):
+        stoploss_norm = self.exchange.price_to_precision(trade.pair, trade.stop_loss)
+
+        if self.exchange.stoploss_adjust(stoploss_norm, order):
             # we check if the update is necessary
             update_beat = self.strategy.order_types.get('stoploss_on_exchange_interval', 60)
             if (datetime.utcnow() - trade.stoploss_last_update).total_seconds() >= update_beat:

freqtrade/persistence/models.py

@@ -304,7 +304,7 @@ class LocalTrade():
     # absolute value of the initial stop loss
     initial_stop_loss: float = 0.0
     # percentage value of the initial stop loss
-    initial_stop_loss_pct: float = 0.0
+    initial_stop_loss_pct: Optional[float] = None
     # stoploss order id which is on exchange
     stoploss_order_id: Optional[str] = None
     # last update time of the stoploss order on exchange
@@ -446,7 +446,8 @@ class LocalTrade():
         new_loss = float(current_price * (1 - abs(stoploss)))
 
         # no stop loss assigned yet
-        if not self.stop_loss:
+        # if not self.stop_loss:
+        if self.initial_stop_loss_pct is None:
             logger.debug(f"{self.pair} - Assigning new stoploss...")
             self._set_new_stoploss(new_loss, stoploss)
             self.initial_stop_loss = new_loss
@@ -786,6 +787,7 @@ class LocalTrade():
                 logger.info(f"Stoploss for {trade} needs adjustment...")
                 # Force reset of stoploss
                 trade.stop_loss = None
+                trade.initial_stop_loss_pct = None
                 trade.adjust_stop_loss(trade.open_rate, desired_stoploss)
                 logger.info(f"New stoploss: {trade.stop_loss}.")
 

freqtrade/rpc/fiat_convert.py

@@ -23,6 +23,7 @@ coingecko_mapping = {
     'eth': 'ethereum',
     'bnb': 'binancecoin',
     'sol': 'solana',
+    'usdt': 'tether',
 }