Merge branch 'develop' into pr/SurferAdmin/6916

2022-07-11 11:49:22 +02:00 · 2022-07-11 11:49:22 +02:00 · ed03ef47ef
commit ed03ef47ef
parent ec3179156c f8e35d8760
42 changed files with 13169 additions and 12252 deletions
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@ -13,11 +13,11 @@ repos:
      - id: mypy
        exclude: build_helpers
        additional_dependencies:
-          - types-cachetools==5.0.2
+          - types-cachetools==5.2.1
          - types-filelock==3.2.7
-          - types-requests==2.27.30
-          - types-tabulate==0.8.9
-          - types-python-dateutil==2.8.17
+          - types-requests==2.28.0
+          - types-tabulate==0.8.11
+          - types-python-dateutil==2.8.18
        # stages: [push]

  - repo: https://github.com/pycqa/isort
--- a/docker/Dockerfile.custom
+++ b/docker/Dockerfile.custom
@ -7,4 +7,5 @@ FROM freqtradeorg/freqtrade:develop
 # The below dependency - pyti - serves as an example. Please use whatever you need!
 RUN pip install --user pyti

+# Switch back to user (only if you required root above)
 # USER ftuser
--- a/docs/bot-basics.md
+++ b/docs/bot-basics.md
@ -20,7 +20,9 @@ All profit calculations of Freqtrade include fees. For Backtesting / Hyperopt /
 ## Bot execution logic

 Starting freqtrade in dry-run or live mode (using `freqtrade trade`) will start the bot and start the bot iteration loop.
-By default, loop runs every few seconds (`internals.process_throttle_secs`) and does roughly the following in the following sequence:
+This will also run the `bot_start()` callback.
+
+By default, the bot loop runs every few seconds (`internals.process_throttle_secs`) and performs the following actions:

 * Fetch open trades from persistence.
 * Calculate current list of tradable pairs.
@ -54,6 +56,7 @@ This loop will be repeated again and again until the bot is stopped.
 [backtesting](backtesting.md) or [hyperopt](hyperopt.md) do only part of the above logic, since most of the trading operations are fully simulated.

 * Load historic data for configured pairlist.
+* Calls `bot_start()` once.
 * Calls `bot_loop_start()` once.
 * Calculate indicators (calls `populate_indicators()` once per pair).
 * Calculate entry / exit signals (calls `populate_entry_trend()` and `populate_exit_trend()` once per pair).
--- a/docs/developer.md
+++ b/docs/developer.md
@ -334,7 +334,7 @@ lev_tiers = exchange.fetch_leverage_tiers()

 # Assumes this is running in the root of the repository.
 file = Path('freqtrade/exchange/binance_leverage_tiers.json')
-json.dump(lev_tiers, file.open('w'), indent=2)
+json.dump(dict(sorted(lev_tiers.items())), file.open('w'), indent=2)

 ```

--- a/docs/hyperopt.md
+++ b/docs/hyperopt.md
@ -271,7 +271,8 @@ The last one we call `trigger` and use it to decide which buy trigger we want to

 !!! Note "Parameter space assignment"
    Parameters must either be assigned to a variable named `buy_*` or `sell_*` - or contain `space='buy'` | `space='sell'` to be assigned to a space correctly.
-    If no parameter is available for a space, you'll receive the error that no space was found when running hyperopt.
+    If no parameter is available for a space, you'll receive the error that no space was found when running hyperopt.  
+    Parameters with unclear space (e.g. `adx_period = IntParameter(4, 24, default=14)` - no explicit nor implicit space) will not be detected and will therefore be ignored.

 So let's write the buy strategy using these values:

--- a/docs/requirements-docs.txt
+++ b/docs/requirements-docs.txt
@ -1,5 +1,5 @@
 mkdocs==1.3.0
-mkdocs-material==8.3.6
+mkdocs-material==8.3.9
 mdx_truly_sane_lists==1.2
 pymdown-extensions==9.5
 jinja2==3.1.2
--- a/docs/stoploss.md
+++ b/docs/stoploss.md
@ -130,7 +130,7 @@ In summary: The stoploss will be adjusted to be always be -10% of the highest ob

 ### Trailing stop loss, custom positive loss

-It is also possible to have a default stop loss, when you are in the red with your buy (buy - fee), but once you hit positive result the system will utilize a new stop loss, which can have a different value.
+You could also have a default stop loss when you are in the red with your buy (buy - fee), but once you hit a positive result (or an offset you define) the system will utilize a new stop loss, which can have a different value.
 For example, your default stop loss is -10%, but once you have more than 0% profit (example 0.1%) a different trailing stoploss will be used.

 !!! Note
@ -142,6 +142,8 @@ Both values require `trailing_stop` to be set to true and `trailing_stop_positiv
    stoploss = -0.10
    trailing_stop = True
    trailing_stop_positive = 0.02
+    trailing_stop_positive_offset = 0.0
+    trailing_only_offset_is_reached = False  # Default - not necessary for this example
 ```

 For example, simplified math:
@ -156,11 +158,31 @@ For example, simplified math:
 The 0.02 would translate to a -2% stop loss.
 Before this, `stoploss` is used for the trailing stoploss.

+!!! Tip "Use an offset to change your stoploss"
+    Use `trailing_stop_positive_offset` to ensure that your new trailing stoploss will be in profit by setting `trailing_stop_positive_offset` higher than `trailing_stop_positive`. Your first new stoploss value will then already have locked in profits.
+
+    Example with simplified math:
+
+    ``` python
+        stoploss = -0.10
+        trailing_stop = True
+        trailing_stop_positive = 0.02
+        trailing_stop_positive_offset = 0.03
+    ```
+
+    * the bot buys an asset at a price of 100$
+    * the stop loss is defined at -10%, so the stop loss would get triggered once the asset drops below 90$
+    * assuming the asset now increases to 102$
+    * the stoploss will now be at 91.8$ - 10% below the highest observed rate
+    * assuming the asset now increases to 103.5$ (above the offset configured)
+    * the stop loss will now be -2% of 103$ = 101.42$
+    * now the asset drops in value to 102\$, the stop loss will still be 101.42$ and would trigger once price breaks below 101.42$
+
 ### Trailing stop loss only once the trade has reached a certain offset

-It is also possible to use a static stoploss until the offset is reached, and then trail the trade to take profits once the market turns.
+You can also keep a static stoploss until the offset is reached, and then trail the trade to take profits once the market turns.

-If `"trailing_only_offset_is_reached": true` then the trailing stoploss is only activated once the offset is reached. Until then, the stoploss remains at the configured `stoploss`.
+If `trailing_only_offset_is_reached = True` then the trailing stoploss is only activated once the offset is reached. Until then, the stoploss remains at the configured `stoploss`.
 This option can be used with or without `trailing_stop_positive`, but uses `trailing_stop_positive_offset` as offset.

 ``` python
@ -203,7 +225,6 @@ If price moves 1% - you've lost 10$ of your own capital - therfore stoploss will

 Make sure to be aware of this, and avoid using too tight stoploss (at 10x leverage, 10% risk may be too little to allow the trade to "breath" a little).

-
 ## Changing stoploss on open trades

 A stoploss on an open trade can be changed by changing the value in the configuration or strategy and use the `/reload_config` command (alternatively, completely stopping and restarting the bot also works).
--- a/docs/strategy-callbacks.md
+++ b/docs/strategy-callbacks.md
@ -82,8 +82,9 @@ Called before entering a trade, makes it possible to manage your position size w
 ```python
 class AwesomeStrategy(IStrategy):
    def custom_stake_amount(self, pair: str, current_time: datetime, current_rate: float,
-                            proposed_stake: float, min_stake: float, max_stake: float,
-                            entry_tag: Optional[str], side: str, **kwargs) -> float:
+                            proposed_stake: float, min_stake: Optional[float], max_stake: float,
+                            leverage: float, entry_tag: Optional[str], side: str,
+                            **kwargs) -> float:

        dataframe, _ = self.dp.get_analyzed_dataframe(pair=pair, timeframe=self.timeframe)
        current_candle = dataframe.iloc[-1].squeeze()
@ -673,9 +674,10 @@ class DigDeeperStrategy(IStrategy):
    max_dca_multiplier = 5.5

    # This is called when placing the initial order (opening trade)
-    def custom_stake_amount(self, pair: str, current_time: datetime, current_rate: float,
+def custom_stake_amount(self, pair: str, current_time: datetime, current_rate: float,
                            proposed_stake: float, min_stake: Optional[float], max_stake: float,
-                            entry_tag: Optional[str], side: str, **kwargs) -> float:
+                            leverage: float, entry_tag: Optional[str], side: str,
+                            **kwargs) -> float:

        # We need to leave most of the funds for possible further DCA orders
        # This also applies to fixed stakes
--- a/freqtrade/commands/hyperopt_commands.py
+++ b/freqtrade/commands/hyperopt_commands.py
@ -24,7 +24,7 @@ def start_hyperopt_list(args: Dict[str, Any]) -> None:

    print_colorized = config.get('print_colorized', False)
    print_json = config.get('print_json', False)
-    export_csv = config.get('export_csv', None)
+    export_csv = config.get('export_csv')
    no_details = config.get('hyperopt_list_no_details', False)
    no_header = False

--- a/freqtrade/configuration/configuration.py
+++ b/freqtrade/configuration/configuration.py
@ -129,7 +129,7 @@ class Configuration:
                # Default to in-memory db for dry_run if not specified
                config['db_url'] = constants.DEFAULT_DB_DRYRUN_URL
        else:
-            if not config.get('db_url', None):
+            if not config.get('db_url'):
                config['db_url'] = constants.DEFAULT_DB_PROD_URL
            logger.info('Dry run is disabled')

@ -182,7 +182,7 @@ class Configuration:
        config['user_data_dir'] = create_userdata_dir(config['user_data_dir'], create_dir=False)
        logger.info('Using user-data directory: %s ...', config['user_data_dir'])

-        config.update({'datadir': create_datadir(config, self.args.get('datadir', None))})
+        config.update({'datadir': create_datadir(config, self.args.get('datadir'))})
        logger.info('Using data directory: %s ...', config.get('datadir'))

        if self.args.get('exportfilename'):
@ -221,7 +221,7 @@ class Configuration:
        if config.get('max_open_trades') == -1:
            config['max_open_trades'] = float('inf')

-        if self.args.get('stake_amount', None):
+        if self.args.get('stake_amount'):
            # Convert explicitly to float to support CLI argument for both unlimited and value
            try:
                self.args['stake_amount'] = float(self.args['stake_amount'])
@ -474,7 +474,7 @@ class Configuration:
                        configuration instead of the content)
        """
        if (argname in self.args and self.args[argname] is not None
-           and self.args[argname] is not False):
+                and self.args[argname] is not False):

            config.update({argname: self.args[argname]})
            if logfun:
--- a/freqtrade/exchange/binance_leverage_tiers.json
+++ b/freqtrade/exchange/binance_leverage_tiers.json
--- a/freqtrade/exchange/common.py
+++ b/freqtrade/exchange/common.py
@ -46,6 +46,7 @@ MAP_EXCHANGE_CHILDCLASS = {
    'binanceje': 'binance',
    'binanceusdm': 'binance',
    'okex': 'okx',
+    'gate': 'gateio',
 }

 SUPPORTED_EXCHANGES = [
@ -63,17 +64,16 @@ EXCHANGE_HAS_REQUIRED = [
    'fetchOrder',
    'cancelOrder',
    'createOrder',
-    # 'createLimitOrder', 'createMarketOrder',
    'fetchBalance',

    # Public endpoints
-    'loadMarkets',
    'fetchOHLCV',
 ]

 EXCHANGE_HAS_OPTIONAL = [
    # Private
    'fetchMyTrades',  # Trades for order - fee detection
+    # 'createLimitOrder', 'createMarketOrder', # Either OR for orders
    # 'setLeverage',  # Margin/Futures trading
    # 'setMarginMode',  # Margin/Futures trading
    # 'fetchFundingHistory', # Futures trading
--- a/freqtrade/exchange/exchange.py
+++ b/freqtrade/exchange/exchange.py
@ -77,6 +77,7 @@ class Exchange:
        "mark_ohlcv_price": "mark",
        "mark_ohlcv_timeframe": "8h",
        "ccxt_futures_name": "swap",
+        "fee_cost_in_contracts": False,  # Fee cost needs contract conversion
        "needs_trading_fees": False,  # use fetch_trading_fees to cache fees
    }
    _ft_has: Dict = {}
@ -387,7 +388,7 @@ class Exchange:
            and market.get('base', None) is not None
            and (self.precisionMode != TICK_SIZE
                 # Too low precision will falsify calculations
-                 or market.get('precision', {}).get('price', None) > 1e-11)
+                 or market.get('precision', {}).get('price') > 1e-11)
            and ((self.trading_mode == TradingMode.SPOT and self.market_is_spot(market))
                 or (self.trading_mode == TradingMode.MARGIN and self.market_is_margin(market))
                 or (self.trading_mode == TradingMode.FUTURES and self.market_is_future(market)))
@ -537,7 +538,7 @@ class Exchange:
                # The internal info array is different for each particular market,
                # its contents depend on the exchange.
                # It can also be a string or similar ... so we need to verify that first.
-            elif (isinstance(self.markets[pair].get('info', None), dict)
+            elif (isinstance(self.markets[pair].get('info'), dict)
                  and self.markets[pair].get('info', {}).get('prohibitedIn', False)):
                # Warn users about restricted pairs in whitelist.
                # We cannot determine reliably if Users are affected.
@ -585,10 +586,13 @@ class Exchange:
        """
        Checks if order-types configured in strategy/config are supported
        """
-        if any(v == 'market' for k, v in order_types.items()):
-            if not self.exchange_has('createMarketOrder'):
-                raise OperationalException(
-                    f'Exchange {self.name} does not support market orders.')
+        # TODO: Reenable once ccxt fixes createMarketOrder assignment - as well as
+        # Revert the change in test_validate_ordertypes.
+
+        # if any(v == 'market' for k, v in order_types.items()):
+        #     if not self.exchange_has('createMarketOrder'):
+        #         raise OperationalException(
+        #             f'Exchange {self.name} does not support market orders.')

        if (order_types.get("stoploss_on_exchange")
                and not self._ft_has.get("stoploss_on_exchange", False)):
@ -1631,27 +1635,35 @@ class Exchange:
                and order['fee']['cost'] is not None
                )

-    def calculate_fee_rate(self, order: Dict) -> Optional[float]:
+    def calculate_fee_rate(
+            self, fee: Dict, symbol: str, cost: float, amount: float) -> Optional[float]:
        """
        Calculate fee rate if it's not given by the exchange.
-        :param order: Order or trade (one trade) dict
+        :param fee: ccxt Fee dict - must contain cost / currency / rate
+        :param symbol: Symbol of the order
+        :param cost: Total cost of the order
+        :param amount: Amount of the order
        """
-        if order['fee'].get('rate') is not None:
-            return order['fee'].get('rate')
-        fee_curr = order['fee']['currency']
+        if fee.get('rate') is not None:
+            return fee.get('rate')
+        fee_curr = fee.get('currency')
+        if fee_curr is None:
+            return None
+        fee_cost = fee['cost']
+        if self._ft_has['fee_cost_in_contracts']:
+            # Convert cost via "contracts" conversion
+            fee_cost = self._contracts_to_amount(symbol, fee['cost'])
+
        # Calculate fee based on order details
-        if fee_curr in self.get_pair_base_currency(order['symbol']):
+        if fee_curr == self.get_pair_base_currency(symbol):
            # Base currency - divide by amount
-            return round(
-                order['fee']['cost'] / safe_value_fallback2(order, order, 'filled', 'amount'), 8)
-        elif fee_curr in self.get_pair_quote_currency(order['symbol']):
+            return round(fee['cost'] / amount, 8)
+        elif fee_curr == self.get_pair_quote_currency(symbol):
            # Quote currency - divide by cost
-            return round(self._contracts_to_amount(
-                order['symbol'], order['fee']['cost']) / order['cost'],
-                8) if order['cost'] else None
+            return round(fee_cost / cost, 8) if cost else None
        else:
            # If Fee currency is a different currency
-            if not order['cost']:
+            if not cost:
                # If cost is None or 0.0 -> falsy, return None
                return None
            try:
@ -1663,19 +1675,28 @@ class Exchange:
                fee_to_quote_rate = self._config['exchange'].get('unknown_fee_rate', None)
                if not fee_to_quote_rate:
                    return None
-            return round((self._contracts_to_amount(
-                order['symbol'], order['fee']['cost']) * fee_to_quote_rate) / order['cost'], 8)
+            return round((fee_cost * fee_to_quote_rate) / cost, 8)

-    def extract_cost_curr_rate(self, order: Dict) -> Tuple[float, str, Optional[float]]:
+    def extract_cost_curr_rate(self, fee: Dict, symbol: str, cost: float,
+                               amount: float) -> Tuple[float, str, Optional[float]]:
        """
        Extract tuple of cost, currency, rate.
        Requires order_has_fee to run first!
-        :param order: Order or trade (one trade) dict
+        :param fee: ccxt Fee dict - must contain cost / currency / rate
+        :param symbol: Symbol of the order
+        :param cost: Total cost of the order
+        :param amount: Amount of the order
        :return: Tuple with cost, currency, rate of the given fee dict
        """
-        return (order['fee']['cost'],
-                order['fee']['currency'],
-                self.calculate_fee_rate(order))
+        return (fee['cost'],
+                fee['currency'],
+                self.calculate_fee_rate(
+                    fee,
+                    symbol,
+                    cost,
+                    amount
+                    )
+                )

    # Historic data

--- a/freqtrade/exchange/gateio.py
+++ b/freqtrade/exchange/gateio.py
@ -32,7 +32,8 @@ class Gateio(Exchange):
    }

    _ft_has_futures: Dict = {
-        "needs_trading_fees": True
+        "needs_trading_fees": True,
+        "fee_cost_in_contracts": False,  # Set explicitly to false for clarity
    }

    _supported_trading_mode_margin_pairs: List[Tuple[TradingMode, MarginMode]] = [
--- a/freqtrade/exchange/okx.py
+++ b/freqtrade/exchange/okx.py
@ -28,6 +28,7 @@ class Okx(Exchange):
    }
    _ft_has_futures: Dict = {
        "tickers_have_quoteVolume": False,
+        "fee_cost_in_contracts": True,
    }

    _supported_trading_mode_margin_pairs: List[Tuple[TradingMode, MarginMode]] = [
--- a/freqtrade/freqtradebot.py
+++ b/freqtrade/freqtradebot.py
@ -67,7 +67,7 @@ class FreqtradeBot(LoggingMixin):

        self.exchange = ExchangeResolver.load_exchange(self.config['exchange']['name'], self.config)

-        init_db(self.config.get('db_url', None))
+        init_db(self.config['db_url'])

        self.wallets = Wallets(self.config, self.exchange)

@ -634,7 +634,7 @@ class FreqtradeBot(LoggingMixin):
                pair=pair, order_type=order_type, amount=amount, rate=enter_limit_requested,
                time_in_force=time_in_force, current_time=datetime.now(timezone.utc),
                entry_tag=enter_tag, side=trade_side):
-            logger.info(f"User requested abortion of buying {pair}")
+            logger.info(f"User denied entry for {pair}.")
            return False
        order = self.exchange.create_order(
            pair=pair,
@ -648,7 +648,7 @@ class FreqtradeBot(LoggingMixin):
        )
        order_obj = Order.parse_from_ccxt_object(order, pair, side)
        order_id = order['id']
-        order_status = order.get('status', None)
+        order_status = order.get('status')
        logger.info(f"Order #{order_id} was created for {pair} and status is {order_status}.")

        # we assume the order is executed at the price requested
@ -814,7 +814,7 @@ class FreqtradeBot(LoggingMixin):
                pair=pair, current_time=datetime.now(timezone.utc),
                current_rate=enter_limit_requested, proposed_stake=stake_amount,
                min_stake=min_stake_amount, max_stake=min(max_stake_amount, stake_available),
-                entry_tag=entry_tag, side=trade_side
+                leverage=leverage, entry_tag=entry_tag, side=trade_side
            )

        stake_amount = self.wallets.validate_stake_amount(
@ -969,6 +969,29 @@ class FreqtradeBot(LoggingMixin):
        logger.debug(f'Found no {exit_signal_type} signal for %s.', trade)
        return False

+    def _check_and_execute_exit(self, trade: Trade, exit_rate: float,
+                                enter: bool, exit_: bool, exit_tag: Optional[str]) -> bool:
+        """
+        Check and execute trade exit
+        """
+        exits: List[ExitCheckTuple] = self.strategy.should_exit(
+            trade,
+            exit_rate,
+            datetime.now(timezone.utc),
+            enter=enter,
+            exit_=exit_,
+            force_stoploss=self.edge.stoploss(trade.pair) if self.edge else 0
+        )
+        for should_exit in exits:
+            if should_exit.exit_flag:
+                exit_tag1 = exit_tag if should_exit.exit_type == ExitType.EXIT_SIGNAL else None
+                logger.info(f'Exit for {trade.pair} detected. Reason: {should_exit.exit_type}'
+                            f'{f" Tag: {exit_tag1}" if exit_tag1 is not None else ""}')
+                exited = self.execute_trade_exit(trade, exit_rate, should_exit, exit_tag=exit_tag1)
+                if exited:
+                    return True
+        return False
+
    def create_stoploss_order(self, trade: Trade, stop_price: float) -> bool:
        """
        Abstracts creating stoploss orders from the logic.
@ -1120,28 +1143,6 @@ class FreqtradeBot(LoggingMixin):
                    logger.warning(f"Could not create trailing stoploss order "
                                   f"for pair {trade.pair}.")

-    def _check_and_execute_exit(self, trade: Trade, exit_rate: float,
-                                enter: bool, exit_: bool, exit_tag: Optional[str]) -> bool:
-        """
-        Check and execute trade exit
-        """
-        exits: List[ExitCheckTuple] = self.strategy.should_exit(
-            trade,
-            exit_rate,
-            datetime.now(timezone.utc),
-            enter=enter,
-            exit_=exit_,
-            force_stoploss=self.edge.stoploss(trade.pair) if self.edge else 0
-        )
-        for should_exit in exits:
-            if should_exit.exit_flag:
-                logger.info(f'Exit for {trade.pair} detected. Reason: {should_exit.exit_type}'
-                            f'{f" Tag: {exit_tag}" if exit_tag is not None else ""}')
-                exited = self.execute_trade_exit(trade, exit_rate, should_exit, exit_tag=exit_tag)
-                if exited:
-                    return True
-        return False
-
    def manage_open_orders(self) -> None:
        """
        Management of open orders on exchange. Unfilled orders might be cancelled if timeout
@ -1474,7 +1475,7 @@ class FreqtradeBot(LoggingMixin):
                time_in_force=time_in_force, exit_reason=exit_reason,
                sell_reason=exit_reason,  # sellreason -> compatibility
                current_time=datetime.now(timezone.utc)):
-            logger.info(f"User requested abortion of {trade.pair} exit.")
+            logger.info(f"User denied exit for {trade.pair}.")
            return False

        try:
@ -1551,7 +1552,7 @@ class FreqtradeBot(LoggingMixin):
            'open_date': trade.open_date,
            'close_date': trade.close_date or datetime.utcnow(),
            'stake_currency': self.config['stake_currency'],
-            'fiat_currency': self.config.get('fiat_display_currency', None),
+            'fiat_currency': self.config.get('fiat_display_currency'),
        }

        if 'fiat_display_currency' in self.config:
@ -1672,7 +1673,7 @@ class FreqtradeBot(LoggingMixin):

        if order['status'] in constants.NON_OPEN_EXCHANGE_STATES:
            # If a entry order was closed, force update on stoploss on exchange
-            if order.get('side', None) == trade.entry_side:
+            if order.get('side') == trade.entry_side:
                trade = self.cancel_stoploss_on_exchange(trade)
                # TODO: Margin will need to use interest_rate as well.
                # interest_rate = self.exchange.get_interest_rate()
@ -1761,7 +1762,8 @@ class FreqtradeBot(LoggingMixin):
        trade_base_currency = self.exchange.get_pair_base_currency(trade.pair)
        # use fee from order-dict if possible
        if self.exchange.order_has_fee(order):
-            fee_cost, fee_currency, fee_rate = self.exchange.extract_cost_curr_rate(order)
+            fee_cost, fee_currency, fee_rate = self.exchange.extract_cost_curr_rate(
+                order['fee'], order['symbol'], order['cost'], order_obj.safe_filled)
            logger.info(f"Fee for Trade {trade} [{order_obj.ft_order_side}]: "
                        f"{fee_cost:.8g} {fee_currency} - rate: {fee_rate}")
            if fee_rate is None or fee_rate < 0.02:
@ -1799,7 +1801,15 @@ class FreqtradeBot(LoggingMixin):
        for exectrade in trades:
            amount += exectrade['amount']
            if self.exchange.order_has_fee(exectrade):
-                fee_cost_, fee_currency, fee_rate_ = self.exchange.extract_cost_curr_rate(exectrade)
+                # Prefer singular fee
+                fees = [exectrade['fee']]
+            else:
+                fees = exectrade.get('fees', [])
+            for fee in fees:
+
+                fee_cost_, fee_currency, fee_rate_ = self.exchange.extract_cost_curr_rate(
+                    fee, exectrade['symbol'], exectrade['cost'], exectrade['amount']
+                )
                fee_cost += fee_cost_
                if fee_rate_ is not None:
                    fee_rate_array.append(fee_rate_)
--- a/freqtrade/optimize/backtesting.py
+++ b/freqtrade/optimize/backtesting.py
@ -87,7 +87,7 @@ class Backtesting:
        self.exchange = ExchangeResolver.load_exchange(self._exchange_name, self.config)
        self.dataprovider = DataProvider(self.config, self.exchange)

-        if self.config.get('strategy_list', None):
+        if self.config.get('strategy_list'):
            for strat in list(self.config['strategy_list']):
                stratconf = deepcopy(self.config)
                stratconf['strategy'] = strat
@ -189,6 +189,7 @@ class Backtesting:
        self.strategy.order_types['stoploss_on_exchange'] = False

        self.strategy.ft_bot_start()
+        strategy_safe_wrapper(self.strategy.bot_loop_start, supress_error=True)()

    def _load_protections(self, strategy: IStrategy):
        if self.config.get('enable_protections', False):
@ -721,7 +722,7 @@ class Backtesting:
                pair=pair, current_time=current_time, current_rate=propose_rate,
                proposed_stake=stake_amount, min_stake=min_stake_amount,
                max_stake=min(stake_available, max_stake_amount),
-                entry_tag=entry_tag, side=direction)
+                leverage=leverage, entry_tag=entry_tag, side=direction)

        stake_amount_val = self.wallets.validate_stake_amount(
            pair=pair,
@ -1140,8 +1141,6 @@ class Backtesting:
        backtest_start_time = datetime.now(timezone.utc)
        self._set_strategy(strat)

-        strategy_safe_wrapper(self.strategy.bot_loop_start, supress_error=True)()
-
        # Use max_open_trades in backtesting, except --disable-max-market-positions is set
        if self.config.get('use_max_market_positions', True):
            # Must come from strategy config, as the strategy may modify this setting.
--- a/freqtrade/optimize/hyperopt.py
+++ b/freqtrade/optimize/hyperopt.py
@ -455,7 +455,7 @@ class Hyperopt:
            return self.opt.ask(n_points=n_points), [False for _ in range(n_points)]

    def start(self) -> None:
-        self.random_state = self._set_random_state(self.config.get('hyperopt_random_state', None))
+        self.random_state = self._set_random_state(self.config.get('hyperopt_random_state'))
        logger.info(f"Using optimizer random state: {self.random_state}")
        self.hyperopt_table_header = -1
        # Initialize spaces ...
--- a/freqtrade/optimize/hyperopt_tools.py
+++ b/freqtrade/optimize/hyperopt_tools.py
@ -127,14 +127,14 @@ class HyperoptTools():
            'only_profitable': config.get('hyperopt_list_profitable', False),
            'filter_min_trades': config.get('hyperopt_list_min_trades', 0),
            'filter_max_trades': config.get('hyperopt_list_max_trades', 0),
-            'filter_min_avg_time': config.get('hyperopt_list_min_avg_time', None),
-            'filter_max_avg_time': config.get('hyperopt_list_max_avg_time', None),
-            'filter_min_avg_profit': config.get('hyperopt_list_min_avg_profit', None),
-            'filter_max_avg_profit': config.get('hyperopt_list_max_avg_profit', None),
-            'filter_min_total_profit': config.get('hyperopt_list_min_total_profit', None),
-            'filter_max_total_profit': config.get('hyperopt_list_max_total_profit', None),
-            'filter_min_objective': config.get('hyperopt_list_min_objective', None),
-            'filter_max_objective': config.get('hyperopt_list_max_objective', None),
+            'filter_min_avg_time': config.get('hyperopt_list_min_avg_time'),
+            'filter_max_avg_time': config.get('hyperopt_list_max_avg_time'),
+            'filter_min_avg_profit': config.get('hyperopt_list_min_avg_profit'),
+            'filter_max_avg_profit': config.get('hyperopt_list_max_avg_profit'),
+            'filter_min_total_profit': config.get('hyperopt_list_min_total_profit'),
+            'filter_max_total_profit': config.get('hyperopt_list_max_total_profit'),
+            'filter_min_objective': config.get('hyperopt_list_min_objective'),
+            'filter_max_objective': config.get('hyperopt_list_max_objective'),
        }
        if not HyperoptTools._test_hyperopt_results_exist(results_file):
            # No file found.
--- a/freqtrade/persistence/migrations.py
+++ b/freqtrade/persistence/migrations.py
@ -1,9 +1,10 @@
 import logging
 from typing import List

-from sqlalchemy import inspect, text
+from sqlalchemy import inspect, select, text, tuple_, update

 from freqtrade.exceptions import OperationalException
+from freqtrade.persistence.trade_model import Order, Trade


 logger = logging.getLogger(__name__)
@ -251,31 +252,31 @@ def set_sqlite_to_wal(engine):

 def fix_old_dry_orders(engine):
    with engine.begin() as connection:
-        connection.execute(
-            text(
-                """
-                update orders
-                set ft_is_open = 0
-                where ft_is_open = 1 and (ft_trade_id, order_id) not in (
-                    select id, stoploss_order_id from trades where stoploss_order_id is not null
-                ) and ft_order_side = 'stoploss'
-                and order_id like 'dry_%'
-                """
-            )
-        )
-        connection.execute(
-            text(
-                """
-                update orders
-                set ft_is_open = 0
-                where ft_is_open = 1
-                and (ft_trade_id, order_id) not in (
-                    select id, open_order_id from trades where open_order_id is not null
-                ) and ft_order_side != 'stoploss'
-                and order_id like 'dry_%'
-                """
-            )
-        )
+        stmt = update(Order).where(
+            Order.ft_is_open.is_(True),
+            tuple_(Order.ft_trade_id, Order.order_id).not_in(
+                select(
+                    Trade.id, Trade.stoploss_order_id
+                ).where(Trade.stoploss_order_id.is_not(None))
+                  ),
+            Order.ft_order_side == 'stoploss',
+            Order.order_id.like('dry%'),
+
+        ).values(ft_is_open=False)
+        connection.execute(stmt)
+
+        stmt = update(Order).where(
+            Order.ft_is_open.is_(True),
+            tuple_(Order.ft_trade_id, Order.order_id).not_in(
+                select(
+                    Trade.id, Trade.open_order_id
+                ).where(Trade.open_order_id.is_not(None))
+                  ),
+            Order.ft_order_side != 'stoploss',
+            Order.order_id.like('dry%')
+
+        ).values(ft_is_open=False)
+        connection.execute(stmt)


 def check_migrate(engine, decl_base, previous_tables) -> None:
--- a/freqtrade/persistence/trade_model.py
+++ b/freqtrade/persistence/trade_model.py
@ -821,7 +821,7 @@ class LocalTrade():
            self.open_rate = total_stake / total_amount
            self.stake_amount = total_stake / (self.leverage or 1.0)
            self.amount = total_amount
-            self.fee_open_cost = self.fee_open * self.stake_amount
+            self.fee_open_cost = self.fee_open * total_stake
            self.recalc_open_trade_value()
            if self.stop_loss_pct is not None and self.open_rate is not None:
                self.adjust_stop_loss(self.open_rate, self.stop_loss_pct)
--- a/freqtrade/plugins/pairlist/AgeFilter.py
+++ b/freqtrade/plugins/pairlist/AgeFilter.py
@ -30,7 +30,7 @@ class AgeFilter(IPairList):
        self._symbolsCheckFailed = PeriodicCache(maxsize=1000, ttl=86_400)

        self._min_days_listed = pairlistconfig.get('min_days_listed', 10)
-        self._max_days_listed = pairlistconfig.get('max_days_listed', None)
+        self._max_days_listed = pairlistconfig.get('max_days_listed')

        candle_limit = exchange.ohlcv_candle_limit('1d', self._config['candle_type_def'])
        if self._min_days_listed < 1:
--- a/freqtrade/plugins/pairlist/PerformanceFilter.py
+++ b/freqtrade/plugins/pairlist/PerformanceFilter.py
@ -21,7 +21,7 @@ class PerformanceFilter(IPairList):
        super().__init__(exchange, pairlistmanager, config, pairlistconfig, pairlist_pos)

        self._minutes = pairlistconfig.get('minutes', 0)
-        self._min_profit = pairlistconfig.get('min_profit', None)
+        self._min_profit = pairlistconfig.get('min_profit')

    @property
    def needstickers(self) -> bool:
--- a/freqtrade/plugins/pairlist/rangestabilityfilter.py
+++ b/freqtrade/plugins/pairlist/rangestabilityfilter.py
@ -27,7 +27,7 @@ class RangeStabilityFilter(IPairList):

        self._days = pairlistconfig.get('lookback_days', 10)
        self._min_rate_of_change = pairlistconfig.get('min_rate_of_change', 0.01)
-        self._max_rate_of_change = pairlistconfig.get('max_rate_of_change', None)
+        self._max_rate_of_change = pairlistconfig.get('max_rate_of_change')
        self._refresh_period = pairlistconfig.get('refresh_period', 1440)
        self._def_candletype = self._config['candle_type_def']

--- a/freqtrade/plugins/pairlistmanager.py
+++ b/freqtrade/plugins/pairlistmanager.py
@ -28,7 +28,7 @@ class PairListManager(LoggingMixin):
        self._blacklist = self._config['exchange'].get('pair_blacklist', [])
        self._pairlist_handlers: List[IPairList] = []
        self._tickers_needed = False
-        for pairlist_handler_config in self._config.get('pairlists', None):
+        for pairlist_handler_config in self._config.get('pairlists', []):
            pairlist_handler = PairListResolver.load_pairlist(
                pairlist_handler_config['method'],
                exchange=exchange,
--- a/freqtrade/rpc/api_server/api_v1.py
+++ b/freqtrade/rpc/api_server/api_v1.py
@ -282,7 +282,7 @@ def get_strategy(strategy: str, config=Depends(get_config)):
 def list_available_pairs(timeframe: Optional[str] = None, stake_currency: Optional[str] = None,
                         candletype: Optional[CandleType] = None, config=Depends(get_config)):

-    dh = get_datahandler(config['datadir'], config.get('dataformat_ohlcv', None))
+    dh = get_datahandler(config['datadir'], config.get('dataformat_ohlcv'))
    trading_mode: TradingMode = config.get('trading_mode', TradingMode.SPOT)
    pair_interval = dh.ohlcv_get_available_data(config['datadir'], trading_mode)

--- a/freqtrade/rpc/rpc.py
+++ b/freqtrade/rpc/rpc.py
@ -97,7 +97,7 @@ class RPC:
        """
        self._freqtrade = freqtrade
        self._config: Dict[str, Any] = freqtrade.config
-        if self._config.get('fiat_display_currency', None):
+        if self._config.get('fiat_display_currency'):
            self._fiat_converter = CryptoToFiatConverter()

    @staticmethod
@ -566,7 +566,7 @@ class RPC:
            else:
                try:
                    pair = self._freqtrade.exchange.get_valid_pair_combination(coin, stake_currency)
-                    rate = tickers.get(pair, {}).get('last', None)
+                    rate = tickers.get(pair, {}).get('last')
                    if rate:
                        if pair.startswith(stake_currency) and not pair.endswith(stake_currency):
                            rate = 1.0 / rate
--- a/freqtrade/rpc/telegram.py
+++ b/freqtrade/rpc/telegram.py
@ -261,7 +261,7 @@ class Telegram(RPCHandler):
            )
        if msg.get('analyzed_candle'):
            message += f"*Analyzed Candle:* `{msg['analyzed_candle']}`\n"
-        message += f"*Enter Tag:* `{msg['enter_tag']}`\n" if msg.get('enter_tag', None) else ""
+        message += f"*Enter Tag:* `{msg['enter_tag']}`\n" if msg.get('enter_tag') else ""
        message += f"*Amount:* `{msg['amount']:.8f}`\n"
        if msg.get('leverage') and msg.get('leverage', 1.0) != 1.0:
            message += f"*Leverage:* `{msg['leverage']}`\n"
@ -274,7 +274,7 @@ class Telegram(RPCHandler):

        message += f"*Total:* `({round_coin_value(msg['stake_amount'], msg['stake_currency'])}"

-        if msg.get('fiat_currency', None):
+        if msg.get('fiat_currency'):
            message += f", {round_coin_value(msg['stake_amount_fiat'], msg['fiat_currency'])}"

        message += ")`"
@ -290,7 +290,7 @@ class Telegram(RPCHandler):
        msg['enter_tag'] = msg['enter_tag'] if "enter_tag" in msg.keys() else None
        msg['emoji'] = self._get_sell_emoji(msg)
        msg['leverage_text'] = (f"*Leverage:* `{msg['leverage']:.1f}`\n"
-                                if msg.get('leverage', None) and msg.get('leverage', 1.0) != 1.0
+                                if msg.get('leverage') and msg.get('leverage', 1.0) != 1.0
                                else "")

        # Check if all sell properties are available.
--- a/freqtrade/rpc/webhook.py
+++ b/freqtrade/rpc/webhook.py
@ -45,21 +45,21 @@ class Webhook(RPCHandler):
        try:
            whconfig = self._config['webhook']
            if msg['type'] in [RPCMessageType.ENTRY]:
-                valuedict = whconfig.get('webhookentry', None)
+                valuedict = whconfig.get('webhookentry')
            elif msg['type'] in [RPCMessageType.ENTRY_CANCEL]:
-                valuedict = whconfig.get('webhookentrycancel', None)
+                valuedict = whconfig.get('webhookentrycancel')
            elif msg['type'] in [RPCMessageType.ENTRY_FILL]:
-                valuedict = whconfig.get('webhookentryfill', None)
+                valuedict = whconfig.get('webhookentryfill')
            elif msg['type'] == RPCMessageType.EXIT:
-                valuedict = whconfig.get('webhookexit', None)
+                valuedict = whconfig.get('webhookexit')
            elif msg['type'] == RPCMessageType.EXIT_FILL:
-                valuedict = whconfig.get('webhookexitfill', None)
+                valuedict = whconfig.get('webhookexitfill')
            elif msg['type'] == RPCMessageType.EXIT_CANCEL:
-                valuedict = whconfig.get('webhookexitcancel', None)
+                valuedict = whconfig.get('webhookexitcancel')
            elif msg['type'] in (RPCMessageType.STATUS,
                                 RPCMessageType.STARTUP,
                                 RPCMessageType.WARNING):
-                valuedict = whconfig.get('webhookstatus', None)
+                valuedict = whconfig.get('webhookstatus')
            else:
                raise NotImplementedError('Unknown message type: {}'.format(msg['type']))
            if not valuedict:
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@ -191,6 +191,7 @@ def detect_parameters(
                        and attr.category is not None and attr.category != category):
                    raise OperationalException(
                        f'Inconclusive parameter name {attr_name}, category: {attr.category}.')
+
                if (category == attr.category or
                        (attr_name.startswith(category + '_') and attr.category is None)):
                    yield attr_name, attr
--- a/freqtrade/strategy/interface.py
+++ b/freqtrade/strategy/interface.py
@ -442,7 +442,8 @@ class IStrategy(ABC, HyperStrategyMixin):

    def custom_stake_amount(self, pair: str, current_time: datetime, current_rate: float,
                            proposed_stake: float, min_stake: Optional[float], max_stake: float,
-                            entry_tag: Optional[str], side: str, **kwargs) -> float:
+                            leverage: float, entry_tag: Optional[str], side: str,
+                            **kwargs) -> float:
        """
        Customize stake size for each new trade.

@ -452,6 +453,7 @@ class IStrategy(ABC, HyperStrategyMixin):
        :param proposed_stake: A stake amount proposed by the bot.
        :param min_stake: Minimal stake size allowed by exchange.
        :param max_stake: Balance available for trading.
+        :param leverage: Leverage selected for this trade.
        :param entry_tag: Optional entry_tag (buy_tag) if provided with the buy signal.
        :param side: 'long' or 'short' - indicating the direction of the proposed trade
        :return: A stake size, which is between min_stake and max_stake.
--- a/freqtrade/templates/subtemplates/strategy_methods_advanced.j2
+++ b/freqtrade/templates/subtemplates/strategy_methods_advanced.j2
@ -79,9 +79,10 @@ def custom_exit_price(self, pair: str, trade: 'Trade',
    """
    return proposed_rate

-def custom_stake_amount(self, pair: str, current_time: 'datetime', current_rate: float,
+def custom_stake_amount(self, pair: str, current_time: datetime, current_rate: float,
                        proposed_stake: float, min_stake: Optional[float], max_stake: float,
-                        entry_tag: 'Optional[str]', side: str, **kwargs) -> float:
+                        leverage: float, entry_tag: Optional[str], side: str,
+                        **kwargs) -> float:
    """
    Customize stake size for each new trade.

@ -91,6 +92,7 @@ def custom_stake_amount(self, pair: str, current_time: 'datetime', current_rate:
    :param proposed_stake: A stake amount proposed by the bot.
    :param min_stake: Minimal stake size allowed by exchange.
    :param max_stake: Balance available for trading.
+    :param leverage: Leverage selected for this trade.
    :param entry_tag: Optional entry_tag (buy_tag) if provided with the buy signal.
    :param side: 'long' or 'short' - indicating the direction of the proposed trade
    :return: A stake size, which is between min_stake and max_stake.
--- a/freqtrade/wallets.py
+++ b/freqtrade/wallets.py
@ -131,9 +131,9 @@ class Wallets:
            if isinstance(balances[currency], dict):
                self._wallets[currency] = Wallet(
                    currency,
-                    balances[currency].get('free', None),
-                    balances[currency].get('used', None),
-                    balances[currency].get('total', None)
+                    balances[currency].get('free'),
+                    balances[currency].get('used'),
+                    balances[currency].get('total')
                )
        # Remove currencies no longer in get_balances output
        for currency in deepcopy(self._wallets):
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@ -8,22 +8,22 @@ coveralls==3.3.1
 flake8==4.0.1
 flake8-tidy-imports==4.8.0
 mypy==0.961
-pre-commit==2.19.0
+pre-commit==2.20.0
 pytest==7.1.2
 pytest-asyncio==0.18.3
 pytest-cov==3.0.0
-pytest-mock==3.7.0
+pytest-mock==3.8.2
 pytest-random-order==1.0.4
 isort==5.10.1
 # For datetime mocking
-time-machine==2.7.0
+time-machine==2.7.1

 # Convert jupyter notebooks to markdown documents
 nbconvert==6.5.0

 # mypy types
-types-cachetools==5.0.2
+types-cachetools==5.2.1
 types-filelock==3.2.7
-types-requests==2.27.30
-types-tabulate==0.8.9
-types-python-dateutil==2.8.17
+types-requests==2.28.0
+types-tabulate==0.8.11
+types-python-dateutil==2.8.18
--- a/requirements-plot.txt
+++ b/requirements-plot.txt
@ -1,4 +1,4 @@
 # Include all requirements to run the bot.
 -r requirements.txt

-plotly==5.8.2
+plotly==5.9.0
--- a/requirements.txt
+++ b/requirements.txt
@ -1,21 +1,21 @@
-numpy==1.22.4
-pandas==1.4.2
+numpy==1.23.1
+pandas==1.4.3
 pandas-ta==0.3.14b

-ccxt==1.88.15
+ccxt==1.90.41
 # Pin cryptography for now due to rust build errors with piwheels
-cryptography==37.0.2
+cryptography==37.0.4
 aiohttp==3.8.1
-SQLAlchemy==1.4.37
-python-telegram-bot==13.12
+SQLAlchemy==1.4.39
+python-telegram-bot==13.13
 arrow==1.2.2
 cachetools==4.2.2
-requests==2.28.0
-urllib3==1.26.9
-jsonschema==4.6.0
+requests==2.28.1
+urllib3==1.26.10
+jsonschema==4.6.2
 TA-Lib==0.4.24
 technical==1.3.0
-tabulate==0.8.9
+tabulate==0.8.10
 pycoingecko==2.2.0
 jinja2==3.1.2
 tables==3.7.0
@ -26,16 +26,16 @@ joblib==1.1.0
 py_find_1st==1.1.5

 # Load ticker files 30% faster
-python-rapidjson==1.6
+python-rapidjson==1.8
 # Properly format api responses
-orjson==3.7.2
+orjson==3.7.7

 # Notify systemd
 sdnotify==0.3.2

 # API Server
 fastapi==0.78.0
-uvicorn==0.17.6
+uvicorn==0.18.2
 pyjwt==2.4.0
 aiofiles==0.8.0
 psutil==5.9.1
@ -44,7 +44,7 @@ psutil==5.9.1
 colorama==0.4.5
 # Building config files interactively
 questionary==1.10.0
-prompt-toolkit==3.0.29
+prompt-toolkit==3.0.30
 # Extensions to datetime library
 python-dateutil==2.8.2

--- a/tests/conftest.py
+++ b/tests/conftest.py
@ -1694,6 +1694,7 @@ def limit_buy_order_old_partial():
        'price': 0.00001099,
        'amount': 90.99181073,
        'filled': 23.0,
+        'cost': 90.99181073 * 23.0,
        'remaining': 67.99181073,
        'status': 'open'
    }
@ -3165,60 +3166,46 @@ def leverage_tiers():
        "AAVE/USDT": [
            {
                'min': 0,
-                'max': 50000,
+                'max': 5000,
                'mmr': 0.01,
                'lev': 50,
                'maintAmt': 0.0
            },
            {
-                'min': 50000,
-                'max': 250000,
+                'min': 5000,
+                'max': 25000,
                'mmr': 0.02,
                'lev': 25,
-                'maintAmt': 500.0
+                'maintAmt': 75.0
+            },
+            {
+                'min': 25000,
+                'max': 100000,
+                'mmr': 0.05,
+                'lev': 10,
+                'maintAmt': 700.0
+            },
+            {
+                'min': 100000,
+                'max': 250000,
+                'mmr': 0.1,
+                'lev': 5,
+                'maintAmt': 5700.0
            },
            {
                'min': 250000,
                'max': 1000000,
-                'mmr': 0.05,
-                'lev': 10,
-                'maintAmt': 8000.0
-            },
-            {
-                'min': 1000000,
-                'max': 2000000,
-                'mmr': 0.1,
-                'lev': 5,
-                'maintAmt': 58000.0
-            },
-            {
-                'min': 2000000,
-                'max': 5000000,
                'mmr': 0.125,
-                'lev': 4,
-                'maintAmt': 108000.0
-            },
-            {
-                'min': 5000000,
-                'max': 10000000,
-                'mmr': 0.1665,
-                'lev': 3,
-                'maintAmt': 315500.0
+                'lev': 2,
+                'maintAmt': 11950.0
            },
            {
                'min': 10000000,
-                'max': 20000000,
-                'mmr': 0.25,
-                'lev': 2,
-                'maintAmt': 1150500.0
+                'max': 50000000,
+                'mmr': 0.5,
+                'lev': 1,
+                'maintAmt': 386950.0
            },
-            {
-                "min": 20000000,
-                "max": 50000000,
-                "mmr": 0.5,
-                "lev": 1,
-                "maintAmt": 6150500.0
-            }
        ],
        "ADA/BUSD": [
            {
--- a/tests/exchange/test_exchange.py
+++ b/tests/exchange/test_exchange.py
@ -1027,9 +1027,10 @@ def test_validate_ordertypes(default_conf, mocker):
        'stoploss': 'market',
        'stoploss_on_exchange': False
    }
-    with pytest.raises(OperationalException,
-                       match=r'Exchange .* does not support market orders.'):
-        Exchange(default_conf)
+    # TODO: Revert once createMarketOrder is available again.
+    # with pytest.raises(OperationalException,
+    #                    match=r'Exchange .* does not support market orders.'):
+    #     Exchange(default_conf)

    default_conf['order_types'] = {
        'entry': 'limit',
@ -3544,7 +3545,7 @@ def test_order_has_fee(order, expected) -> None:
 def test_extract_cost_curr_rate(mocker, default_conf, order, expected) -> None:
    mocker.patch('freqtrade.exchange.Exchange.calculate_fee_rate', MagicMock(return_value=0.01))
    ex = get_patched_exchange(mocker, default_conf)
-    assert ex.extract_cost_curr_rate(order) == expected
+    assert ex.extract_cost_curr_rate(order['fee'], order['symbol'], cost=20, amount=1) == expected


@pytest.mark.parametrize("order,unknown_fee_rate,expected", [
@ -3582,6 +3583,9 @@ def test_extract_cost_curr_rate(mocker, default_conf, order, expected) -> None:
      'fee': {'currency': 'POINT', 'cost': 2.0, 'rate': None}}, 1, 4.0),
    ({'symbol': 'POINT/BTC', 'amount': 0.04, 'cost': 0.5,
      'fee': {'currency': 'POINT', 'cost': 2.0, 'rate': None}}, 2, 8.0),
+    # Missing currency
+    ({'symbol': 'ETH/BTC', 'amount': 0.04, 'cost': 0.05,
+        'fee': {'currency': None, 'cost': 0.005}}, None, None),
 ])
 def test_calculate_fee_rate(mocker, default_conf, order, expected, unknown_fee_rate) -> None:
    mocker.patch('freqtrade.exchange.Exchange.fetch_ticker', return_value={'last': 0.081})
@ -3590,7 +3594,8 @@ def test_calculate_fee_rate(mocker, default_conf, order, expected, unknown_fee_r

    ex = get_patched_exchange(mocker, default_conf)

-    assert ex.calculate_fee_rate(order) == expected
+    assert ex.calculate_fee_rate(order['fee'], order['symbol'],
+                                 cost=order['cost'], amount=order['amount']) == expected


@pytest.mark.parametrize('retrycount,max_retries,expected', [
--- a/tests/optimize/test_hyperopt.py
+++ b/tests/optimize/test_hyperopt.py
@ -861,6 +861,7 @@ def test_in_strategy_auto_hyperopt(mocker, hyperopt_conf, tmpdir, fee) -> None:
    hyperopt.backtesting.exchange.get_max_leverage = MagicMock(return_value=1.0)
    assert isinstance(hyperopt.custom_hyperopt, HyperOptAuto)
    assert isinstance(hyperopt.backtesting.strategy.buy_rsi, IntParameter)
+    assert hyperopt.backtesting.strategy.bot_loop_started is True

    assert hyperopt.backtesting.strategy.buy_rsi.in_space is True
    assert hyperopt.backtesting.strategy.buy_rsi.value == 35
--- a/tests/strategy/strats/hyperoptable_strategy.py
+++ b/tests/strategy/strats/hyperoptable_strategy.py
@ -44,6 +44,11 @@ class HyperoptableStrategy(StrategyTestV2):
            })
        return prot

+    bot_loop_started = False
+
+    def bot_loop_start(self):
+        self.bot_loop_started = True
+
    def bot_start(self, **kwargs) -> None:
        """
        Parameters can also be defined here ...
--- a/tests/test_freqtradebot.py
+++ b/tests/test_freqtradebot.py
@ -3951,9 +3951,9 @@ def test_ignore_roi_if_entry_signal(default_conf_usdt, limit_order, limit_order_

    # Test if entry-signal is absent (should sell due to roi = true)
    if is_short:
-        patch_get_signal(freqtrade, enter_long=False, exit_short=False)
+        patch_get_signal(freqtrade, enter_long=False, exit_short=False, exit_tag='something')
    else:
-        patch_get_signal(freqtrade, enter_long=False, exit_long=False)
+        patch_get_signal(freqtrade, enter_long=False, exit_long=False, exit_tag='something')
    assert freqtrade.handle_trade(trade) is True
    assert trade.exit_reason == ExitType.ROI.value

--- a/tests/test_persistence.py
+++ b/tests/test_persistence.py
@ -1200,7 +1200,7 @@ def test_migrate_new(mocker, default_conf, fee, caplog):
                          0.00258580, {stake}, {amount},
                          '2019-11-28 12:44:24.000000',
                          0.0, 0.0, 0.0, '5m',
-                          'buy_order', 'stop_order_id222')
+                          'buy_order', 'dry_stop_order_id222')
                          """.format(fee=fee.return_value,
                                     stake=default_conf.get("stake_amount"),
                                     amount=amount
@ -1226,7 +1226,7 @@ def test_migrate_new(mocker, default_conf, fee, caplog):
            'buy',
            'ETC/BTC',
            0,
-            'buy_order',
+            'dry_buy_order',
            'closed',
            'ETC/BTC',
            'limit',
@ -1238,12 +1238,44 @@ def test_migrate_new(mocker, default_conf, fee, caplog):
            {amount * 0.00258580}
        ),
        (
+            1,
+            'buy',
+            'ETC/BTC',
+            1,
+            'dry_buy_order22',
+            'canceled',
+            'ETC/BTC',
+            'limit',
+            'buy',
+            0.00258580,
+            {amount},
+            {amount},
+            0,
+            {amount * 0.00258580}
+        ),
+         (
            1,
            'stoploss',
            'ETC/BTC',
+            1,
+            'dry_stop_order_id11X',
+            'canceled',
+            'ETC/BTC',
+            'limit',
+            'sell',
+            0.00258580,
+            {amount},
+            {amount},
            0,
-            'stop_order_id222',
-            'closed',
+            {amount * 0.00258580}
+        ),
+        (
+            1,
+            'stoploss',
+            'ETC/BTC',
+            1,
+            'dry_stop_order_id222',
+            'open',
            'ETC/BTC',
            'limit',
            'sell',
@ -1292,7 +1324,7 @@ def test_migrate_new(mocker, default_conf, fee, caplog):
    assert trade.exit_reason is None
    assert trade.strategy is None
    assert trade.timeframe == '5m'
-    assert trade.stoploss_order_id == 'stop_order_id222'
+    assert trade.stoploss_order_id == 'dry_stop_order_id222'
    assert trade.stoploss_last_update is None
    assert log_has("trying trades_bak1", caplog)
    assert log_has("trying trades_bak2", caplog)
@ -1302,12 +1334,21 @@ def test_migrate_new(mocker, default_conf, fee, caplog):
    assert trade.close_profit_abs is None

    orders = trade.orders
-    assert len(orders) == 2
-    assert orders[0].order_id == 'buy_order'
+    assert len(orders) == 4
+    assert orders[0].order_id == 'dry_buy_order'
    assert orders[0].ft_order_side == 'buy'

-    assert orders[1].order_id == 'stop_order_id222'
-    assert orders[1].ft_order_side == 'stoploss'
+    assert orders[-1].order_id == 'dry_stop_order_id222'
+    assert orders[-1].ft_order_side == 'stoploss'
+    assert orders[-1].ft_is_open is True
+
+    assert orders[1].order_id == 'dry_buy_order22'
+    assert orders[1].ft_order_side == 'buy'
+    assert orders[1].ft_is_open is False
+
+    assert orders[2].order_id == 'dry_stop_order_id11X'
+    assert orders[2].ft_order_side == 'stoploss'
+    assert orders[2].ft_is_open is False


 def test_migrate_too_old(mocker, default_conf, fee, caplog):