Merge branch 'develop' of https://github.com/Surfableio/freqtrade into develop

2022-06-21 14:06:56 -04:00 · 2022-06-21 14:06:56 -04:00 · e2a94d75b4
commit e2a94d75b4
parent 405ea74f16 36f7315481
58 changed files with 1745 additions and 958 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -13,6 +13,10 @@ on:
  schedule:
    - cron:  '0 5 * * 4'

+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
  build_linux:

@ -26,7 +30,7 @@ jobs:
    - uses: actions/checkout@v3

    - name: Set up Python
-      uses: actions/setup-python@v3
+      uses: actions/setup-python@v4
      with:
        python-version: ${{ matrix.python-version }}

@ -123,7 +127,7 @@ jobs:
    - uses: actions/checkout@v3

    - name: Set up Python
-      uses: actions/setup-python@v3
+      uses: actions/setup-python@v4
      with:
        python-version: ${{ matrix.python-version }}

@ -207,7 +211,7 @@ jobs:
    - uses: actions/checkout@v3

    - name: Set up Python
-      uses: actions/setup-python@v3
+      uses: actions/setup-python@v4
      with:
        python-version: ${{ matrix.python-version }}

@ -259,7 +263,7 @@ jobs:
    - uses: actions/checkout@v3

    - name: Set up Python
-      uses: actions/setup-python@v3
+      uses: actions/setup-python@v4
      with:
        python-version: "3.10"

@ -278,7 +282,7 @@ jobs:
        ./tests/test_docs.sh

    - name: Set up Python
-      uses: actions/setup-python@v3
+      uses: actions/setup-python@v4
      with:
        python-version: "3.10"

@ -296,18 +300,6 @@ jobs:
          details: Freqtrade doc test failed!
          webhookUrl: ${{ secrets.DISCORD_WEBHOOK }}

-  cleanup-prior-runs:
-    permissions:
-      actions: write  # for rokroskar/workflow-run-cleanup-action to obtain workflow name & cancel it
-      contents: read  # for rokroskar/workflow-run-cleanup-action to obtain branch
-    runs-on: ubuntu-20.04
-    steps:
-    - name: Cleanup previous runs on this branch
-      uses: rokroskar/workflow-run-cleanup-action@v0.3.3
-      if: "!startsWith(github.ref, 'refs/tags/') && github.ref != 'refs/heads/stable' && github.repository == 'freqtrade/freqtrade'"
-      env:
-        GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
-
  # Notify only once - when CI completes (and after deploy) in case it's successfull
  notify-complete:
    needs: [ build_linux, build_macos, build_windows, docs_check, mypy_version_check ]
@ -344,7 +336,7 @@ jobs:
    - uses: actions/checkout@v3

    - name: Set up Python
-      uses: actions/setup-python@v3
+      uses: actions/setup-python@v4
      with:
        python-version: "3.9"

--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@ -14,8 +14,8 @@ repos:
        exclude: build_helpers
        additional_dependencies:
          - types-cachetools==5.0.1
-          - types-filelock==3.2.6
-          - types-requests==2.27.29
+          - types-filelock==3.2.7
+          - types-requests==2.27.30
          - types-tabulate==0.8.9
          - types-python-dateutil==2.8.17
        # stages: [push]
--- a/2
+++ b/2
@ -1,4 +1,4 @@
-FROM python:3.10.4-slim-bullseye as base
+FROM python:3.10.5-slim-bullseye as base

 # Setup env
 ENV LANG C.UTF-8
--- a/docs/advanced-backtesting.md
+++ b/docs/advanced-backtesting.md
@ -22,50 +22,79 @@ DataFrame of the candles that resulted in buy signals. Depending on how many buy
 makes, this file may get quite large, so periodically check your `user_data/backtest_results`
 folder to delete old exports.

-To analyze the buy tags, we need to use the `buy_reasons.py` script from
-[froggleston's repo](https://github.com/froggleston/freqtrade-buyreasons). Follow the instructions
-in their README to copy the script into your `freqtrade/scripts/` folder.
-
 Before running your next backtest, make sure you either delete your old backtest results or run
 backtesting with the `--cache none` option to make sure no cached results are used.

 If all goes well, you should now see a `backtest-result-{timestamp}_signals.pkl` file in the
 `user_data/backtest_results` folder.

-Now run the `buy_reasons.py` script, supplying a few options:
+To analyze the entry/exit tags, we now need to use the `freqtrade backtesting-analysis` command
+with `--analysis-groups` option provided with space-separated arguments (default `0 1 2`):

 ``` bash
-python3 scripts/buy_reasons.py -c <config.json> -s <strategy_name> -t <timerange> -g0,1,2,3,4
+freqtrade backtesting-analysis -c <config.json> --analysis-groups 0 1 2 3 4
 ```

-The `-g` option is used to specify the various tabular outputs, ranging from the simplest (0)
-to the most detailed per pair, per buy and per sell tag (4). More options are available by
-running with the `-h` option.
+This command will read from the last backtesting results. The `--analysis-groups` option is
+used to specify the various tabular outputs showing the profit fo each group or trade,
+ranging from the simplest (0) to the most detailed per pair, per buy and per sell tag (4):
+
+* 1: profit summaries grouped by enter_tag
+* 2: profit summaries grouped by enter_tag and exit_tag
+* 3: profit summaries grouped by pair and enter_tag
+* 4: profit summaries grouped by pair, enter_ and exit_tag (this can get quite large)
+
+More options are available by running with the `-h` option.
+
+### Using export-filename
+
+Normally, `backtesting-analysis` uses the latest backtest results, but if you wanted to go
+back to a previous backtest output, you need to supply the `--export-filename` option.
+You can supply the same parameter to `backtest-analysis` with the name of the final backtest
+output file. This allows you to keep historical versions of backtest results and re-analyse
+them at a later date:
+
+``` bash
+freqtrade backtesting -c <config.json> --timeframe <tf> --strategy <strategy_name> --timerange=<timerange> --export=signals --export-filename=/tmp/mystrat_backtest.json
+```
+
+You should see some output similar to below in the logs with the name of the timestamped
+filename that was exported:
+
+```
+2022-06-14 16:28:32,698 - freqtrade.misc - INFO - dumping json to "/tmp/mystrat_backtest-2022-06-14_16-28-32.json"
+```
+
+You can then use that filename in `backtesting-analysis`:
+
+```
+freqtrade backtesting-analysis -c <config.json> --export-filename=/tmp/mystrat_backtest-2022-06-14_16-28-32.json
+```

 ### Tuning the buy tags and sell tags to display

 To show only certain buy and sell tags in the displayed output, use the following two options:

 ```
--enter_reason_list : Comma separated list of enter signals to analyse. Default: "all"
--exit_reason_list : Comma separated list of exit signals to analyse. Default: "stop_loss,trailing_stop_loss"
+--enter-reason-list : Space-separated list of enter signals to analyse. Default: "all"
+--exit-reason-list : Space-separated list of exit signals to analyse. Default: "all"
 ```

 For example:

 ```bash
-python3 scripts/buy_reasons.py -c <config.json> -s <strategy_name> -t <timerange> -g0,1,2,3,4 --enter_reason_list "enter_tag_a,enter_tag_b" --exit_reason_list "roi,custom_exit_tag_a,stop_loss"
+freqtrade backtesting-analysis -c <config.json> --analysis-groups 0 2 --enter-reason-list enter_tag_a enter_tag_b --exit-reason-list roi custom_exit_tag_a stop_loss
 ```

 ### Outputting signal candle indicators

-The real power of the buy_reasons.py script comes from the ability to print out the indicator
+The real power of `freqtrade backtesting-analysis` comes from the ability to print out the indicator
 values present on signal candles to allow fine-grained investigation and tuning of buy signal
 indicators. To print out a column for a given set of indicators, use the `--indicator-list`
 option:

 ```bash
-python3 scripts/buy_reasons.py -c <config.json> -s <strategy_name> -t <timerange> -g0,1,2,3,4 --enter_reason_list "enter_tag_a,enter_tag_b" --exit_reason_list "roi,custom_exit_tag_a,stop_loss" --indicator_list "rsi,rsi_1h,bb_lowerband,ema_9,macd,macdsignal"
+freqtrade backtesting-analysis -c <config.json> --analysis-groups 0 2 --enter-reason-list enter_tag_a enter_tag_b --exit-reason-list roi custom_exit_tag_a stop_loss --indicator-list rsi rsi_1h bb_lowerband ema_9 macd macdsignal
 ```

 The indicators have to be present in your strategy's main DataFrame (either for your main
--- a/docs/assets/discord_notification.png
+++ b/docs/assets/discord_notification.png
--- a/docs/requirements-docs.txt
+++ b/docs/requirements-docs.txt
@ -1,5 +1,5 @@
 mkdocs==1.3.0
-mkdocs-material==8.2.16
+mkdocs-material==8.3.4
 mdx_truly_sane_lists==1.2
-pymdown-extensions==9.4
+pymdown-extensions==9.5
 jinja2==3.1.2
--- a/docs/sql_cheatsheet.md
+++ b/docs/sql_cheatsheet.md
@ -89,11 +89,12 @@ WHERE id=31;

 If you'd still like to remove a trade from the database directly, you can use the below query.

-```sql
-DELETE FROM trades WHERE id = <tradeid>;
-```
+!!! Danger
+    Some systems (Ubuntu) disable foreign keys in their sqlite3 packaging. When using sqlite - please ensure that foreign keys are on by running `PRAGMA foreign_keys = ON` before the above query.

 ```sql
+DELETE FROM trades WHERE id = <tradeid>;
+
 DELETE FROM trades WHERE id = 31;
 ```

@ -102,13 +103,20 @@ DELETE FROM trades WHERE id = 31;

 ## Use a different database system

+Freqtrade is using SQLAlchemy, which supports multiple different database systems. As such, a multitude of database systems should be supported.
+Freqtrade does not depend or install any additional database driver. Please refer to the [SQLAlchemy docs](https://docs.sqlalchemy.org/en/14/core/engines.html#database-urls) on installation instructions for the respective database systems.
+
+The following systems have been tested and are known to work with freqtrade:
+
+* sqlite (default)
+* PostgreSQL)
+* MariaDB
+
 !!! Warning
-    By using one of the below database systems, you acknowledge that you know how to manage such a system. Freqtrade will not provide any support with setup or maintenance (or backups) of the below database systems.
+    By using one of the below database systems, you acknowledge that you know how to manage such a system. The freqtrade team will not provide any support with setup or maintenance (or backups) of the below database systems.

 ### PostgreSQL

-Freqtrade supports PostgreSQL by using SQLAlchemy, which supports multiple different database systems.
-
 Installation:
 `pip install psycopg2-binary`

--- a/docs/strategy-callbacks.md
+++ b/docs/strategy-callbacks.md
@ -550,7 +550,8 @@ class AwesomeStrategy(IStrategy):
        :param pair: Pair that's about to be bought/shorted.
        :param order_type: Order type (as configured in order_types). usually limit or market.
        :param amount: Amount in target (base) currency that's going to be traded.
-        :param rate: Rate that's going to be used when using limit orders
+        :param rate: Rate that's going to be used when using limit orders 
+                     or current rate for market orders.
        :param time_in_force: Time in force. Defaults to GTC (Good-til-cancelled).
        :param current_time: datetime object, containing the current datetime
        :param entry_tag: Optional entry_tag (buy_tag) if provided with the buy signal.
@ -600,6 +601,7 @@ class AwesomeStrategy(IStrategy):
        :param order_type: Order type (as configured in order_types). usually limit or market.
        :param amount: Amount in base currency.
        :param rate: Rate that's going to be used when using limit orders
+                     or current rate for market orders.
        :param time_in_force: Time in force. Defaults to GTC (Good-til-cancelled).
        :param exit_reason: Exit reason.
            Can be any of ['roi', 'stop_loss', 'stoploss_on_exchange', 'trailing_stop_loss',
@ -804,17 +806,18 @@ For markets / exchanges that don't support leverage, this method is ignored.

 ``` python
 class AwesomeStrategy(IStrategy):
-    def leverage(self, pair: str, current_time: 'datetime', current_rate: float,
-                 proposed_leverage: float, max_leverage: float, side: str,
+    def leverage(self, pair: str, current_time: datetime, current_rate: float,
+                 proposed_leverage: float, max_leverage: float, entry_tag: Optional[str], side: str,
                 **kwargs) -> float:
        """
-        Customize leverage for each new trade.
+        Customize leverage for each new trade. This method is only called in futures mode.

        :param pair: Pair that's currently analyzed
        :param current_time: datetime object, containing the current datetime
        :param current_rate: Rate, calculated based on pricing settings in exit_pricing.
        :param proposed_leverage: A leverage proposed by the bot.
        :param max_leverage: Max leverage allowed on this pair
+        :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 leverage amount, which is between 1.0 and max_leverage.
        """
--- a/docs/telegram-usage.md
+++ b/docs/telegram-usage.md
@ -328,11 +328,11 @@ Per default `/daily` will return the 7 last days. The example below if for `/dai

 > **Daily Profit over the last 3 days:**
 ```
-Day         Profit BTC      Profit USD
----------  --------------  ------------
-2018-01-03  0.00224175 BTC  29,142 USD
-2018-01-02  0.00033131 BTC   4,307 USD
-2018-01-01  0.00269130 BTC  34.986 USD
+Day (count)     USDT          USD         Profit %
+--------------  ------------  ----------  ----------
+2022-06-11 (1)  -0.746 USDT   -0.75 USD   -0.08%
+2022-06-10 (0)  0 USDT        0.00 USD    0.00%
+2022-06-09 (5)  20 USDT       20.10 USD   5.00%
 ```

 ### /weekly <n>
@ -342,11 +342,11 @@ from Monday. The example below if for `/weekly 3`:

 > **Weekly Profit over the last 3 weeks (starting from Monday):**
 ```
-Monday         Profit BTC      Profit USD
----------  --------------  ------------
-2018-01-03  0.00224175 BTC  29,142 USD
-2017-12-27  0.00033131 BTC   4,307 USD
-2017-12-20  0.00269130 BTC  34.986 USD
+Monday (count)  Profit BTC      Profit USD   Profit %
+-------------  --------------  ------------    ----------
+2018-01-03 (5)  0.00224175 BTC  29,142 USD   4.98%
+2017-12-27 (1)  0.00033131 BTC   4,307 USD   0.00%
+2017-12-20 (4)  0.00269130 BTC  34.986 USD   5.12%
 ```

 ### /monthly <n>
@ -356,11 +356,11 @@ if for `/monthly 3`:

 > **Monthly Profit over the last 3 months:**
 ```
-Month         Profit BTC      Profit USD
----------  --------------  ------------
-2018-01     0.00224175 BTC  29,142 USD
-2017-12     0.00033131 BTC   4,307 USD
-2017-11     0.00269130 BTC  34.986 USD
+Month (count)  Profit BTC      Profit USD    Profit %
+-------------  --------------  ------------    ----------
+2018-01 (20)    0.00224175 BTC  29,142 USD  4.98%
+2017-12 (5)    0.00033131 BTC   4,307 USD   0.00%
+2017-11 (10)    0.00269130 BTC  34.986 USD  5.10%
 ```

 ### /whitelist
--- a/docs/updating.md
+++ b/docs/updating.md
@ -32,4 +32,8 @@ Please ensure that you're also updating dependencies - otherwise things might br
 ``` bash
 git pull
 pip install -U -r requirements.txt
+pip install -e .
+
+# Ensure freqUI is at the latest version
+freqtrade install-ui 
 ```
--- a/docs/utils.md
+++ b/docs/utils.md
@ -651,6 +651,61 @@ Common arguments:

 ```

+## Detailed backtest analysis
+
+Advanced backtest result analysis.
+
+More details in the [Backtesting analysis](advanced-backtesting.md#analyze-the-buyentry-and-sellexit-tags) Section.
+
+```
+usage: freqtrade backtesting-analysis [-h] [-v] [--logfile FILE] [-V]
+                                      [-c PATH] [-d PATH] [--userdir PATH]
+                                      [--export-filename PATH]
+                                      [--analysis-groups {0,1,2,3,4} [{0,1,2,3,4} ...]]
+                                      [--enter-reason-list ENTER_REASON_LIST [ENTER_REASON_LIST ...]]
+                                      [--exit-reason-list EXIT_REASON_LIST [EXIT_REASON_LIST ...]]
+                                      [--indicator-list INDICATOR_LIST [INDICATOR_LIST ...]]
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --export-filename PATH, --backtest-filename PATH
+                        Use this filename for backtest results.Requires
+                        `--export` to be set as well. Example: `--export-filen
+                        ame=user_data/backtest_results/backtest_today.json`
+  --analysis-groups {0,1,2,3,4} [{0,1,2,3,4} ...]
+                        grouping output - 0: simple wins/losses by enter tag,
+                        1: by enter_tag, 2: by enter_tag and exit_tag, 3: by
+                        pair and enter_tag, 4: by pair, enter_ and exit_tag
+                        (this can get quite large)
+  --enter-reason-list ENTER_REASON_LIST [ENTER_REASON_LIST ...]
+                        Comma separated list of entry signals to analyse.
+                        Default: all. e.g. 'entry_tag_a,entry_tag_b'
+  --exit-reason-list EXIT_REASON_LIST [EXIT_REASON_LIST ...]
+                        Comma separated list of exit signals to analyse.
+                        Default: all. e.g.
+                        'exit_tag_a,roi,stop_loss,trailing_stop_loss'
+  --indicator-list INDICATOR_LIST [INDICATOR_LIST ...]
+                        Comma separated list of indicators to analyse. e.g.
+                        'close,rsi,bb_lowerband,profit_abs'
+
+Common arguments:
+  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
+  --logfile FILE        Log to the file specified. Special values are:
+                        'syslog', 'journald'. See the documentation for more
+                        details.
+  -V, --version         show program's version number and exit
+  -c PATH, --config PATH
+                        Specify configuration file (default:
+                        `userdir/config.json` or `config.json` whichever
+                        exists). Multiple --config options may be used. Can be
+                        set to `-` to read config from stdin.
+  -d PATH, --datadir PATH
+                        Path to directory with historical backtesting data.
+  --userdir PATH, --user-data-dir PATH
+                        Path to userdata directory.
+
+```
+
 ## List Hyperopt results

 You can list the hyperoptimization epochs the Hyperopt module evaluated previously with the `hyperopt-list` sub-command.
--- a/docs/webhook-config.md
+++ b/docs/webhook-config.md
@ -239,3 +239,52 @@ Possible parameters are:
 The fields in `webhook.webhookstatus` are used for regular status messages (Started / Stopped / ...). Parameters are filled using string.format.

 The only possible value here is `{status}`.
+
+## Discord
+
+A special form of webhooks is available for discord.
+You can configure this as follows:
+
+```json
+"discord": {
+    "enabled": true,
+    "webhook_url": "https://discord.com/api/webhooks/<Your webhook URL ...>",
+    "exit_fill": [
+        {"Trade ID": "{trade_id}"},
+        {"Exchange": "{exchange}"},
+        {"Pair": "{pair}"},
+        {"Direction": "{direction}"},
+        {"Open rate": "{open_rate}"},
+        {"Close rate": "{close_rate}"},
+        {"Amount": "{amount}"},
+        {"Open date": "{open_date:%Y-%m-%d %H:%M:%S}"},
+        {"Close date": "{close_date:%Y-%m-%d %H:%M:%S}"},
+        {"Profit": "{profit_amount} {stake_currency}"},
+        {"Profitability": "{profit_ratio:.2%}"},
+        {"Enter tag": "{enter_tag}"},
+        {"Exit Reason": "{exit_reason}"},
+        {"Strategy": "{strategy}"},
+        {"Timeframe": "{timeframe}"},
+    ],
+    "entry_fill": [
+        {"Trade ID": "{trade_id}"},
+        {"Exchange": "{exchange}"},
+        {"Pair": "{pair}"},
+        {"Direction": "{direction}"},
+        {"Open rate": "{open_rate}"},
+        {"Amount": "{amount}"},
+        {"Open date": "{open_date:%Y-%m-%d %H:%M:%S}"},
+        {"Enter tag": "{enter_tag}"},
+        {"Strategy": "{strategy} {timeframe}"},
+    ]
+}
+```
+
+
+The above represents the default (`exit_fill` and `entry_fill` are optional and will default to the above configuration) - modifications are obviously possible.
+
+Available fields correspond to the fields for webhooks and are documented in the corresponding webhook sections.
+
+The notifications will look as follows by default.
+
+![discord-notification](assets/discord_notification.png)
--- a/freqtrade/commands/init.py
+++ b/freqtrade/commands/init.py
@ -6,6 +6,7 @@ Contains all start-commands, subcommands and CLI Interface creation.
 Note: Be careful with file-scoped imports in these subfiles.
    as they are parsed on startup, nothing containing optional modules should be loaded.
 """
+from freqtrade.commands.analyze_commands import start_analysis_entries_exits
 from freqtrade.commands.arguments import Arguments
 from freqtrade.commands.build_config_commands import start_new_config
 from freqtrade.commands.data_commands import (start_convert_data, start_convert_trades,
--- a/freqtrade/commands/analyze_commands.py
+++ b/freqtrade/commands/analyze_commands.py
@ -0,0 +1,69 @@
+import logging
+from pathlib import Path
+from typing import Any, Dict
+
+from freqtrade.configuration import setup_utils_configuration
+from freqtrade.enums import RunMode
+from freqtrade.exceptions import OperationalException
+
+
+logger = logging.getLogger(__name__)
+
+
+def setup_analyze_configuration(args: Dict[str, Any], method: RunMode) -> Dict[str, Any]:
+    """
+    Prepare the configuration for the entry/exit reason analysis module
+    :param args: Cli args from Arguments()
+    :param method: Bot running mode
+    :return: Configuration
+    """
+    config = setup_utils_configuration(args, method)
+
+    no_unlimited_runmodes = {
+        RunMode.BACKTEST: 'backtesting',
+    }
+    if method in no_unlimited_runmodes.keys():
+        from freqtrade.data.btanalysis import get_latest_backtest_filename
+
+        if 'exportfilename' in config:
+            if config['exportfilename'].is_dir():
+                btfile = Path(get_latest_backtest_filename(config['exportfilename']))
+                signals_file = f"{config['exportfilename']}/{btfile.stem}_signals.pkl"
+            else:
+                if config['exportfilename'].exists():
+                    btfile = Path(config['exportfilename'])
+                    signals_file = f"{btfile.parent}/{btfile.stem}_signals.pkl"
+                else:
+                    raise OperationalException(f"{config['exportfilename']} does not exist.")
+        else:
+            raise OperationalException('exportfilename not in config.')
+
+        if (not Path(signals_file).exists()):
+            raise OperationalException(
+                (f"Cannot find latest backtest signals file: {signals_file}."
+                  "Run backtesting with `--export signals`.")
+            )
+
+    return config
+
+
+def start_analysis_entries_exits(args: Dict[str, Any]) -> None:
+    """
+    Start analysis script
+    :param args: Cli args from Arguments()
+    :return: None
+    """
+    from freqtrade.data.entryexitanalysis import process_entry_exit_reasons
+
+    # Initialize configuration
+    config = setup_analyze_configuration(args, RunMode.BACKTEST)
+
+    logger.info('Starting freqtrade in analysis mode')
+
+    process_entry_exit_reasons(config['exportfilename'],
+                               config['exchange']['pair_whitelist'],
+                               config['analysis_groups'],
+                               config['enter_reason_list'],
+                               config['exit_reason_list'],
+                               config['indicator_list']
+                               )
--- a/freqtrade/commands/arguments.py
+++ b/freqtrade/commands/arguments.py
@ -101,6 +101,9 @@ ARGS_HYPEROPT_SHOW = ["hyperopt_list_best", "hyperopt_list_profitable", "hyperop
                      "print_json", "hyperoptexportfilename", "hyperopt_show_no_header",
                      "disableparamexport", "backtest_breakdown"]

+ARGS_ANALYZE_ENTRIES_EXITS = ["exportfilename", "analysis_groups", "enter_reason_list",
+                              "exit_reason_list", "indicator_list"]
+
 NO_CONF_REQURIED = ["convert-data", "convert-trade-data", "download-data", "list-timeframes",
                    "list-markets", "list-pairs", "list-strategies", "list-data",
                    "hyperopt-list", "hyperopt-show", "backtest-filter",
@ -182,8 +185,9 @@ class Arguments:
        self.parser = argparse.ArgumentParser(description='Free, open source crypto trading bot')
        self._build_args(optionlist=['version'], parser=self.parser)

-        from freqtrade.commands import (start_backtesting, start_backtesting_show,
-                                        start_convert_data, start_convert_db, start_convert_trades,
+        from freqtrade.commands import (start_analysis_entries_exits, start_backtesting,
+                                        start_backtesting_show, start_convert_data,
+                                        start_convert_db, start_convert_trades,
                                        start_create_userdir, start_download_data, start_edge,
                                        start_hyperopt, start_hyperopt_list, start_hyperopt_show,
                                        start_install_ui, start_list_data, start_list_exchanges,
@ -283,6 +287,13 @@ class Arguments:
        backtesting_show_cmd.set_defaults(func=start_backtesting_show)
        self._build_args(optionlist=ARGS_BACKTEST_SHOW, parser=backtesting_show_cmd)

+        # Add backtesting analysis subcommand
+        analysis_cmd = subparsers.add_parser('backtesting-analysis',
+                                             help='Backtest Analysis module.',
+                                             parents=[_common_parser])
+        analysis_cmd.set_defaults(func=start_analysis_entries_exits)
+        self._build_args(optionlist=ARGS_ANALYZE_ENTRIES_EXITS, parser=analysis_cmd)
+
        # Add edge subcommand
        edge_cmd = subparsers.add_parser('edge', help='Edge module.',
                                         parents=[_common_parser, _strategy_parser])
--- a/freqtrade/commands/cli_options.py
+++ b/freqtrade/commands/cli_options.py
@ -614,4 +614,37 @@ AVAILABLE_CLI_OPTIONS = {
              "that do not contain any parameters."),
        action="store_true",
    ),
+    "analysis_groups": Arg(
+        "--analysis-groups",
+        help=("grouping output - "
+              "0: simple wins/losses by enter tag, "
+              "1: by enter_tag, "
+              "2: by enter_tag and exit_tag, "
+              "3: by pair and enter_tag, "
+              "4: by pair, enter_ and exit_tag (this can get quite large)"),
+        nargs='+',
+        default=['0', '1', '2'],
+        choices=['0', '1', '2', '3', '4'],
+    ),
+    "enter_reason_list": Arg(
+        "--enter-reason-list",
+        help=("Comma separated list of entry signals to analyse. Default: all. "
+              "e.g. 'entry_tag_a,entry_tag_b'"),
+        nargs='+',
+        default=['all'],
+    ),
+    "exit_reason_list": Arg(
+        "--exit-reason-list",
+        help=("Comma separated list of exit signals to analyse. Default: all. "
+              "e.g. 'exit_tag_a,roi,stop_loss,trailing_stop_loss'"),
+        nargs='+',
+        default=['all'],
+    ),
+    "indicator_list": Arg(
+        "--indicator-list",
+        help=("Comma separated list of indicators to analyse. "
+              "e.g. 'close,rsi,bb_lowerband,profit_abs'"),
+        nargs='+',
+        default=[],
+    ),
 }
--- a/freqtrade/configuration/configuration.py
+++ b/freqtrade/configuration/configuration.py
@ -95,6 +95,8 @@ class Configuration:

        self._process_data_options(config)

+        self._process_analyze_options(config)
+
        # Check if the exchange set by the user is supported
        check_exchange(config, config.get('experimental', {}).get('block_bad_exchanges', True))

@ -433,6 +435,19 @@ class Configuration:
        self._args_to_config(config, argname='candle_types',
                             logstring='Detected --candle-types: {}')

+    def _process_analyze_options(self, config: Dict[str, Any]) -> None:
+        self._args_to_config(config, argname='analysis_groups',
+                             logstring='Analysis reason groups: {}')
+
+        self._args_to_config(config, argname='enter_reason_list',
+                             logstring='Analysis enter tag list: {}')
+
+        self._args_to_config(config, argname='exit_reason_list',
+                             logstring='Analysis exit tag list: {}')
+
+        self._args_to_config(config, argname='indicator_list',
+                             logstring='Analysis indicator list: {}')
+
    def _process_runmode(self, config: Dict[str, Any]) -> None:

        self._args_to_config(config, argname='dry_run',
--- a/freqtrade/constants.py
+++ b/freqtrade/constants.py
@ -336,6 +336,47 @@ CONF_SCHEMA = {
                'webhookstatus': {'type': 'object'},
            },
        },
+        'discord': {
+            'type': 'object',
+            'properties': {
+                'enabled': {'type': 'boolean'},
+                'webhook_url': {'type': 'string'},
+                "exit_fill": {
+                    'type': 'array', 'items': {'type': 'object'},
+                    'default': [
+                        {"Trade ID": "{trade_id}"},
+                        {"Exchange": "{exchange}"},
+                        {"Pair": "{pair}"},
+                        {"Direction": "{direction}"},
+                        {"Open rate": "{open_rate}"},
+                        {"Close rate": "{close_rate}"},
+                        {"Amount": "{amount}"},
+                        {"Open date": "{open_date:%Y-%m-%d %H:%M:%S}"},
+                        {"Close date": "{close_date:%Y-%m-%d %H:%M:%S}"},
+                        {"Profit": "{profit_amount} {stake_currency}"},
+                        {"Profitability": "{profit_ratio:.2%}"},
+                        {"Enter tag": "{enter_tag}"},
+                        {"Exit Reason": "{exit_reason}"},
+                        {"Strategy": "{strategy}"},
+                        {"Timeframe": "{timeframe}"},
+                    ]
+                },
+                "entry_fill": {
+                    'type': 'array', 'items': {'type': 'object'},
+                    'default': [
+                        {"Trade ID": "{trade_id}"},
+                        {"Exchange": "{exchange}"},
+                        {"Pair": "{pair}"},
+                        {"Direction": "{direction}"},
+                        {"Open rate": "{open_rate}"},
+                        {"Amount": "{amount}"},
+                        {"Open date": "{open_date:%Y-%m-%d %H:%M:%S}"},
+                        {"Enter tag": "{enter_tag}"},
+                        {"Strategy": "{strategy} {timeframe}"},
+                    ]
+                },
+            }
+        },
        'api_server': {
            'type': 'object',
            'properties': {
--- a/freqtrade/data/btanalysis.py
+++ b/freqtrade/data/btanalysis.py
@ -26,7 +26,7 @@ BT_DATA_COLUMNS = ['pair', 'stake_amount', 'amount', 'open_date', 'close_date',
                   'profit_ratio', 'profit_abs', 'exit_reason',
                   'initial_stop_loss_abs', 'initial_stop_loss_ratio', 'stop_loss_abs',
                   'stop_loss_ratio', 'min_rate', 'max_rate', 'is_open', 'enter_tag',
-                   'is_short'
+                   'is_short', 'open_timestamp', 'close_timestamp', 'orders'
                   ]


@ -283,6 +283,8 @@ def load_backtest_data(filename: Union[Path, str], strategy: Optional[str] = Non
            if 'enter_tag' not in df.columns:
                df['enter_tag'] = df['buy_tag']
                df = df.drop(['buy_tag'], axis=1)
+            if 'orders' not in df.columns:
+                df.loc[:, 'orders'] = None

    else:
        # old format - only with lists.
@ -337,7 +339,7 @@ def trade_list_to_dataframe(trades: List[LocalTrade]) -> pd.DataFrame:
    :param trades: List of trade objects
    :return: Dataframe with BT_DATA_COLUMNS
    """
-    df = pd.DataFrame.from_records([t.to_json() for t in trades], columns=BT_DATA_COLUMNS)
+    df = pd.DataFrame.from_records([t.to_json(True) for t in trades], columns=BT_DATA_COLUMNS)
    if len(df) > 0:
        df.loc[:, 'close_date'] = pd.to_datetime(df['close_date'], utc=True)
        df.loc[:, 'open_date'] = pd.to_datetime(df['open_date'], utc=True)
--- a/freqtrade/data/entryexitanalysis.py
+++ b/freqtrade/data/entryexitanalysis.py
@ -0,0 +1,227 @@
+import logging
+from pathlib import Path
+from typing import List, Optional
+
+import joblib
+import pandas as pd
+from tabulate import tabulate
+
+from freqtrade.data.btanalysis import (get_latest_backtest_filename, load_backtest_data,
+                                       load_backtest_stats)
+from freqtrade.exceptions import OperationalException
+
+
+logger = logging.getLogger(__name__)
+
+
+def _load_signal_candles(backtest_dir: Path):
+    if backtest_dir.is_dir():
+        scpf = Path(backtest_dir,
+                    Path(get_latest_backtest_filename(backtest_dir)).stem + "_signals.pkl"
+                    )
+    else:
+        scpf = Path(backtest_dir.parent / f"{backtest_dir.stem}_signals.pkl")
+
+    try:
+        scp = open(scpf, "rb")
+        signal_candles = joblib.load(scp)
+        logger.info(f"Loaded signal candles: {str(scpf)}")
+    except Exception as e:
+        logger.error("Cannot load signal candles from pickled results: ", e)
+
+    return signal_candles
+
+
+def _process_candles_and_indicators(pairlist, strategy_name, trades, signal_candles):
+    analysed_trades_dict = {}
+    analysed_trades_dict[strategy_name] = {}
+
+    try:
+        logger.info(f"Processing {strategy_name} : {len(pairlist)} pairs")
+
+        for pair in pairlist:
+            if pair in signal_candles[strategy_name]:
+                analysed_trades_dict[strategy_name][pair] = _analyze_candles_and_indicators(
+                                                              pair,
+                                                              trades,
+                                                              signal_candles[strategy_name][pair])
+    except Exception as e:
+        print(f"Cannot process entry/exit reasons for {strategy_name}: ", e)
+
+    return analysed_trades_dict
+
+
+def _analyze_candles_and_indicators(pair, trades, signal_candles):
+    buyf = signal_candles
+
+    if len(buyf) > 0:
+        buyf = buyf.set_index('date', drop=False)
+        trades_red = trades.loc[trades['pair'] == pair].copy()
+
+        trades_inds = pd.DataFrame()
+
+        if trades_red.shape[0] > 0 and buyf.shape[0] > 0:
+            for t, v in trades_red.open_date.items():
+                allinds = buyf.loc[(buyf['date'] < v)]
+                if allinds.shape[0] > 0:
+                    tmp_inds = allinds.iloc[[-1]]
+
+                    trades_red.loc[t, 'signal_date'] = tmp_inds['date'].values[0]
+                    trades_red.loc[t, 'enter_reason'] = trades_red.loc[t, 'enter_tag']
+                    tmp_inds.index.rename('signal_date', inplace=True)
+                    trades_inds = pd.concat([trades_inds, tmp_inds])
+
+            if 'signal_date' in trades_red:
+                trades_red['signal_date'] = pd.to_datetime(trades_red['signal_date'], utc=True)
+                trades_red.set_index('signal_date', inplace=True)
+
+                try:
+                    trades_red = pd.merge(trades_red, trades_inds, on='signal_date', how='outer')
+                except Exception as e:
+                    raise e
+        return trades_red
+    else:
+        return pd.DataFrame()
+
+
+def _do_group_table_output(bigdf, glist):
+    for g in glist:
+        # 0: summary wins/losses grouped by enter tag
+        if g == "0":
+            group_mask = ['enter_reason']
+            wins = bigdf.loc[bigdf['profit_abs'] >= 0] \
+                        .groupby(group_mask) \
+                        .agg({'profit_abs': ['sum']})
+
+            wins.columns = ['profit_abs_wins']
+            loss = bigdf.loc[bigdf['profit_abs'] < 0] \
+                        .groupby(group_mask) \
+                        .agg({'profit_abs': ['sum']})
+            loss.columns = ['profit_abs_loss']
+
+            new = bigdf.groupby(group_mask).agg({'profit_abs': [
+                                                    'count',
+                                                    lambda x: sum(x > 0),
+                                                    lambda x: sum(x <= 0)]})
+            new = pd.concat([new, wins, loss], axis=1).fillna(0)
+
+            new['profit_tot'] = new['profit_abs_wins'] - abs(new['profit_abs_loss'])
+            new['wl_ratio_pct'] = (new.iloc[:, 1] / new.iloc[:, 0] * 100).fillna(0)
+            new['avg_win'] = (new['profit_abs_wins'] / new.iloc[:, 1]).fillna(0)
+            new['avg_loss'] = (new['profit_abs_loss'] / new.iloc[:, 2]).fillna(0)
+
+            new.columns = ['total_num_buys', 'wins', 'losses', 'profit_abs_wins', 'profit_abs_loss',
+                           'profit_tot', 'wl_ratio_pct', 'avg_win', 'avg_loss']
+
+            sortcols = ['total_num_buys']
+
+            _print_table(new, sortcols, show_index=True)
+
+        else:
+            agg_mask = {'profit_abs': ['count', 'sum', 'median', 'mean'],
+                        'profit_ratio': ['sum', 'median', 'mean']}
+            agg_cols = ['num_buys', 'profit_abs_sum', 'profit_abs_median',
+                        'profit_abs_mean', 'median_profit_pct', 'mean_profit_pct',
+                        'total_profit_pct']
+            sortcols = ['profit_abs_sum', 'enter_reason']
+
+            # 1: profit summaries grouped by enter_tag
+            if g == "1":
+                group_mask = ['enter_reason']
+
+            # 2: profit summaries grouped by enter_tag and exit_tag
+            if g == "2":
+                group_mask = ['enter_reason', 'exit_reason']
+
+            # 3: profit summaries grouped by pair and enter_tag
+            if g == "3":
+                group_mask = ['pair', 'enter_reason']
+
+            # 4: profit summaries grouped by pair, enter_ and exit_tag (this can get quite large)
+            if g == "4":
+                group_mask = ['pair', 'enter_reason', 'exit_reason']
+            if group_mask:
+                new = bigdf.groupby(group_mask).agg(agg_mask).reset_index()
+                new.columns = group_mask + agg_cols
+                new['median_profit_pct'] = new['median_profit_pct'] * 100
+                new['mean_profit_pct'] = new['mean_profit_pct'] * 100
+                new['total_profit_pct'] = new['total_profit_pct'] * 100
+
+                _print_table(new, sortcols)
+            else:
+                logger.warning("Invalid group mask specified.")
+
+
+def _print_results(analysed_trades, stratname, analysis_groups,
+                   enter_reason_list, exit_reason_list,
+                   indicator_list, columns=None):
+    if columns is None:
+        columns = ['pair', 'open_date', 'close_date', 'profit_abs', 'enter_reason', 'exit_reason']
+
+    bigdf = pd.DataFrame()
+    for pair, trades in analysed_trades[stratname].items():
+        bigdf = pd.concat([bigdf, trades], ignore_index=True)
+
+    if bigdf.shape[0] > 0 and ('enter_reason' in bigdf.columns):
+        if analysis_groups:
+            _do_group_table_output(bigdf, analysis_groups)
+
+        if enter_reason_list and "all" not in enter_reason_list:
+            bigdf = bigdf.loc[(bigdf['enter_reason'].isin(enter_reason_list))]
+
+        if exit_reason_list and "all" not in exit_reason_list:
+            bigdf = bigdf.loc[(bigdf['exit_reason'].isin(exit_reason_list))]
+
+        if "all" in indicator_list:
+            print(bigdf)
+        elif indicator_list is not None:
+            available_inds = []
+            for ind in indicator_list:
+                if ind in bigdf:
+                    available_inds.append(ind)
+            ilist = ["pair", "enter_reason", "exit_reason"] + available_inds
+            _print_table(bigdf[ilist], sortcols=['exit_reason'], show_index=False)
+    else:
+        print("\\_ No trades to show")
+
+
+def _print_table(df, sortcols=None, show_index=False):
+    if (sortcols is not None):
+        data = df.sort_values(sortcols)
+    else:
+        data = df
+
+    print(
+        tabulate(
+            data,
+            headers='keys',
+            tablefmt='psql',
+            showindex=show_index
+        )
+    )
+
+
+def process_entry_exit_reasons(backtest_dir: Path,
+                               pairlist: List[str],
+                               analysis_groups: Optional[List[str]] = ["0", "1", "2"],
+                               enter_reason_list: Optional[List[str]] = ["all"],
+                               exit_reason_list: Optional[List[str]] = ["all"],
+                               indicator_list: Optional[List[str]] = []):
+    try:
+        backtest_stats = load_backtest_stats(backtest_dir)
+        for strategy_name, results in backtest_stats['strategy'].items():
+            trades = load_backtest_data(backtest_dir, strategy_name)
+
+            if not trades.empty:
+                signal_candles = _load_signal_candles(backtest_dir)
+                analysed_trades_dict = _process_candles_and_indicators(pairlist, strategy_name,
+                                                                       trades, signal_candles)
+                _print_results(analysed_trades_dict,
+                               strategy_name,
+                               analysis_groups,
+                               enter_reason_list,
+                               exit_reason_list,
+                               indicator_list)
+
+    except ValueError as e:
+        raise OperationalException(e) from e
--- a/freqtrade/freqtradebot.py
+++ b/freqtrade/freqtradebot.py
@ -4,7 +4,7 @@ Freqtrade is the main module of this bot. It contains the class Freqtrade()
 import copy
 import logging
 import traceback
-from datetime import datetime, time, timezone
+from datetime import datetime, time, timedelta, timezone
 from math import isclose
 from threading import Lock
 from typing import Any, Dict, List, Optional, Tuple
@ -73,8 +73,6 @@ class FreqtradeBot(LoggingMixin):

        PairLocks.timeframe = self.config['timeframe']

-        self.protections = ProtectionManager(self.config, self.strategy.protections)
-
        # RPC runs in separate threads, can start handling external commands just after
        # initialization, even before Freqtradebot has a chance to start its throttling,
        # so anything in the Freqtradebot instance should be ready (initialized), including
@ -124,6 +122,8 @@ class FreqtradeBot(LoggingMixin):
        self.last_process = datetime(1970, 1, 1, tzinfo=timezone.utc)

        self.strategy.ft_bot_start()
+        # Initialize protections AFTER bot start - otherwise parameters are not loaded.
+        self.protections = ProtectionManager(self.config, self.strategy.protections)

    def notify_status(self, msg: str) -> None:
        """
@ -227,7 +227,7 @@ class FreqtradeBot(LoggingMixin):
        Notify the user when the bot is stopped (not reloaded)
        and there are still open trades active.
        """
-        open_trades = Trade.get_trades([Trade.is_open.is_(True)]).all()
+        open_trades = Trade.get_open_trades()

        if len(open_trades) != 0 and self.state != State.RELOAD_CONFIG:
            msg = {
@ -302,6 +302,15 @@ class FreqtradeBot(LoggingMixin):
                self.update_trade_state(order.trade, order.order_id, fo,
                                        stoploss_order=(order.ft_order_side == 'stoploss'))

+            except InvalidOrderException as e:
+                logger.warning(f"Error updating Order {order.order_id} due to {e}.")
+                if order.order_date_utc - timedelta(days=5) < datetime.now(timezone.utc):
+                    logger.warning(
+                        "Order is older than 5 days. Assuming order was fully cancelled.")
+                    fo = order.to_ccxt_object()
+                    fo['status'] = 'canceled'
+                    self.handle_timedout_order(fo, order.trade)
+
            except ExchangeError as e:

                logger.warning(f"Error updating Order {order.order_id} due to {e}")
@ -781,7 +790,7 @@ class FreqtradeBot(LoggingMixin):
                current_rate=enter_limit_requested,
                proposed_leverage=1.0,
                max_leverage=max_leverage,
-                side=trade_side,
+                side=trade_side, entry_tag=entry_tag,
            ) if self.trading_mode != TradingMode.SPOT else 1.0
            # Cap leverage between 1.0 and max_leverage.
            leverage = min(max(leverage, 1.0), max_leverage)
--- a/freqtrade/optimize/backtesting.py
+++ b/freqtrade/optimize/backtesting.py
@ -704,7 +704,7 @@ class Backtesting:
                current_rate=row[OPEN_IDX],
                proposed_leverage=1.0,
                max_leverage=max_leverage,
-                side=direction,
+                side=direction, entry_tag=entry_tag,
            ) if self._can_short else 1.0
            # Cap leverage between 1.0 and max_leverage.
            leverage = min(max(leverage, 1.0), max_leverage)
@ -966,6 +966,7 @@ class Backtesting:
                return False
            else:
                del trade.orders[trade.orders.index(order)]
+                trade.open_order_id = None
                self.canceled_entry_orders += 1

            # place new order if result was not None
@ -1094,6 +1095,7 @@ class Backtesting:
                    # 5. Process exit orders.
                    order = trade.select_order(trade.exit_side, is_open=True)
                    if order and self._get_order_filled(order.price, row):
+                        order.close_bt_order(current_time, trade)
                        trade.open_order_id = None
                        trade.close_date = current_time
                        trade.close(order.price, show_msg=False)
@ -1262,13 +1264,14 @@ class Backtesting:
                self.results['strategy_comparison'].extend(results['strategy_comparison'])
            else:
                self.results = results
-
+            dt_appendix = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
            if self.config.get('export', 'none') in ('trades', 'signals'):
-                store_backtest_stats(self.config['exportfilename'], self.results)
+                store_backtest_stats(self.config['exportfilename'], self.results, dt_appendix)

            if (self.config.get('export', 'none') == 'signals' and
                    self.dataprovider.runmode == RunMode.BACKTEST):
-                store_backtest_signal_candles(self.config['exportfilename'], self.processed_dfs)
+                store_backtest_signal_candles(
+                    self.config['exportfilename'], self.processed_dfs, dt_appendix)

        # Results may be mixed up now. Sort them so they follow --strategy-list order.
        if 'strategy_list' in self.config and len(self.results) > 0:
--- a/freqtrade/optimize/hyperopt.py
+++ b/freqtrade/optimize/hyperopt.py
@ -429,7 +429,7 @@ class Hyperopt:
            return new_list
        i = 0
        asked_non_tried: List[List[Any]] = []
-        is_random: List[bool] = []
+        is_random_non_tried: List[bool] = []
        while i < 5 and len(asked_non_tried) < n_points:
            if i < 3:
                self.opt.cache_ = {}
@ -438,9 +438,9 @@ class Hyperopt:
            else:
                asked = unique_list(self.opt.space.rvs(n_samples=n_points * 5))
                is_random = [True for _ in range(len(asked))]
-            is_random += [rand for x, rand in zip(asked, is_random)
-                          if x not in self.opt.Xi
-                          and x not in asked_non_tried]
+            is_random_non_tried += [rand for x, rand in zip(asked, is_random)
+                                    if x not in self.opt.Xi
+                                    and x not in asked_non_tried]
            asked_non_tried += [x for x in asked
                                if x not in self.opt.Xi
                                and x not in asked_non_tried]
@ -449,7 +449,7 @@ class Hyperopt:
        if asked_non_tried:
            return (
                asked_non_tried[:min(len(asked_non_tried), n_points)],
-                is_random[:min(len(asked_non_tried), n_points)]
+                is_random_non_tried[:min(len(asked_non_tried), n_points)]
            )
        else:
            return self.opt.ask(n_points=n_points), [False for _ in range(n_points)]
--- a/freqtrade/optimize/optimize_reports.py
+++ b/freqtrade/optimize/optimize_reports.py
@ -4,7 +4,6 @@ from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Union

-from numpy import int64
 from pandas import DataFrame, to_datetime
 from tabulate import tabulate

@ -18,21 +17,21 @@ from freqtrade.optimize.backtest_caching import get_backtest_metadata_filename
 logger = logging.getLogger(__name__)


-def store_backtest_stats(recordfilename: Path, stats: Dict[str, DataFrame]) -> None:
+def store_backtest_stats(
+        recordfilename: Path, stats: Dict[str, DataFrame], dtappendix: str) -> None:
    """
    Stores backtest results
    :param recordfilename: Path object, which can either be a filename or a directory.
        Filenames will be appended with a timestamp right before the suffix
        while for directories, <directory>/backtest-result-<datetime>.json will be used as filename
    :param stats: Dataframe containing the backtesting statistics
+    :param dtappendix: Datetime to use for the filename
    """
    if recordfilename.is_dir():
-        filename = (recordfilename /
-                    f'backtest-result-{datetime.now().strftime("%Y-%m-%d_%H-%M-%S")}.json')
+        filename = (recordfilename / f'backtest-result-{dtappendix}.json')
    else:
        filename = Path.joinpath(
-            recordfilename.parent,
-            f'{recordfilename.stem}-{datetime.now().strftime("%Y-%m-%d_%H-%M-%S")}'
+            recordfilename.parent, f'{recordfilename.stem}-{dtappendix}'
        ).with_suffix(recordfilename.suffix)

    # Store metadata separately.
@ -45,7 +44,8 @@ def store_backtest_stats(recordfilename: Path, stats: Dict[str, DataFrame]) -> N
    file_dump_json(latest_filename, {'latest_backtest': str(filename.name)})


-def store_backtest_signal_candles(recordfilename: Path, candles: Dict[str, Dict]) -> Path:
+def store_backtest_signal_candles(
+        recordfilename: Path, candles: Dict[str, Dict], dtappendix: str) -> Path:
    """
    Stores backtest trade signal candles
    :param recordfilename: Path object, which can either be a filename or a directory.
@ -53,14 +53,13 @@ def store_backtest_signal_candles(recordfilename: Path, candles: Dict[str, Dict]
        while for directories, <directory>/backtest-result-<datetime>_signals.pkl will be used
        as filename
    :param stats: Dict containing the backtesting signal candles
+    :param dtappendix: Datetime to use for the filename
    """
    if recordfilename.is_dir():
-        filename = (recordfilename /
-                    f'backtest-result-{datetime.now().strftime("%Y-%m-%d_%H-%M-%S")}_signals.pkl')
+        filename = (recordfilename / f'backtest-result-{dtappendix}_signals.pkl')
    else:
        filename = Path.joinpath(
-            recordfilename.parent,
-            f'{recordfilename.stem}-{datetime.now().strftime("%Y-%m-%d_%H-%M-%S")}_signals.pkl'
+            recordfilename.parent, f'{recordfilename.stem}-{dtappendix}_signals.pkl'
        )

    file_dump_joblib(filename, candles)
@ -417,9 +416,6 @@ def generate_strategy_stats(pairlist: List[str],
                    key=lambda x: x['profit_sum']) if len(pair_results) > 1 else None
    worst_pair = min([pair for pair in pair_results if pair['key'] != 'TOTAL'],
                     key=lambda x: x['profit_sum']) if len(pair_results) > 1 else None
-    if not results.empty:
-        results['open_timestamp'] = results['open_date'].view(int64) // 1e6
-        results['close_timestamp'] = results['close_date'].view(int64) // 1e6

    backtest_days = (max_date - min_date).days or 1
    strat_stats = {
--- a/freqtrade/persistence/migrations.py
+++ b/freqtrade/persistence/migrations.py
@ -247,6 +247,35 @@ def set_sqlite_to_wal(engine):
            connection.execute(text("PRAGMA journal_mode=wal"))


+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_%'
+                """
+            )
+        )
+
+
 def check_migrate(engine, decl_base, previous_tables) -> None:
    """
    Checks if migration is necessary and migrates if necessary
@ -288,3 +317,4 @@ def check_migrate(engine, decl_base, previous_tables) -> None:
            "start with a fresh database.")

    set_sqlite_to_wal(engine)
+    fix_old_dry_orders(engine)
--- a/freqtrade/persistence/trade_model.py
+++ b/freqtrade/persistence/trade_model.py
@ -74,7 +74,7 @@ class Order(_DECL_BASE):

    @property
    def safe_filled(self) -> float:
-        return self.filled or self.amount or 0.0
+        return self.filled if self.filled is not None else self.amount or 0.0

    @property
    def safe_fee_base(self) -> float:
@ -137,35 +137,40 @@ class Order(_DECL_BASE):
            'info': {},
        }

-    def to_json(self, entry_side: str) -> Dict[str, Any]:
-        return {
-            'pair': self.ft_pair,
-            'order_id': self.order_id,
-            'status': self.status,
+    def to_json(self, entry_side: str, minified: bool = False) -> Dict[str, Any]:
+        resp = {
            'amount': self.amount,
-            'average': round(self.average, 8) if self.average else 0,
            'safe_price': self.safe_price,
-            'cost': self.cost if self.cost else 0,
-            'filled': self.filled,
            'ft_order_side': self.ft_order_side,
-            'is_open': self.ft_is_open,
-            'order_date': self.order_date.strftime(DATETIME_PRINT_FORMAT)
-            if self.order_date else None,
-            'order_timestamp': int(self.order_date.replace(
-                tzinfo=timezone.utc).timestamp() * 1000) if self.order_date else None,
-            'order_filled_date': self.order_filled_date.strftime(DATETIME_PRINT_FORMAT)
-            if self.order_filled_date else None,
            'order_filled_timestamp': int(self.order_filled_date.replace(
                tzinfo=timezone.utc).timestamp() * 1000) if self.order_filled_date else None,
-            'order_type': self.order_type,
-            'price': self.price,
            'ft_is_entry': self.ft_order_side == entry_side,
-            'remaining': self.remaining,
        }
+        if not minified:
+            resp.update({
+                'pair': self.ft_pair,
+                'order_id': self.order_id,
+                'status': self.status,
+                'average': round(self.average, 8) if self.average else 0,
+                'cost': self.cost if self.cost else 0,
+                'filled': self.filled,
+                'is_open': self.ft_is_open,
+                'order_date': self.order_date.strftime(DATETIME_PRINT_FORMAT)
+                if self.order_date else None,
+                'order_timestamp': int(self.order_date.replace(
+                    tzinfo=timezone.utc).timestamp() * 1000) if self.order_date else None,
+                'order_filled_date': self.order_filled_date.strftime(DATETIME_PRINT_FORMAT)
+                if self.order_filled_date else None,
+                'order_type': self.order_type,
+                'price': self.price,
+                'remaining': self.remaining,
+            })
+        return resp

    def close_bt_order(self, close_date: datetime, trade: 'LocalTrade'):
        self.order_filled_date = close_date
        self.filled = self.amount
+        self.remaining = 0
        self.status = 'closed'
        self.ft_is_open = False
        if (self.ft_order_side == trade.entry_side
@ -393,9 +398,9 @@ class LocalTrade():
            f'open_rate={self.open_rate:.8f}, open_since={open_since})'
        )

-    def to_json(self) -> Dict[str, Any]:
-        filled_orders = self.select_filled_orders()
-        orders = [order.to_json(self.entry_side) for order in filled_orders]
+    def to_json(self, minified: bool = False) -> Dict[str, Any]:
+        filled_orders = self.select_filled_or_open_orders()
+        orders = [order.to_json(self.entry_side, minified) for order in filled_orders]

        return {
            'trade_id': self.id,
@ -823,14 +828,6 @@ class LocalTrade():
        return float(f"{profit_ratio:.8f}")

    def recalc_trade_from_orders(self):
-        # We need at least 2 entry orders for averaging amounts and rates.
-        # TODO: this condition could probably be removed
-        if len(self.select_filled_orders(self.entry_side)) < 2:
-            self.stake_amount = self.amount * self.open_rate / self.leverage
-
-            # Just in case, still recalc open trade value
-            self.recalc_open_trade_value()
-            return

        total_amount = 0.0
        total_stake = 0.0
@ -842,8 +839,6 @@ class LocalTrade():

            tmp_amount = o.safe_amount_after_fee
            tmp_price = o.average or o.price
-            if o.filled is not None:
-                tmp_amount = o.filled
            if tmp_amount > 0.0 and tmp_price is not None:
                total_amount += tmp_amount
                total_stake += tmp_price * tmp_amount
@ -897,6 +892,21 @@ class LocalTrade():
                (o.filled or 0) > 0 and
                o.status in NON_OPEN_EXCHANGE_STATES]

+    def select_filled_or_open_orders(self) -> List['Order']:
+        """
+        Finds filled or open orders
+        :param order_side: Side of the order (either 'buy', 'sell', or None)
+        :return: array of Order objects
+        """
+        return [o for o in self.orders if
+                (
+                    o.ft_is_open is False
+                    and (o.filled or 0) > 0
+                    and o.status in NON_OPEN_EXCHANGE_STATES
+                    )
+                or (o.ft_is_open is True and o.status is not None)
+                ]
+
    @property
    def nr_of_successful_entries(self) -> int:
        """
--- a/freqtrade/rpc/api_server/api_backtest.py
+++ b/freqtrade/rpc/api_server/api_backtest.py
@ -1,6 +1,7 @@
 import asyncio
 import logging
 from copy import deepcopy
+from datetime import datetime
 from typing import Any, Dict, List

 from fastapi import APIRouter, BackgroundTasks, Depends
@ -102,7 +103,10 @@ async def api_start_backtest(bt_settings: BacktestRequest, background_tasks: Bac
                    min_date=min_date, max_date=max_date)

            if btconfig.get('export', 'none') == 'trades':
-                store_backtest_stats(btconfig['exportfilename'], ApiServer._bt.results)
+                store_backtest_stats(
+                    btconfig['exportfilename'], ApiServer._bt.results,
+                    datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+                    )

            logger.info("Backtest finished.")

--- a/freqtrade/rpc/api_server/api_schemas.py
+++ b/freqtrade/rpc/api_server/api_schemas.py
@ -120,6 +120,8 @@ class Stats(BaseModel):
 class DailyRecord(BaseModel):
    date: date
    abs_profit: float
+    rel_profit: float
+    starting_balance: float
    fiat_value: float
    trade_count: int

@ -166,7 +168,7 @@ class ShowConfig(BaseModel):
    trailing_stop_positive: Optional[float]
    trailing_stop_positive_offset: Optional[float]
    trailing_only_offset_is_reached: Optional[bool]
-    unfilledtimeout: UnfilledTimeout
+    unfilledtimeout: Optional[UnfilledTimeout]  # Empty in webserver mode
    order_types: Optional[OrderTypes]
    use_custom_stoploss: Optional[bool]
    timeframe: Optional[str]
--- a/freqtrade/rpc/api_server/api_v1.py
+++ b/freqtrade/rpc/api_server/api_v1.py
@ -36,7 +36,8 @@ logger = logging.getLogger(__name__)
 # versions 2.xx -> futures/short branch
 # 2.14: Add entry/exit orders to trade response
 # 2.15: Add backtest history endpoints
-API_VERSION = 2.15
+# 2.16: Additional daily metrics
+API_VERSION = 2.16

 # Public API, requires no auth.
 router_public = APIRouter()
@ -86,8 +87,8 @@ def stats(rpc: RPC = Depends(get_rpc)):

@router.get('/daily', response_model=Daily, tags=['info'])
 def daily(timescale: int = 7, rpc: RPC = Depends(get_rpc), config=Depends(get_config)):
-    return rpc._rpc_daily_profit(timescale, config['stake_currency'],
-                                 config.get('fiat_display_currency', ''))
+    return rpc._rpc_timeunit_profit(timescale, config['stake_currency'],
+                                    config.get('fiat_display_currency', ''))


@router.get('/status', response_model=List[OpenTradeSchema], tags=['info'])
--- a/freqtrade/rpc/discord.py
+++ b/freqtrade/rpc/discord.py
@ -0,0 +1,59 @@
+import logging
+from typing import Any, Dict
+
+from freqtrade.enums.rpcmessagetype import RPCMessageType
+from freqtrade.rpc import RPC
+from freqtrade.rpc.webhook import Webhook
+
+
+logger = logging.getLogger(__name__)
+
+
+class Discord(Webhook):
+    def __init__(self, rpc: 'RPC', config: Dict[str, Any]):
+        # super().__init__(rpc, config)
+        self.rpc = rpc
+        self.config = config
+        self.strategy = config.get('strategy', '')
+        self.timeframe = config.get('timeframe', '')
+
+        self._url = self.config['discord']['webhook_url']
+        self._format = 'json'
+        self._retries = 1
+        self._retry_delay = 0.1
+
+    def cleanup(self) -> None:
+        """
+        Cleanup pending module resources.
+        This will do nothing for webhooks, they will simply not be called anymore
+        """
+        pass
+
+    def send_msg(self, msg) -> None:
+        logger.info(f"Sending discord message: {msg}")
+
+        if msg['type'].value in self.config['discord']:
+
+            msg['strategy'] = self.strategy
+            msg['timeframe'] = self.timeframe
+            fields = self.config['discord'].get(msg['type'].value)
+            color = 0x0000FF
+            if msg['type'] in (RPCMessageType.EXIT, RPCMessageType.EXIT_FILL):
+                profit_ratio = msg.get('profit_ratio')
+                color = (0x00FF00 if profit_ratio > 0 else 0xFF0000)
+
+            embeds = [{
+                'title': f"Trade: {msg['pair']} {msg['type'].value}",
+                'color': color,
+                'fields': [],
+
+            }]
+            for f in fields:
+                for k, v in f.items():
+                    v = v.format(**msg)
+                    embeds[0]['fields'].append(  # type: ignore
+                        {'name': k, 'value': v, 'inline': True})
+
+            # Send the message to discord channel
+            payload = {'embeds': embeds}
+            self._send_msg(payload)
--- a/freqtrade/rpc/rpc.py
+++ b/freqtrade/rpc/rpc.py
@ -283,33 +283,57 @@ class RPC:
                columns.append('# Entries')
            return trades_list, columns, fiat_profit_sum

-    def _rpc_daily_profit(
+    def _rpc_timeunit_profit(
            self, timescale: int,
-            stake_currency: str, fiat_display_currency: str) -> Dict[str, Any]:
-        today = datetime.now(timezone.utc).date()
-        profit_days: Dict[date, Dict] = {}
+            stake_currency: str, fiat_display_currency: str,
+            timeunit: str = 'days') -> Dict[str, Any]:
+        """
+        :param timeunit: Valid entries are 'days', 'weeks', 'months'
+        """
+        start_date = datetime.now(timezone.utc).date()
+        if timeunit == 'weeks':
+            # weekly
+            start_date = start_date - timedelta(days=start_date.weekday())  # Monday
+        if timeunit == 'months':
+            start_date = start_date.replace(day=1)
+
+        def time_offset(step: int):
+            if timeunit == 'months':
+                return relativedelta(months=step)
+            return timedelta(**{timeunit: step})

        if not (isinstance(timescale, int) and timescale > 0):
            raise RPCException('timescale must be an integer greater than 0')

+        profit_units: Dict[date, Dict] = {}
+        daily_stake = self._freqtrade.wallets.get_total_stake_amount()
+
        for day in range(0, timescale):
-            profitday = today - timedelta(days=day)
-            trades = Trade.get_trades(trade_filter=[
+            profitday = start_date - time_offset(day)
+            # Only query for necessary columns for performance reasons.
+            trades = Trade.query.session.query(Trade.close_profit_abs).filter(
                Trade.is_open.is_(False),
                Trade.close_date >= profitday,
-                Trade.close_date < (profitday + timedelta(days=1))
-            ]).order_by(Trade.close_date).all()
+                Trade.close_date < (profitday + time_offset(1))
+            ).order_by(Trade.close_date).all()
+
            curdayprofit = sum(
                trade.close_profit_abs for trade in trades if trade.close_profit_abs is not None)
-            profit_days[profitday] = {
+            # Calculate this periods starting balance
+            daily_stake = daily_stake - curdayprofit
+            profit_units[profitday] = {
                'amount': curdayprofit,
-                'trades': len(trades)
+                'daily_stake': daily_stake,
+                'rel_profit': round(curdayprofit / daily_stake, 8) if daily_stake > 0 else 0,
+                'trades': len(trades),
            }

        data = [
            {
-                'date': key,
+                'date': f"{key.year}-{key.month:02d}" if timeunit == 'months' else key,
                'abs_profit': value["amount"],
+                'starting_balance': value["daily_stake"],
+                'rel_profit': value["rel_profit"],
                'fiat_value': self._fiat_converter.convert_amount(
                    value['amount'],
                    stake_currency,
@ -317,92 +341,7 @@ class RPC:
                ) if self._fiat_converter else 0,
                'trade_count': value["trades"],
            }
-            for key, value in profit_days.items()
-        ]
-        return {
-            'stake_currency': stake_currency,
-            'fiat_display_currency': fiat_display_currency,
-            'data': data
-        }
-
-    def _rpc_weekly_profit(
-            self, timescale: int,
-            stake_currency: str, fiat_display_currency: str) -> Dict[str, Any]:
-        today = datetime.now(timezone.utc).date()
-        first_iso_day_of_week = today - timedelta(days=today.weekday())  # Monday
-        profit_weeks: Dict[date, Dict] = {}
-
-        if not (isinstance(timescale, int) and timescale > 0):
-            raise RPCException('timescale must be an integer greater than 0')
-
-        for week in range(0, timescale):
-            profitweek = first_iso_day_of_week - timedelta(weeks=week)
-            trades = Trade.get_trades(trade_filter=[
-                Trade.is_open.is_(False),
-                Trade.close_date >= profitweek,
-                Trade.close_date < (profitweek + timedelta(weeks=1))
-            ]).order_by(Trade.close_date).all()
-            curweekprofit = sum(
-                trade.close_profit_abs for trade in trades if trade.close_profit_abs is not None)
-            profit_weeks[profitweek] = {
-                'amount': curweekprofit,
-                'trades': len(trades)
-            }
-
-        data = [
-            {
-                'date': key,
-                'abs_profit': value["amount"],
-                'fiat_value': self._fiat_converter.convert_amount(
-                    value['amount'],
-                    stake_currency,
-                    fiat_display_currency
-                ) if self._fiat_converter else 0,
-                'trade_count': value["trades"],
-            }
-            for key, value in profit_weeks.items()
-        ]
-        return {
-            'stake_currency': stake_currency,
-            'fiat_display_currency': fiat_display_currency,
-            'data': data
-        }
-
-    def _rpc_monthly_profit(
-            self, timescale: int,
-            stake_currency: str, fiat_display_currency: str) -> Dict[str, Any]:
-        first_day_of_month = datetime.now(timezone.utc).date().replace(day=1)
-        profit_months: Dict[date, Dict] = {}
-
-        if not (isinstance(timescale, int) and timescale > 0):
-            raise RPCException('timescale must be an integer greater than 0')
-
-        for month in range(0, timescale):
-            profitmonth = first_day_of_month - relativedelta(months=month)
-            trades = Trade.get_trades(trade_filter=[
-                Trade.is_open.is_(False),
-                Trade.close_date >= profitmonth,
-                Trade.close_date < (profitmonth + relativedelta(months=1))
-            ]).order_by(Trade.close_date).all()
-            curmonthprofit = sum(
-                trade.close_profit_abs for trade in trades if trade.close_profit_abs is not None)
-            profit_months[profitmonth] = {
-                'amount': curmonthprofit,
-                'trades': len(trades)
-            }
-
-        data = [
-            {
-                'date': f"{key.year}-{key.month:02d}",
-                'abs_profit': value["amount"],
-                'fiat_value': self._fiat_converter.convert_amount(
-                    value['amount'],
-                    stake_currency,
-                    fiat_display_currency
-                ) if self._fiat_converter else 0,
-                'trade_count': value["trades"],
-            }
-            for key, value in profit_months.items()
+            for key, value in profit_units.items()
        ]
        return {
            'stake_currency': stake_currency,
--- a/freqtrade/rpc/rpc_manager.py
+++ b/freqtrade/rpc/rpc_manager.py
@ -27,6 +27,12 @@ class RPCManager:
            from freqtrade.rpc.telegram import Telegram
            self.registered_modules.append(Telegram(self._rpc, config))

+        # Enable discord
+        if config.get('discord', {}).get('enabled', False):
+            logger.info('Enabling rpc.discord ...')
+            from freqtrade.rpc.discord import Discord
+            self.registered_modules.append(Discord(self._rpc, config))
+
        # Enable Webhook
        if config.get('webhook', {}).get('enabled', False):
            logger.info('Enabling rpc.webhook ...')
--- a/freqtrade/rpc/telegram.py
+++ b/freqtrade/rpc/telegram.py
@ -6,6 +6,7 @@ This module manage Telegram communication
 import json
 import logging
 import re
+from dataclasses import dataclass
 from datetime import date, datetime, timedelta
 from functools import partial
 from html import escape
@ -37,6 +38,15 @@ logger.debug('Included module rpc.telegram ...')
 MAX_TELEGRAM_MESSAGE_LENGTH = 4096


+@dataclass
+class TimeunitMappings:
+    header: str
+    message: str
+    message2: str
+    callback: str
+    default: int
+
+
 def authorized_only(command_handler: Callable[..., None]) -> Callable[..., Any]:
    """
    Decorator to check if the message comes from the correct chat_id
@ -404,7 +414,7 @@ class Telegram(RPCHandler):
            first_avg = filled_orders[0]["safe_price"]

        for x, order in enumerate(filled_orders):
-            if not order['ft_is_entry']:
+            if not order['ft_is_entry'] or order['is_open'] is True:
                continue
            cur_entry_datetime = arrow.get(order["order_filled_date"])
            cur_entry_amount = order["amount"]
@ -571,6 +581,60 @@ class Telegram(RPCHandler):
        except RPCException as e:
            self._send_msg(str(e))

+    @authorized_only
+    def _timeunit_stats(self, update: Update, context: CallbackContext, unit: str) -> None:
+        """
+        Handler for /daily <n>
+        Returns a daily profit (in BTC) over the last n days.
+        :param bot: telegram bot
+        :param update: message update
+        :return: None
+        """
+
+        vals = {
+            'days': TimeunitMappings('Day', 'Daily', 'days', 'update_daily', 7),
+            'weeks': TimeunitMappings('Monday', 'Weekly', 'weeks (starting from Monday)',
+                                      'update_weekly', 8),
+            'months': TimeunitMappings('Month', 'Monthly', 'months', 'update_monthly', 6),
+        }
+        val = vals[unit]
+
+        stake_cur = self._config['stake_currency']
+        fiat_disp_cur = self._config.get('fiat_display_currency', '')
+        try:
+            timescale = int(context.args[0]) if context.args else val.default
+        except (TypeError, ValueError, IndexError):
+            timescale = val.default
+        try:
+            stats = self._rpc._rpc_timeunit_profit(
+                timescale,
+                stake_cur,
+                fiat_disp_cur,
+                unit
+            )
+            stats_tab = tabulate(
+                [[f"{period['date']} ({period['trade_count']})",
+                  f"{round_coin_value(period['abs_profit'], stats['stake_currency'])}",
+                  f"{period['fiat_value']:.2f} {stats['fiat_display_currency']}",
+                  f"{period['rel_profit']:.2%}",
+                  ] for period in stats['data']],
+                headers=[
+                    f"{val.header} (count)",
+                    f'{stake_cur}',
+                    f'{fiat_disp_cur}',
+                    'Profit %',
+                    'Trades',
+                ],
+                tablefmt='simple')
+            message = (
+                f'<b>{val.message} Profit over the last {timescale} {val.message2}</b>:\n'
+                f'<pre>{stats_tab}</pre>'
+            )
+            self._send_msg(message, parse_mode=ParseMode.HTML, reload_able=True,
+                           callback_path=val.callback, query=update.callback_query)
+        except RPCException as e:
+            self._send_msg(str(e))
+
    @authorized_only
    def _daily(self, update: Update, context: CallbackContext) -> None:
        """
@ -580,35 +644,7 @@ class Telegram(RPCHandler):
        :param update: message update
        :return: None
        """
-        stake_cur = self._config['stake_currency']
-        fiat_disp_cur = self._config.get('fiat_display_currency', '')
-        try:
-            timescale = int(context.args[0]) if context.args else 7
-        except (TypeError, ValueError, IndexError):
-            timescale = 7
-        try:
-            stats = self._rpc._rpc_daily_profit(
-                timescale,
-                stake_cur,
-                fiat_disp_cur
-            )
-            stats_tab = tabulate(
-                [[day['date'],
-                  f"{round_coin_value(day['abs_profit'], stats['stake_currency'])}",
-                  f"{day['fiat_value']:.3f} {stats['fiat_display_currency']}",
-                  f"{day['trade_count']} trades"] for day in stats['data']],
-                headers=[
-                    'Day',
-                    f'Profit {stake_cur}',
-                    f'Profit {fiat_disp_cur}',
-                    'Trades',
-                ],
-                tablefmt='simple')
-            message = f'<b>Daily Profit over the last {timescale} days</b>:\n<pre>{stats_tab}</pre>'
-            self._send_msg(message, parse_mode=ParseMode.HTML, reload_able=True,
-                           callback_path="update_daily", query=update.callback_query)
-        except RPCException as e:
-            self._send_msg(str(e))
+        self._timeunit_stats(update, context, 'days')

    @authorized_only
    def _weekly(self, update: Update, context: CallbackContext) -> None:
@ -619,36 +655,7 @@ class Telegram(RPCHandler):
        :param update: message update
        :return: None
        """
-        stake_cur = self._config['stake_currency']
-        fiat_disp_cur = self._config.get('fiat_display_currency', '')
-        try:
-            timescale = int(context.args[0]) if context.args else 8
-        except (TypeError, ValueError, IndexError):
-            timescale = 8
-        try:
-            stats = self._rpc._rpc_weekly_profit(
-                timescale,
-                stake_cur,
-                fiat_disp_cur
-            )
-            stats_tab = tabulate(
-                [[week['date'],
-                  f"{round_coin_value(week['abs_profit'], stats['stake_currency'])}",
-                  f"{week['fiat_value']:.3f} {stats['fiat_display_currency']}",
-                  f"{week['trade_count']} trades"] for week in stats['data']],
-                headers=[
-                    'Monday',
-                    f'Profit {stake_cur}',
-                    f'Profit {fiat_disp_cur}',
-                    'Trades',
-                ],
-                tablefmt='simple')
-            message = f'<b>Weekly Profit over the last {timescale} weeks ' \
-                      f'(starting from Monday)</b>:\n<pre>{stats_tab}</pre> '
-            self._send_msg(message, parse_mode=ParseMode.HTML, reload_able=True,
-                           callback_path="update_weekly", query=update.callback_query)
-        except RPCException as e:
-            self._send_msg(str(e))
+        self._timeunit_stats(update, context, 'weeks')

    @authorized_only
    def _monthly(self, update: Update, context: CallbackContext) -> None:
@ -659,36 +666,7 @@ class Telegram(RPCHandler):
        :param update: message update
        :return: None
        """
-        stake_cur = self._config['stake_currency']
-        fiat_disp_cur = self._config.get('fiat_display_currency', '')
-        try:
-            timescale = int(context.args[0]) if context.args else 6
-        except (TypeError, ValueError, IndexError):
-            timescale = 6
-        try:
-            stats = self._rpc._rpc_monthly_profit(
-                timescale,
-                stake_cur,
-                fiat_disp_cur
-            )
-            stats_tab = tabulate(
-                [[month['date'],
-                  f"{round_coin_value(month['abs_profit'], stats['stake_currency'])}",
-                  f"{month['fiat_value']:.3f} {stats['fiat_display_currency']}",
-                  f"{month['trade_count']} trades"] for month in stats['data']],
-                headers=[
-                    'Month',
-                    f'Profit {stake_cur}',
-                    f'Profit {fiat_disp_cur}',
-                    'Trades',
-                ],
-                tablefmt='simple')
-            message = f'<b>Monthly Profit over the last {timescale} months' \
-                      f'</b>:\n<pre>{stats_tab}</pre> '
-            self._send_msg(message, parse_mode=ParseMode.HTML, reload_able=True,
-                           callback_path="update_monthly", query=update.callback_query)
-        except RPCException as e:
-            self._send_msg(str(e))
+        self._timeunit_stats(update, context, 'months')

    @authorized_only
    def _profit(self, update: Update, context: CallbackContext) -> None:
--- a/freqtrade/strategy/interface.py
+++ b/freqtrade/strategy/interface.py
@ -289,6 +289,7 @@ class IStrategy(ABC, HyperStrategyMixin):
        :param order_type: Order type (as configured in order_types). usually limit or market.
        :param amount: Amount in target (base) currency that's going to be traded.
        :param rate: Rate that's going to be used when using limit orders
+                     or current rate for market orders.
        :param time_in_force: Time in force. Defaults to GTC (Good-til-cancelled).
        :param current_time: datetime object, containing the current datetime
        :param entry_tag: Optional entry_tag (buy_tag) if provided with the buy signal.
@ -316,6 +317,7 @@ class IStrategy(ABC, HyperStrategyMixin):
        :param order_type: Order type (as configured in order_types). usually limit or market.
        :param amount: Amount in base currency.
        :param rate: Rate that's going to be used when using limit orders
+                     or current rate for market orders.
        :param time_in_force: Time in force. Defaults to GTC (Good-til-cancelled).
        :param exit_reason: Exit reason.
            Can be any of ['roi', 'stop_loss', 'stoploss_on_exchange', 'trailing_stop_loss',
@ -509,8 +511,8 @@ class IStrategy(ABC, HyperStrategyMixin):
        return current_order_rate

    def leverage(self, pair: str, current_time: datetime, current_rate: float,
-                 proposed_leverage: float, max_leverage: float, side: str,
-                 **kwargs) -> float:
+                 proposed_leverage: float, max_leverage: float, entry_tag: Optional[str],
+                 side: str, **kwargs) -> float:
        """
        Customize leverage for each new trade. This method is only called in futures mode.

@ -519,6 +521,7 @@ class IStrategy(ABC, HyperStrategyMixin):
        :param current_rate: Rate, calculated based on pricing settings in exit_pricing.
        :param proposed_leverage: A leverage proposed by the bot.
        :param max_leverage: Max leverage allowed on this pair
+        :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 leverage amount, which is between 1.0 and max_leverage.
        """
--- a/freqtrade/templates/subtemplates/strategy_methods_advanced.j2
+++ b/freqtrade/templates/subtemplates/strategy_methods_advanced.j2
@ -161,6 +161,7 @@ def confirm_trade_entry(self, pair: str, order_type: str, amount: float, rate: f
    :param order_type: Order type (as configured in order_types). usually limit or market.
    :param amount: Amount in target (base) currency that's going to be traded.
    :param rate: Rate that's going to be used when using limit orders
+                 or current rate for market orders.
    :param time_in_force: Time in force. Defaults to GTC (Good-til-cancelled).
    :param current_time: datetime object, containing the current datetime
    :param entry_tag: Optional entry_tag (buy_tag) if provided with the buy signal.
@ -188,6 +189,7 @@ def confirm_trade_exit(self, pair: str, trade: 'Trade', order_type: str, amount:
    :param order_type: Order type (as configured in order_types). usually limit or market.
    :param amount: Amount in base currency.
    :param rate: Rate that's going to be used when using limit orders
+                 or current rate for market orders.
    :param time_in_force: Time in force. Defaults to GTC (Good-til-cancelled).
    :param exit_reason: Exit reason.
        Can be any of ['roi', 'stop_loss', 'stoploss_on_exchange', 'trailing_stop_loss',
@ -267,8 +269,8 @@ def adjust_trade_position(self, trade: 'Trade', current_time: 'datetime',
    return None

 def leverage(self, pair: str, current_time: datetime, current_rate: float,
-                proposed_leverage: float, max_leverage: float, side: str,
-                **kwargs) -> float:
+             proposed_leverage: float, max_leverage: float, entry_tag: Optional[str],
+             side: str, **kwargs) -> float:
    """
    Customize leverage for each new trade. This method is only called in futures mode.

@ -277,6 +279,7 @@ def leverage(self, pair: str, current_time: datetime, current_rate: float,
    :param current_rate: Rate, calculated based on pricing settings in exit_pricing.
    :param proposed_leverage: A leverage proposed by the bot.
    :param max_leverage: Max leverage allowed on this pair
+    :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 leverage amount, which is between 1.0 and max_leverage.
    """
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@ -7,7 +7,7 @@
 coveralls==3.3.1
 flake8==4.0.1
 flake8-tidy-imports==4.8.0
-mypy==0.960
+mypy==0.961
 pre-commit==2.19.0
 pytest==7.1.2
 pytest-asyncio==0.18.3
@ -23,7 +23,7 @@ nbconvert==6.5.0

 # mypy types
 types-cachetools==5.0.1
-types-filelock==3.2.6
-types-requests==2.27.29
+types-filelock==3.2.7
+types-requests==2.27.30
 types-tabulate==0.8.9
 types-python-dateutil==2.8.17
--- a/requirements-hyperopt.txt
+++ b/requirements-hyperopt.txt
@ -5,5 +5,5 @@
 scipy==1.8.1
 scikit-learn==1.1.1
 scikit-optimize==0.9.0
-filelock==3.7.0
+filelock==3.7.1
 progressbar2==4.0.0
--- 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.0
+plotly==5.8.2
--- a/requirements.txt
+++ b/requirements.txt
@ -2,17 +2,17 @@ numpy==1.22.4
 pandas==1.4.2
 pandas-ta==0.3.14b

-ccxt==1.84.39
+ccxt==1.87.12
 # Pin cryptography for now due to rust build errors with piwheels
 cryptography==37.0.2
 aiohttp==3.8.1
-SQLAlchemy==1.4.36
+SQLAlchemy==1.4.37
 python-telegram-bot==13.12
 arrow==1.2.2
 cachetools==4.2.2
-requests==2.27.1
+requests==2.28.0
 urllib3==1.26.9
-jsonschema==4.5.1
+jsonschema==4.6.0
 TA-Lib==0.4.24
 technical==1.3.0
 tabulate==0.8.9
@ -28,7 +28,7 @@ py_find_1st==1.1.5
 # Load ticker files 30% faster
 python-rapidjson==1.6
 # Properly format api responses
-orjson==3.6.8
+orjson==3.7.2

 # Notify systemd
 sdnotify==0.3.2
--- a/scripts/rest_client.py
+++ b/scripts/rest_client.py
@ -261,7 +261,7 @@ class FtRestClient():
                }
        return self._post("forcebuy", data=data)

-    def force_enter(self, pair, side, price=None):
+    def forceenter(self, pair, side, price=None):
        """Force entering a trade

        :param pair: Pair to buy (ETH/BTC)
@ -273,7 +273,7 @@ class FtRestClient():
                "side": side,
                "price": price,
                }
-        return self._post("force_enter", data=data)
+        return self._post("forceenter", data=data)

    def forceexit(self, tradeid):
        """Force-exit a trade.
--- a/setup.sh
+++ b/setup.sh
@ -87,6 +87,10 @@ function updateenv() {
        echo "Failed installing Freqtrade"
        exit 1
    fi
+
+    echo "Installing freqUI"
+    freqtrade install-ui
+
    echo "pip install completed"
    echo
    if [[ $dev =~ ^[Yy]$ ]]; then
--- a/tests/conftest.py
+++ b/tests/conftest.py
@ -325,7 +325,7 @@ def create_mock_trades_with_leverage(fee, use_db: bool = True):
        Trade.query.session.flush()


-def create_mock_trades_usdt(fee, use_db: bool = True):
+def create_mock_trades_usdt(fee, is_short: Optional[bool] = False, use_db: bool = True):
    """
    Create some fake trades ...
    """
@ -335,26 +335,29 @@ def create_mock_trades_usdt(fee, use_db: bool = True):
        else:
            LocalTrade.add_bt_trade(trade)

+    is_short1 = is_short if is_short is not None else True
+    is_short2 = is_short if is_short is not None else False
+
    # Simulate dry_run entries
-    trade = mock_trade_usdt_1(fee)
+    trade = mock_trade_usdt_1(fee, is_short1)
    add_trade(trade)

-    trade = mock_trade_usdt_2(fee)
+    trade = mock_trade_usdt_2(fee, is_short1)
    add_trade(trade)

-    trade = mock_trade_usdt_3(fee)
+    trade = mock_trade_usdt_3(fee, is_short1)
    add_trade(trade)

-    trade = mock_trade_usdt_4(fee)
+    trade = mock_trade_usdt_4(fee, is_short2)
    add_trade(trade)

-    trade = mock_trade_usdt_5(fee)
+    trade = mock_trade_usdt_5(fee, is_short2)
    add_trade(trade)

-    trade = mock_trade_usdt_6(fee)
+    trade = mock_trade_usdt_6(fee, is_short1)
    add_trade(trade)

-    trade = mock_trade_usdt_7(fee)
+    trade = mock_trade_usdt_7(fee, is_short1)
    add_trade(trade)
    if use_db:
        Trade.commit()
--- a/tests/conftest_trades_usdt.py
+++ b/tests/conftest_trades_usdt.py
@ -6,47 +6,84 @@ from freqtrade.persistence.models import Order, Trade
 MOCK_TRADE_COUNT = 6


-def mock_order_usdt_1():
+def entry_side(is_short: bool):
+    return "sell" if is_short else "buy"
+
+
+def exit_side(is_short: bool):
+    return "buy" if is_short else "sell"
+
+
+def direc(is_short: bool):
+    return "short" if is_short else "long"
+
+
+def mock_order_usdt_1(is_short: bool):
    return {
-        'id': '1234',
-        'symbol': 'ADA/USDT',
+        'id': f'prod_entry_1_{direc(is_short)}',
+        'symbol': 'LTC/USDT',
        'status': 'closed',
-        'side': 'buy',
+        'side': entry_side(is_short),
        'type': 'limit',
-        'price': 2.0,
-        'amount': 10.0,
-        'filled': 10.0,
+        'price': 10.0,
+        'amount': 2.0,
+        'filled': 2.0,
        'remaining': 0.0,
    }


-def mock_trade_usdt_1(fee):
+def mock_order_usdt_1_exit(is_short: bool):
+    return {
+        'id': f'prod_exit_1_{direc(is_short)}',
+        'symbol': 'LTC/USDT',
+        'status': 'closed',
+        'side': exit_side(is_short),
+        'type': 'limit',
+        'price': 8.0,
+        'amount': 2.0,
+        'filled': 2.0,
+        'remaining': 0.0,
+    }
+
+
+def mock_trade_usdt_1(fee, is_short: bool):
+    """
+    Simulate prod entry with open sell order
+    """
    trade = Trade(
-        pair='ADA/USDT',
+        pair='LTC/USDT',
        stake_amount=20.0,
-        amount=10.0,
-        amount_requested=10.0,
+        amount=2.0,
+        amount_requested=2.0,
+        open_date=datetime.now(tz=timezone.utc) - timedelta(days=2, minutes=20),
+        close_date=datetime.now(tz=timezone.utc) - timedelta(days=2, minutes=5),
        fee_open=fee.return_value,
        fee_close=fee.return_value,
-        is_open=True,
-        open_date=datetime.now(tz=timezone.utc) - timedelta(minutes=17),
-        open_rate=2.0,
+        is_open=False,
+        open_rate=10.0,
+        close_rate=8.0,
+        close_profit=-0.2,
+        close_profit_abs=-4.0,
        exchange='binance',
-        open_order_id='dry_run_buy_12345',
-        strategy='StrategyTestV2',
+        strategy='SampleStrategy',
+        open_order_id=f'prod_exit_1_{direc(is_short)}',
        timeframe=5,
+        is_short=is_short,
    )
-    o = Order.parse_from_ccxt_object(mock_order_usdt_1(), 'ADA/USDT', 'buy')
+    o = Order.parse_from_ccxt_object(mock_order_usdt_1(is_short), 'LTC/USDT', entry_side(is_short))
+    trade.orders.append(o)
+    o = Order.parse_from_ccxt_object(mock_order_usdt_1_exit(is_short),
+                                     'LTC/USDT', exit_side(is_short))
    trade.orders.append(o)
    return trade


-def mock_order_usdt_2():
+def mock_order_usdt_2(is_short: bool):
    return {
-        'id': '1235',
+        'id': f'1235_{direc(is_short)}',
        'symbol': 'ETC/USDT',
        'status': 'closed',
-        'side': 'buy',
+        'side': entry_side(is_short),
        'type': 'limit',
        'price': 2.0,
        'amount': 100.0,
@ -55,12 +92,12 @@ def mock_order_usdt_2():
    }


-def mock_order_usdt_2_sell():
+def mock_order_usdt_2_exit(is_short: bool):
    return {
-        'id': '12366',
+        'id': f'12366_{direc(is_short)}',
        'symbol': 'ETC/USDT',
        'status': 'closed',
-        'side': 'sell',
+        'side': exit_side(is_short),
        'type': 'limit',
        'price': 2.05,
        'amount': 100.0,
@ -69,7 +106,7 @@ def mock_order_usdt_2_sell():
    }


-def mock_trade_usdt_2(fee):
+def mock_trade_usdt_2(fee, is_short: bool):
    """
    Closed trade...
    """
@ -82,30 +119,33 @@ def mock_trade_usdt_2(fee):
        fee_close=fee.return_value,
        open_rate=2.0,
        close_rate=2.05,
-        close_profit=5.0,
+        close_profit=0.05,
        close_profit_abs=3.9875,
        exchange='binance',
        is_open=False,
-        open_order_id='dry_run_sell_12345',
+        open_order_id=f'12366_{direc(is_short)}',
        strategy='StrategyTestV2',
        timeframe=5,
-        exit_reason='sell_signal',
+        enter_tag='TEST1',
+        exit_reason='exit_signal',
        open_date=datetime.now(tz=timezone.utc) - timedelta(minutes=20),
        close_date=datetime.now(tz=timezone.utc) - timedelta(minutes=2),
+        is_short=is_short,
    )
-    o = Order.parse_from_ccxt_object(mock_order_usdt_2(), 'ETC/USDT', 'buy')
+    o = Order.parse_from_ccxt_object(mock_order_usdt_2(is_short), 'ETC/USDT', entry_side(is_short))
    trade.orders.append(o)
-    o = Order.parse_from_ccxt_object(mock_order_usdt_2_sell(), 'ETC/USDT', 'sell')
+    o = Order.parse_from_ccxt_object(
+        mock_order_usdt_2_exit(is_short), 'ETC/USDT', exit_side(is_short))
    trade.orders.append(o)
    return trade


-def mock_order_usdt_3():
+def mock_order_usdt_3(is_short: bool):
    return {
-        'id': '41231a12a',
+        'id': f'41231a12a_{direc(is_short)}',
        'symbol': 'XRP/USDT',
        'status': 'closed',
-        'side': 'buy',
+        'side': entry_side(is_short),
        'type': 'limit',
        'price': 1.0,
        'amount': 30.0,
@ -114,12 +154,12 @@ def mock_order_usdt_3():
    }


-def mock_order_usdt_3_sell():
+def mock_order_usdt_3_exit(is_short: bool):
    return {
-        'id': '41231a666a',
+        'id': f'41231a666a_{direc(is_short)}',
        'symbol': 'XRP/USDT',
        'status': 'closed',
-        'side': 'sell',
+        'side': exit_side(is_short),
        'type': 'stop_loss_limit',
        'price': 1.1,
        'average': 1.1,
@ -129,7 +169,7 @@ def mock_order_usdt_3_sell():
    }


-def mock_trade_usdt_3(fee):
+def mock_trade_usdt_3(fee, is_short: bool):
    """
    Closed trade
    """
@ -142,29 +182,32 @@ def mock_trade_usdt_3(fee):
        fee_close=fee.return_value,
        open_rate=1.0,
        close_rate=1.1,
-        close_profit=10.0,
+        close_profit=0.1,
        close_profit_abs=9.8425,
        exchange='binance',
        is_open=False,
        strategy='StrategyTestV2',
        timeframe=5,
+        enter_tag='TEST3',
        exit_reason='roi',
        open_date=datetime.now(tz=timezone.utc) - timedelta(minutes=20),
        close_date=datetime.now(tz=timezone.utc),
+        is_short=is_short,
    )
-    o = Order.parse_from_ccxt_object(mock_order_usdt_3(), 'XRP/USDT', 'buy')
+    o = Order.parse_from_ccxt_object(mock_order_usdt_3(is_short), 'XRP/USDT', entry_side(is_short))
    trade.orders.append(o)
-    o = Order.parse_from_ccxt_object(mock_order_usdt_3_sell(), 'XRP/USDT', 'sell')
+    o = Order.parse_from_ccxt_object(mock_order_usdt_3_exit(is_short),
+                                     'XRP/USDT', exit_side(is_short))
    trade.orders.append(o)
    return trade


-def mock_order_usdt_4():
+def mock_order_usdt_4(is_short: bool):
    return {
-        'id': 'prod_buy_12345',
+        'id': f'prod_buy_12345_{direc(is_short)}',
        'symbol': 'ETC/USDT',
        'status': 'open',
-        'side': 'buy',
+        'side': entry_side(is_short),
        'type': 'limit',
        'price': 2.0,
        'amount': 10.0,
@ -173,7 +216,7 @@ def mock_order_usdt_4():
    }


-def mock_trade_usdt_4(fee):
+def mock_trade_usdt_4(fee, is_short: bool):
    """
    Simulate prod entry
    """
@ -188,21 +231,22 @@ def mock_trade_usdt_4(fee):
        is_open=True,
        open_rate=2.0,
        exchange='binance',
-        open_order_id='prod_buy_12345',
+        open_order_id=f'prod_buy_12345_{direc(is_short)}',
        strategy='StrategyTestV2',
        timeframe=5,
+        is_short=is_short,
    )
-    o = Order.parse_from_ccxt_object(mock_order_usdt_4(), 'ETC/USDT', 'buy')
+    o = Order.parse_from_ccxt_object(mock_order_usdt_4(is_short), 'ETC/USDT', entry_side(is_short))
    trade.orders.append(o)
    return trade


-def mock_order_usdt_5():
+def mock_order_usdt_5(is_short: bool):
    return {
-        'id': 'prod_buy_3455',
+        'id': f'prod_buy_3455_{direc(is_short)}',
        'symbol': 'XRP/USDT',
        'status': 'closed',
-        'side': 'buy',
+        'side': entry_side(is_short),
        'type': 'limit',
        'price': 2.0,
        'amount': 10.0,
@ -211,12 +255,12 @@ def mock_order_usdt_5():
    }


-def mock_order_usdt_5_stoploss():
+def mock_order_usdt_5_stoploss(is_short: bool):
    return {
-        'id': 'prod_stoploss_3455',
+        'id': f'prod_stoploss_3455_{direc(is_short)}',
        'symbol': 'XRP/USDT',
        'status': 'open',
-        'side': 'sell',
+        'side': exit_side(is_short),
        'type': 'stop_loss_limit',
        'price': 2.0,
        'amount': 10.0,
@ -225,7 +269,7 @@ def mock_order_usdt_5_stoploss():
    }


-def mock_trade_usdt_5(fee):
+def mock_trade_usdt_5(fee, is_short: bool):
    """
    Simulate prod entry with stoploss
    """
@ -241,22 +285,23 @@ def mock_trade_usdt_5(fee):
        open_rate=2.0,
        exchange='binance',
        strategy='SampleStrategy',
-        stoploss_order_id='prod_stoploss_3455',
+        stoploss_order_id=f'prod_stoploss_3455_{direc(is_short)}',
        timeframe=5,
+        is_short=is_short,
    )
-    o = Order.parse_from_ccxt_object(mock_order_usdt_5(), 'XRP/USDT', 'buy')
+    o = Order.parse_from_ccxt_object(mock_order_usdt_5(is_short), 'XRP/USDT', entry_side(is_short))
    trade.orders.append(o)
-    o = Order.parse_from_ccxt_object(mock_order_usdt_5_stoploss(), 'XRP/USDT', 'stoploss')
+    o = Order.parse_from_ccxt_object(mock_order_usdt_5_stoploss(is_short), 'XRP/USDT', 'stoploss')
    trade.orders.append(o)
    return trade


-def mock_order_usdt_6():
+def mock_order_usdt_6(is_short: bool):
    return {
-        'id': 'prod_buy_6',
+        'id': f'prod_entry_6_{direc(is_short)}',
        'symbol': 'LTC/USDT',
        'status': 'closed',
-        'side': 'buy',
+        'side': entry_side(is_short),
        'type': 'limit',
        'price': 10.0,
        'amount': 2.0,
@ -265,12 +310,12 @@ def mock_order_usdt_6():
    }


-def mock_order_usdt_6_sell():
+def mock_order_usdt_6_exit(is_short: bool):
    return {
-        'id': 'prod_sell_6',
+        'id': f'prod_exit_6_{direc(is_short)}',
        'symbol': 'LTC/USDT',
        'status': 'open',
-        'side': 'sell',
+        'side': exit_side(is_short),
        'type': 'limit',
        'price': 12.0,
        'amount': 2.0,
@ -279,7 +324,7 @@ def mock_order_usdt_6_sell():
    }


-def mock_trade_usdt_6(fee):
+def mock_trade_usdt_6(fee, is_short: bool):
    """
    Simulate prod entry with open sell order
    """
@ -295,69 +340,49 @@ def mock_trade_usdt_6(fee):
        open_rate=10.0,
        exchange='binance',
        strategy='SampleStrategy',
-        open_order_id="prod_sell_6",
+        open_order_id=f'prod_exit_6_{direc(is_short)}',
        timeframe=5,
+        is_short=is_short,
    )
-    o = Order.parse_from_ccxt_object(mock_order_usdt_6(), 'LTC/USDT', 'buy')
+    o = Order.parse_from_ccxt_object(mock_order_usdt_6(is_short), 'LTC/USDT', entry_side(is_short))
    trade.orders.append(o)
-    o = Order.parse_from_ccxt_object(mock_order_usdt_6_sell(), 'LTC/USDT', 'sell')
+    o = Order.parse_from_ccxt_object(mock_order_usdt_6_exit(is_short),
+                                     'LTC/USDT', exit_side(is_short))
    trade.orders.append(o)
    return trade


-def mock_order_usdt_7():
+def mock_order_usdt_7(is_short: bool):
    return {
-        'id': 'prod_buy_7',
-        'symbol': 'LTC/USDT',
+        'id': f'1234_{direc(is_short)}',
+        'symbol': 'ADA/USDT',
        'status': 'closed',
-        'side': 'buy',
+        'side': entry_side(is_short),
        'type': 'limit',
-        'price': 10.0,
-        'amount': 2.0,
-        'filled': 2.0,
+        'price': 2.0,
+        'amount': 10.0,
+        'filled': 10.0,
        'remaining': 0.0,
    }


-def mock_order_usdt_7_sell():
-    return {
-        'id': 'prod_sell_7',
-        'symbol': 'LTC/USDT',
-        'status': 'closed',
-        'side': 'sell',
-        'type': 'limit',
-        'price': 8.0,
-        'amount': 2.0,
-        'filled': 2.0,
-        'remaining': 0.0,
-    }
-
-
-def mock_trade_usdt_7(fee):
-    """
-    Simulate prod entry with open sell order
-    """
+def mock_trade_usdt_7(fee, is_short: bool):
    trade = Trade(
-        pair='LTC/USDT',
+        pair='ADA/USDT',
        stake_amount=20.0,
-        amount=2.0,
-        amount_requested=2.0,
-        open_date=datetime.now(tz=timezone.utc) - timedelta(minutes=20),
-        close_date=datetime.now(tz=timezone.utc) - timedelta(minutes=5),
+        amount=10.0,
+        amount_requested=10.0,
        fee_open=fee.return_value,
        fee_close=fee.return_value,
-        is_open=False,
-        open_rate=10.0,
-        close_rate=8.0,
-        close_profit=-0.2,
-        close_profit_abs=-4.0,
+        is_open=True,
+        open_date=datetime.now(tz=timezone.utc) - timedelta(minutes=17),
+        open_rate=2.0,
        exchange='binance',
-        strategy='SampleStrategy',
-        open_order_id="prod_sell_6",
+        open_order_id=f'1234_{direc(is_short)}',
+        strategy='StrategyTestV2',
        timeframe=5,
+        is_short=is_short,
    )
-    o = Order.parse_from_ccxt_object(mock_order_usdt_7(), 'LTC/USDT', 'buy')
-    trade.orders.append(o)
-    o = Order.parse_from_ccxt_object(mock_order_usdt_7_sell(), 'LTC/USDT', 'sell')
+    o = Order.parse_from_ccxt_object(mock_order_usdt_7(is_short), 'ADA/USDT', entry_side(is_short))
    trade.orders.append(o)
    return trade
--- a/tests/data/test_btanalysis.py
+++ b/tests/data/test_btanalysis.py
@ -85,7 +85,7 @@ def test_load_backtest_data_new_format(testdatadir):
    filename = testdatadir / "backtest_results/backtest-result_new.json"
    bt_data = load_backtest_data(filename)
    assert isinstance(bt_data, DataFrame)
-    assert set(bt_data.columns) == set(BT_DATA_COLUMNS + ['close_timestamp', 'open_timestamp'])
+    assert set(bt_data.columns) == set(BT_DATA_COLUMNS)
    assert len(bt_data) == 179

    # Test loading from string (must yield same result)
@ -110,7 +110,7 @@ def test_load_backtest_data_multi(testdatadir):
        bt_data = load_backtest_data(filename, strategy=strategy)
        assert isinstance(bt_data, DataFrame)
        assert set(bt_data.columns) == set(
-            BT_DATA_COLUMNS + ['close_timestamp', 'open_timestamp'])
+            BT_DATA_COLUMNS)
        assert len(bt_data) == 179

        # Test loading from string (must yield same result)
--- a/tests/data/test_entryexitanalysis.py
+++ b/tests/data/test_entryexitanalysis.py
@ -0,0 +1,191 @@
+import logging
+from unittest.mock import MagicMock, PropertyMock
+
+import pandas as pd
+import pytest
+
+from freqtrade.commands.analyze_commands import start_analysis_entries_exits
+from freqtrade.commands.optimize_commands import start_backtesting
+from freqtrade.enums import ExitType
+from freqtrade.optimize.backtesting import Backtesting
+from tests.conftest import get_args, patch_exchange, patched_configuration_load_config_file
+
+
+@pytest.fixture(autouse=True)
+def entryexitanalysis_cleanup() -> None:
+    yield None
+
+    Backtesting.cleanup()
+
+
+def test_backtest_analysis_nomock(default_conf, mocker, caplog, testdatadir, tmpdir, capsys):
+    caplog.set_level(logging.INFO)
+
+    default_conf.update({
+        "use_exit_signal": True,
+        "exit_profit_only": False,
+        "exit_profit_offset": 0.0,
+        "ignore_roi_if_entry_signal": False,
+    })
+    patch_exchange(mocker)
+    result1 = pd.DataFrame({'pair': ['ETH/BTC', 'LTC/BTC', 'ETH/BTC', 'LTC/BTC'],
+                            'profit_ratio': [0.025, 0.05, -0.1, -0.05],
+                            'profit_abs': [0.5, 2.0, -4.0, -2.0],
+                            'open_date': pd.to_datetime(['2018-01-29 18:40:00',
+                                                         '2018-01-30 03:30:00',
+                                                         '2018-01-30 08:10:00',
+                                                         '2018-01-31 13:30:00', ], utc=True
+                                                        ),
+                            'close_date': pd.to_datetime(['2018-01-29 20:45:00',
+                                                          '2018-01-30 05:35:00',
+                                                          '2018-01-30 09:10:00',
+                                                          '2018-01-31 15:00:00', ], utc=True),
+                            'trade_duration': [235, 40, 60, 90],
+                            'is_open': [False, False, False, False],
+                            'stake_amount': [0.01, 0.01, 0.01, 0.01],
+                            'open_rate': [0.104445, 0.10302485, 0.10302485, 0.10302485],
+                            'close_rate': [0.104969, 0.103541, 0.102041, 0.102541],
+                            "is_short": [False, False, False, False],
+                            'enter_tag': ["enter_tag_long_a",
+                                          "enter_tag_long_b",
+                                          "enter_tag_long_a",
+                                          "enter_tag_long_b"],
+                            'exit_reason': [ExitType.ROI,
+                                            ExitType.EXIT_SIGNAL,
+                                            ExitType.STOP_LOSS,
+                                            ExitType.TRAILING_STOP_LOSS]
+                            })
+
+    backtestmock = MagicMock(side_effect=[
+        {
+            'results': result1,
+            'config': default_conf,
+            'locks': [],
+            'rejected_signals': 20,
+            'timedout_entry_orders': 0,
+            'timedout_exit_orders': 0,
+            'canceled_trade_entries': 0,
+            'canceled_entry_orders': 0,
+            'replaced_entry_orders': 0,
+            'final_balance': 1000,
+        }
+    ])
+    mocker.patch('freqtrade.plugins.pairlistmanager.PairListManager.whitelist',
+                 PropertyMock(return_value=['ETH/BTC', 'LTC/BTC', 'DASH/BTC']))
+    mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest', backtestmock)
+
+    patched_configuration_load_config_file(mocker, default_conf)
+
+    args = [
+        'backtesting',
+        '--config', 'config.json',
+        '--datadir', str(testdatadir),
+        '--user-data-dir', str(tmpdir),
+        '--timeframe', '5m',
+        '--timerange', '1515560100-1517287800',
+        '--export', 'signals',
+        '--cache', 'none',
+    ]
+    args = get_args(args)
+    start_backtesting(args)
+
+    captured = capsys.readouterr()
+    assert 'BACKTESTING REPORT' in captured.out
+    assert 'EXIT REASON STATS' in captured.out
+    assert 'LEFT OPEN TRADES REPORT' in captured.out
+
+    base_args = [
+        'backtesting-analysis',
+        '--config', 'config.json',
+        '--datadir', str(testdatadir),
+        '--user-data-dir', str(tmpdir),
+    ]
+
+    # test group 0 and indicator list
+    args = get_args(base_args +
+                    ['--analysis-groups', "0",
+                     '--indicator-list', "close", "rsi", "profit_abs"]
+                    )
+    start_analysis_entries_exits(args)
+    captured = capsys.readouterr()
+    assert 'LTC/BTC' in captured.out
+    assert 'ETH/BTC' in captured.out
+    assert 'enter_tag_long_a' in captured.out
+    assert 'enter_tag_long_b' in captured.out
+    assert 'exit_signal' in captured.out
+    assert 'roi' in captured.out
+    assert 'stop_loss' in captured.out
+    assert 'trailing_stop_loss' in captured.out
+    assert '0.5' in captured.out
+    assert '-4' in captured.out
+    assert '-2' in captured.out
+    assert '-3.5' in captured.out
+    assert '50' in captured.out
+    assert '0' in captured.out
+    assert '0.01616' in captured.out
+    assert '34.049' in captured.out
+    assert '0.104104' in captured.out
+    assert '47.0996' in captured.out
+
+    # test group 1
+    args = get_args(base_args + ['--analysis-groups', "1"])
+    start_analysis_entries_exits(args)
+    captured = capsys.readouterr()
+    assert 'enter_tag_long_a' in captured.out
+    assert 'enter_tag_long_b' in captured.out
+    assert 'total_profit_pct' in captured.out
+    assert '-3.5' in captured.out
+    assert '-1.75' in captured.out
+    assert '-7.5' in captured.out
+    assert '-3.75' in captured.out
+    assert '0' in captured.out
+
+    # test group 2
+    args = get_args(base_args + ['--analysis-groups', "2"])
+    start_analysis_entries_exits(args)
+    captured = capsys.readouterr()
+    assert 'enter_tag_long_a' in captured.out
+    assert 'enter_tag_long_b' in captured.out
+    assert 'exit_signal' in captured.out
+    assert 'roi' in captured.out
+    assert 'stop_loss' in captured.out
+    assert 'trailing_stop_loss' in captured.out
+    assert 'total_profit_pct' in captured.out
+    assert '-10' in captured.out
+    assert '-5' in captured.out
+    assert '2.5' in captured.out
+
+    # test group 3
+    args = get_args(base_args + ['--analysis-groups', "3"])
+    start_analysis_entries_exits(args)
+    captured = capsys.readouterr()
+    assert 'LTC/BTC' in captured.out
+    assert 'ETH/BTC' in captured.out
+    assert 'enter_tag_long_a' in captured.out
+    assert 'enter_tag_long_b' in captured.out
+    assert 'total_profit_pct' in captured.out
+    assert '-7.5' in captured.out
+    assert '-3.75' in captured.out
+    assert '-1.75' in captured.out
+    assert '0' in captured.out
+    assert '2' in captured.out
+
+    # test group 4
+    args = get_args(base_args + ['--analysis-groups', "4"])
+    start_analysis_entries_exits(args)
+    captured = capsys.readouterr()
+    assert 'LTC/BTC' in captured.out
+    assert 'ETH/BTC' in captured.out
+    assert 'enter_tag_long_a' in captured.out
+    assert 'enter_tag_long_b' in captured.out
+    assert 'exit_signal' in captured.out
+    assert 'roi' in captured.out
+    assert 'stop_loss' in captured.out
+    assert 'trailing_stop_loss' in captured.out
+    assert 'total_profit_pct' in captured.out
+    assert '-10' in captured.out
+    assert '-5' in captured.out
+    assert '-4' in captured.out
+    assert '0.5' in captured.out
+    assert '1' in captured.out
+    assert '2.5' in captured.out
--- a/tests/optimize/test_backtesting.py
+++ b/tests/optimize/test_backtesting.py
@ -795,10 +795,27 @@ def test_backtest_one(default_conf, fee, mocker, testdatadir) -> None:
         'is_open': [False, False],
         'enter_tag': [None, None],
         "is_short": [False, False],
+         'open_timestamp': [1517251200000, 1517283000000],
+         'close_timestamp': [1517265300000, 1517285400000],
+         'orders': [
+            [
+                {'amount': 0.00957442, 'safe_price': 0.104445, 'ft_order_side': 'buy',
+                 'order_filled_timestamp': 1517251200000, 'ft_is_entry': True},
+                {'amount': 0.00957442, 'safe_price': 0.10496853383458644, 'ft_order_side': 'sell',
+                 'order_filled_timestamp': 1517265300000, 'ft_is_entry': False}
+            ], [
+                {'amount': 0.0097064, 'safe_price': 0.10302485, 'ft_order_side': 'buy',
+                 'order_filled_timestamp': 1517283000000, 'ft_is_entry': True},
+                {'amount': 0.0097064, 'safe_price': 0.10354126528822055, 'ft_order_side': 'sell',
+                 'order_filled_timestamp': 1517285400000, 'ft_is_entry': False}
+            ]
+         ]
         })
    pd.testing.assert_frame_equal(results, expected)
+    assert 'orders' in results.columns
    data_pair = processed[pair]
    for _, t in results.iterrows():
+        assert len(t['orders']) == 2
        ln = data_pair.loc[data_pair["date"] == t["open_date"]]
        # Check open trade rate alignes to open rate
        assert ln is not None
--- a/tests/optimize/test_backtesting_adjust_position.py
+++ b/tests/optimize/test_backtesting_adjust_position.py
@ -70,9 +70,14 @@ def test_backtest_position_adjustment(default_conf, fee, mocker, testdatadir) ->
         'is_open': [False, False],
         'enter_tag': [None, None],
         'is_short': [False, False],
+         'open_timestamp': [1517251200000, 1517283000000],
+         'close_timestamp': [1517265300000, 1517285400000],
         })
-    pd.testing.assert_frame_equal(results, expected)
+    pd.testing.assert_frame_equal(results.drop(columns=['orders']), expected)
    data_pair = processed[pair]
+    assert len(results.iloc[0]['orders']) == 6
+    assert len(results.iloc[1]['orders']) == 2
+
    for _, t in results.iterrows():
        ln = data_pair.loc[data_pair["date"] == t["open_date"]]
        # Check open trade rate alignes to open rate
--- a/tests/optimize/test_optimize_reports.py
+++ b/tests/optimize/test_optimize_reports.py
@ -171,7 +171,7 @@ def test_generate_backtest_stats(default_conf, testdatadir, tmpdir):
    _backup_file(filename_last, copy_file=True)
    assert not filename.is_file()

-    store_backtest_stats(filename, stats)
+    store_backtest_stats(filename, stats, '2022_01_01_15_05_13')

    # get real Filename (it's btresult-<date>.json)
    last_fn = get_latest_backtest_filename(filename_last.parent)
@ -194,7 +194,7 @@ def test_store_backtest_stats(testdatadir, mocker):

    dump_mock = mocker.patch('freqtrade.optimize.optimize_reports.file_dump_json')

-    store_backtest_stats(testdatadir, {'metadata': {}})
+    store_backtest_stats(testdatadir, {'metadata': {}}, '2022_01_01_15_05_13')

    assert dump_mock.call_count == 3
    assert isinstance(dump_mock.call_args_list[0][0][0], Path)
@ -202,7 +202,7 @@ def test_store_backtest_stats(testdatadir, mocker):

    dump_mock.reset_mock()
    filename = testdatadir / 'testresult.json'
-    store_backtest_stats(filename, {'metadata': {}})
+    store_backtest_stats(filename, {'metadata': {}}, '2022_01_01_15_05_13')
    assert dump_mock.call_count == 3
    assert isinstance(dump_mock.call_args_list[0][0][0], Path)
    # result will be testdatadir / testresult-<timestamp>.json
@ -216,7 +216,7 @@ def test_store_backtest_candles(testdatadir, mocker):
    candle_dict = {'DefStrat': {'UNITTEST/BTC': pd.DataFrame()}}

    # mock directory exporting
-    store_backtest_signal_candles(testdatadir, candle_dict)
+    store_backtest_signal_candles(testdatadir, candle_dict, '2022_01_01_15_05_13')

    assert dump_mock.call_count == 1
    assert isinstance(dump_mock.call_args_list[0][0][0], Path)
@ -225,7 +225,7 @@ def test_store_backtest_candles(testdatadir, mocker):
    dump_mock.reset_mock()
    # mock file exporting
    filename = Path(testdatadir / 'testresult')
-    store_backtest_signal_candles(filename, candle_dict)
+    store_backtest_signal_candles(filename, candle_dict, '2022_01_01_15_05_13')
    assert dump_mock.call_count == 1
    assert isinstance(dump_mock.call_args_list[0][0][0], Path)
    # result will be testdatadir / testresult-<timestamp>_signals.pkl
@ -238,7 +238,7 @@ def test_write_read_backtest_candles(tmpdir):
    candle_dict = {'DefStrat': {'UNITTEST/BTC': pd.DataFrame()}}

    # test directory exporting
-    stored_file = store_backtest_signal_candles(Path(tmpdir), candle_dict)
+    stored_file = store_backtest_signal_candles(Path(tmpdir), candle_dict, '2022_01_01_15_05_13')
    scp = open(stored_file, "rb")
    pickled_signal_candles = joblib.load(scp)
    scp.close()
@ -252,7 +252,7 @@ def test_write_read_backtest_candles(tmpdir):

    # test file exporting
    filename = Path(tmpdir / 'testresult')
-    stored_file = store_backtest_signal_candles(filename, candle_dict)
+    stored_file = store_backtest_signal_candles(filename, candle_dict, '2022_01_01_15_05_13')
    scp = open(stored_file, "rb")
    pickled_signal_candles = joblib.load(scp)
    scp.close()
--- a/tests/plugins/test_pairlist.py
+++ b/tests/plugins/test_pairlist.py
@ -762,8 +762,8 @@ def test_PerformanceFilter_keep_mid_order(mocker, default_conf_usdt, fee, caplog
    with time_machine.travel("2021-09-01 05:00:00 +00:00") as t:
        create_mock_trades_usdt(fee)
        pm.refresh_pairlist()
-        assert pm.whitelist == ['XRP/USDT', 'ETC/USDT', 'ETH/USDT',
-                                'NEO/USDT', 'TKN/USDT', 'ADA/USDT', 'LTC/USDT']
+        assert pm.whitelist == ['XRP/USDT', 'ETC/USDT', 'ETH/USDT', 'LTC/USDT',
+                                'NEO/USDT', 'TKN/USDT', 'ADA/USDT', ]
        # assert log_has_re(r'Removing pair .* since .* is below .*', caplog)

        # Move to "outside" of lookback window, so original sorting is restored.
--- a/tests/rpc/test_rpc.py
+++ b/tests/rpc/test_rpc.py
@ -11,11 +11,11 @@ from freqtrade.edge import PairInfo
 from freqtrade.enums import SignalDirection, State, TradingMode
 from freqtrade.exceptions import ExchangeError, InvalidOrderException, TemporaryError
 from freqtrade.persistence import Trade
-from freqtrade.persistence.models import Order
 from freqtrade.persistence.pairlock_middleware import PairLocks
 from freqtrade.rpc import RPC, RPCException
 from freqtrade.rpc.fiat_convert import CryptoToFiatConverter
-from tests.conftest import create_mock_trades, get_patched_freqtradebot, patch_get_signal
+from tests.conftest import (create_mock_trades, create_mock_trades_usdt, get_patched_freqtradebot,
+                            patch_get_signal)


 # Functions for recurrent object patching
@ -284,8 +284,8 @@ def test_rpc_status_table(default_conf, ticker, fee, mocker) -> None:
    assert isnan(fiat_profit_sum)


-def test_rpc_daily_profit(default_conf, update, ticker, fee,
-                          limit_buy_order, limit_sell_order, markets, mocker) -> None:
+def test__rpc_timeunit_profit(default_conf_usdt, ticker, fee,
+                              limit_buy_order, limit_sell_order, markets, mocker) -> None:
    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
@ -294,45 +294,35 @@ def test_rpc_daily_profit(default_conf, update, ticker, fee,
        markets=PropertyMock(return_value=markets)
    )

-    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
-    patch_get_signal(freqtradebot)
-    stake_currency = default_conf['stake_currency']
-    fiat_display_currency = default_conf['fiat_display_currency']
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf_usdt)
+    create_mock_trades_usdt(fee)
+
+    stake_currency = default_conf_usdt['stake_currency']
+    fiat_display_currency = default_conf_usdt['fiat_display_currency']

    rpc = RPC(freqtradebot)
    rpc._fiat_converter = CryptoToFiatConverter()
-    # Create some test data
-    freqtradebot.enter_positions()
-    trade = Trade.query.first()
-    assert trade
-
-    # Simulate buy & sell
-    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
-    trade.update_trade(oobj)
-    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
-    trade.update_trade(oobj)
-    trade.close_date = datetime.utcnow()
-    trade.is_open = False

    # Try valid data
-    update.message.text = '/daily 2'
-    days = rpc._rpc_daily_profit(7, stake_currency, fiat_display_currency)
+    days = rpc._rpc_timeunit_profit(7, stake_currency, fiat_display_currency)
    assert len(days['data']) == 7
-    assert days['stake_currency'] == default_conf['stake_currency']
-    assert days['fiat_display_currency'] == default_conf['fiat_display_currency']
+    assert days['stake_currency'] == default_conf_usdt['stake_currency']
+    assert days['fiat_display_currency'] == default_conf_usdt['fiat_display_currency']
    for day in days['data']:
-        # [datetime.date(2018, 1, 11), '0.00000000 BTC', '0.000 USD']
-        assert (day['abs_profit'] == 0.0 or
-                day['abs_profit'] == 0.00006217)
-
-        assert (day['fiat_value'] == 0.0 or
-                day['fiat_value'] == 0.76748865)
+        # {'date': datetime.date(2022, 6, 11), 'abs_profit': 13.8299999,
+        #  'starting_balance': 1055.37, 'rel_profit': 0.0131044,
+        #  'fiat_value': 0.0, 'trade_count': 2}
+        assert day['abs_profit'] in (0.0, pytest.approx(13.8299999), pytest.approx(-4.0))
+        assert day['rel_profit'] in (0.0, pytest.approx(0.01310441), pytest.approx(-0.00377583))
+        assert day['trade_count'] in (0, 1, 2)
+        assert day['starting_balance'] in (pytest.approx(1059.37), pytest.approx(1055.37))
+        assert day['fiat_value'] in (0.0, )
    # ensure first day is current date
    assert str(days['data'][0]['date']) == str(datetime.utcnow().date())

    # Try invalid data
    with pytest.raises(RPCException, match=r'.*must be an integer greater than 0*'):
-        rpc._rpc_daily_profit(0, stake_currency, fiat_display_currency)
+        rpc._rpc_timeunit_profit(0, stake_currency, fiat_display_currency)


@pytest.mark.parametrize('is_short', [True, False])
@ -416,13 +406,8 @@ def test_rpc_delete_trade(mocker, default_conf, fee, markets, caplog, is_short):
    assert stoploss_mock.call_count == 0


-def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
-                              limit_buy_order, limit_sell_order, mocker) -> None:
-    mocker.patch.multiple(
-        'freqtrade.rpc.fiat_convert.CoinGeckoAPI',
-        get_price=MagicMock(return_value={'bitcoin': {'usd': 15000.0}}),
-    )
-    mocker.patch('freqtrade.rpc.rpc.CryptoToFiatConverter._find_price', return_value=15000.0)
+def test_rpc_trade_statistics(default_conf_usdt, ticker, fee, mocker) -> None:
+    mocker.patch('freqtrade.rpc.rpc.CryptoToFiatConverter._find_price', return_value=1.1)
    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
@ -430,10 +415,9 @@ def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
        get_fee=fee,
    )

-    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
-    patch_get_signal(freqtradebot)
-    stake_currency = default_conf['stake_currency']
-    fiat_display_currency = default_conf['fiat_display_currency']
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf_usdt)
+    stake_currency = default_conf_usdt['stake_currency']
+    fiat_display_currency = default_conf_usdt['fiat_display_currency']

    rpc = RPC(freqtradebot)
    rpc._fiat_converter = CryptoToFiatConverter()
@ -446,75 +430,40 @@ def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
    assert res['latest_trade_timestamp'] == 0

    # Create some test data
-    freqtradebot.enter_positions()
-    trade = Trade.query.first()
-    # Simulate fulfilled LIMIT_BUY order for trade
-    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'sell')
-    trade.update_trade(oobj)
-
-    # Update the ticker with a market going up
-    mocker.patch.multiple(
-        'freqtrade.exchange.Exchange',
-        fetch_ticker=ticker_sell_up
-    )
-    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
-    trade.update_trade(oobj)
-    trade.close_date = datetime.utcnow()
-    trade.is_open = False
-
-    freqtradebot.enter_positions()
-    trade = Trade.query.first()
-    # Simulate fulfilled LIMIT_BUY order for trade
-    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
-    trade.update_trade(oobj)
-
-    # Update the ticker with a market going up
-    mocker.patch.multiple(
-        'freqtrade.exchange.Exchange',
-        fetch_ticker=ticker_sell_up
-    )
-    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
-    trade.update_trade(oobj)
-    trade.close_date = datetime.utcnow()
-    trade.is_open = False
+    create_mock_trades_usdt(fee)

    stats = rpc._rpc_trade_statistics(stake_currency, fiat_display_currency)
-    assert prec_satoshi(stats['profit_closed_coin'], 6.217e-05)
-    assert prec_satoshi(stats['profit_closed_percent_mean'], 6.2)
-    assert prec_satoshi(stats['profit_closed_fiat'], 0.93255)
-    assert prec_satoshi(stats['profit_all_coin'], 5.802e-05)
-    assert prec_satoshi(stats['profit_all_percent_mean'], 2.89)
-    assert prec_satoshi(stats['profit_all_fiat'], 0.8703)
-    assert stats['trade_count'] == 2
-    assert stats['first_trade_date'] == 'just now'
-    assert stats['latest_trade_date'] == 'just now'
-    assert stats['avg_duration'] in ('0:00:00', '0:00:01', '0:00:02')
-    assert stats['best_pair'] == 'ETH/BTC'
-    assert prec_satoshi(stats['best_rate'], 6.2)
+    assert pytest.approx(stats['profit_closed_coin']) == 9.83
+    assert pytest.approx(stats['profit_closed_percent_mean']) == -1.67
+    assert pytest.approx(stats['profit_closed_fiat']) == 10.813
+    assert pytest.approx(stats['profit_all_coin']) == -77.45964918
+    assert pytest.approx(stats['profit_all_percent_mean']) == -57.86
+    assert pytest.approx(stats['profit_all_fiat']) == -85.205614098
+    assert stats['trade_count'] == 7
+    assert stats['first_trade_date'] == '2 days ago'
+    assert stats['latest_trade_date'] == '17 minutes ago'
+    assert stats['avg_duration'] in ('0:17:40')
+    assert stats['best_pair'] == 'XRP/USDT'
+    assert stats['best_rate'] == 10.0

    # Test non-available pair
    mocker.patch('freqtrade.exchange.Exchange.get_rate',
-                 MagicMock(side_effect=ExchangeError("Pair 'ETH/BTC' not available")))
+                 MagicMock(side_effect=ExchangeError("Pair 'XRP/USDT' not available")))
    stats = rpc._rpc_trade_statistics(stake_currency, fiat_display_currency)
-    assert stats['trade_count'] == 2
-    assert stats['first_trade_date'] == 'just now'
-    assert stats['latest_trade_date'] == 'just now'
-    assert stats['avg_duration'] in ('0:00:00', '0:00:01', '0:00:02')
-    assert stats['best_pair'] == 'ETH/BTC'
-    assert prec_satoshi(stats['best_rate'], 6.2)
+    assert stats['trade_count'] == 7
+    assert stats['first_trade_date'] == '2 days ago'
+    assert stats['latest_trade_date'] == '17 minutes ago'
+    assert stats['avg_duration'] in ('0:17:40')
+    assert stats['best_pair'] == 'XRP/USDT'
+    assert stats['best_rate'] == 10.0
    assert isnan(stats['profit_all_coin'])


 # Test that rpc_trade_statistics can handle trades that lacks
 # trade.open_rate (it is set to None)
-def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, fee,
-                                     ticker_sell_up, limit_buy_order, limit_sell_order):
-    mocker.patch.multiple(
-        'freqtrade.rpc.fiat_convert.CoinGeckoAPI',
-        get_price=MagicMock(return_value={'bitcoin': {'usd': 15000.0}}),
-    )
+def test_rpc_trade_statistics_closed(mocker, default_conf_usdt, ticker, fee):
    mocker.patch('freqtrade.rpc.fiat_convert.CryptoToFiatConverter._find_price',
-                 return_value=15000.0)
+                 return_value=1.1)
    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
@ -522,46 +471,32 @@ def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, fee,
        get_fee=fee,
    )

-    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf_usdt)
    patch_get_signal(freqtradebot)
-    stake_currency = default_conf['stake_currency']
-    fiat_display_currency = default_conf['fiat_display_currency']
+    stake_currency = default_conf_usdt['stake_currency']
+    fiat_display_currency = default_conf_usdt['fiat_display_currency']

    rpc = RPC(freqtradebot)

    # Create some test data
-    freqtradebot.enter_positions()
-    trade = Trade.query.first()
-    # Simulate fulfilled LIMIT_BUY order for trade
-    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
-    trade.update_trade(oobj)
-    # Update the ticker with a market going up
-    mocker.patch.multiple(
-        'freqtrade.exchange.Exchange',
-        fetch_ticker=ticker_sell_up,
-        get_fee=fee
-    )
-    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
-    trade.update_trade(oobj)
-    trade.close_date = datetime.utcnow()
-    trade.is_open = False
+    create_mock_trades_usdt(fee)

    for trade in Trade.query.order_by(Trade.id).all():
        trade.open_rate = None

    stats = rpc._rpc_trade_statistics(stake_currency, fiat_display_currency)
-    assert prec_satoshi(stats['profit_closed_coin'], 0)
-    assert prec_satoshi(stats['profit_closed_percent_mean'], 0)
-    assert prec_satoshi(stats['profit_closed_fiat'], 0)
-    assert prec_satoshi(stats['profit_all_coin'], 0)
-    assert prec_satoshi(stats['profit_all_percent_mean'], 0)
-    assert prec_satoshi(stats['profit_all_fiat'], 0)
-    assert stats['trade_count'] == 1
-    assert stats['first_trade_date'] == 'just now'
-    assert stats['latest_trade_date'] == 'just now'
+    assert stats['profit_closed_coin'] == 0
+    assert stats['profit_closed_percent_mean'] == 0
+    assert stats['profit_closed_fiat'] == 0
+    assert stats['profit_all_coin'] == 0
+    assert stats['profit_all_percent_mean'] == 0
+    assert stats['profit_all_fiat'] == 0
+    assert stats['trade_count'] == 7
+    assert stats['first_trade_date'] == '2 days ago'
+    assert stats['latest_trade_date'] == '17 minutes ago'
    assert stats['avg_duration'] == '0:00:00'
-    assert stats['best_pair'] == 'ETH/BTC'
-    assert prec_satoshi(stats['best_rate'], 6.2)
+    assert stats['best_pair'] == 'XRP/USDT'
+    assert stats['best_rate'] == 10.0


 def test_rpc_balance_handle_error(default_conf, mocker):
@ -913,8 +848,7 @@ def test_rpc_force_exit(default_conf, ticker, fee, mocker) -> None:
    assert cancel_order_mock.call_count == 3


-def test_performance_handle(default_conf, ticker, limit_buy_order, fee,
-                            limit_sell_order, mocker) -> None:
+def test_performance_handle(default_conf_usdt, ticker, fee, mocker) -> None:
    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
@ -923,34 +857,21 @@ def test_performance_handle(default_conf, ticker, limit_buy_order, fee,
        get_fee=fee,
    )

-    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf_usdt)
    patch_get_signal(freqtradebot)
    rpc = RPC(freqtradebot)
-
    # Create some test data
-    freqtradebot.enter_positions()
-    trade = Trade.query.first()
-    assert trade
+    create_mock_trades_usdt(fee)

-    # Simulate fulfilled LIMIT_BUY order for trade
-    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
-    trade.update_trade(oobj)
-
-    # Simulate fulfilled LIMIT_SELL order for trade
-    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
-    trade.update_trade(oobj)
-
-    trade.close_date = datetime.utcnow()
-    trade.is_open = False
    res = rpc._rpc_performance()
-    assert len(res) == 1
-    assert res[0]['pair'] == 'ETH/BTC'
+    assert len(res) == 3
+    assert res[0]['pair'] == 'XRP/USDT'
    assert res[0]['count'] == 1
-    assert prec_satoshi(res[0]['profit_pct'], 6.2)
+    assert res[0]['profit_pct'] == 10.0


-def test_enter_tag_performance_handle(default_conf, ticker, limit_buy_order, fee,
-                                      limit_sell_order, mocker) -> None:
+def test_enter_tag_performance_handle(default_conf, ticker, fee, mocker) -> None:
+
    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
@ -964,34 +885,22 @@ def test_enter_tag_performance_handle(default_conf, ticker, limit_buy_order, fee
    rpc = RPC(freqtradebot)

    # Create some test data
+    create_mock_trades_usdt(fee)
    freqtradebot.enter_positions()
-    trade = Trade.query.first()
-    assert trade

-    # Simulate fulfilled LIMIT_BUY order for trade
-    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
-    trade.update_trade(oobj)
-
-    # Simulate fulfilled LIMIT_SELL order for trade
-    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
-    trade.update_trade(oobj)
-
-    trade.close_date = datetime.utcnow()
-    trade.is_open = False
    res = rpc._rpc_enter_tag_performance(None)

-    assert len(res) == 1
-    assert res[0]['enter_tag'] == 'Other'
+    assert len(res) == 3
+    assert res[0]['enter_tag'] == 'TEST3'
    assert res[0]['count'] == 1
-    assert prec_satoshi(res[0]['profit_pct'], 6.2)
+    assert res[0]['profit_pct'] == 10.0

-    trade.enter_tag = "TEST_TAG"
    res = rpc._rpc_enter_tag_performance(None)

-    assert len(res) == 1
-    assert res[0]['enter_tag'] == 'TEST_TAG'
+    assert len(res) == 3
+    assert res[0]['enter_tag'] == 'TEST3'
    assert res[0]['count'] == 1
-    assert prec_satoshi(res[0]['profit_pct'], 6.2)
+    assert res[0]['profit_pct'] == 10.0


 def test_enter_tag_performance_handle_2(mocker, default_conf, markets, fee):
@ -1023,8 +932,7 @@ def test_enter_tag_performance_handle_2(mocker, default_conf, markets, fee):
    assert prec_satoshi(res[0]['profit_pct'], 0.5)


-def test_exit_reason_performance_handle(default_conf, ticker, limit_buy_order, fee,
-                                        limit_sell_order, mocker) -> None:
+def test_exit_reason_performance_handle(default_conf_usdt, ticker, fee, mocker) -> None:
    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
@ -1033,39 +941,22 @@ def test_exit_reason_performance_handle(default_conf, ticker, limit_buy_order, f
        get_fee=fee,
    )

-    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf_usdt)
    patch_get_signal(freqtradebot)
    rpc = RPC(freqtradebot)

    # Create some test data
-    freqtradebot.enter_positions()
-    trade = Trade.query.first()
-    assert trade
+    create_mock_trades_usdt(fee)

-    # Simulate fulfilled LIMIT_BUY order for trade
-    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
-    trade.update_trade(oobj)
-
-    # Simulate fulfilled LIMIT_SELL order for trade
-    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
-    trade.update_trade(oobj)
-
-    trade.close_date = datetime.utcnow()
-    trade.is_open = False
    res = rpc._rpc_exit_reason_performance(None)

-    assert len(res) == 1
-    assert res[0]['exit_reason'] == 'Other'
+    assert len(res) == 3
+    assert res[0]['exit_reason'] == 'roi'
    assert res[0]['count'] == 1
-    assert prec_satoshi(res[0]['profit_pct'], 6.2)
+    assert res[0]['profit_pct'] == 10.0

-    trade.exit_reason = "TEST1"
-    res = rpc._rpc_exit_reason_performance(None)
-
-    assert len(res) == 1
-    assert res[0]['exit_reason'] == 'TEST1'
-    assert res[0]['count'] == 1
-    assert prec_satoshi(res[0]['profit_pct'], 6.2)
+    assert res[1]['exit_reason'] == 'exit_signal'
+    assert res[2]['exit_reason'] == 'Other'


 def test_exit_reason_performance_handle_2(mocker, default_conf, markets, fee):
@ -1097,8 +988,7 @@ def test_exit_reason_performance_handle_2(mocker, default_conf, markets, fee):
    assert prec_satoshi(res[0]['profit_pct'], 0.5)


-def test_mix_tag_performance_handle(default_conf, ticker, limit_buy_order, fee,
-                                    limit_sell_order, mocker) -> None:
+def test_mix_tag_performance_handle(default_conf, ticker, fee, mocker) -> None:
    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
@ -1112,35 +1002,14 @@ def test_mix_tag_performance_handle(default_conf, ticker, limit_buy_order, fee,
    rpc = RPC(freqtradebot)

    # Create some test data
-    freqtradebot.enter_positions()
-    trade = Trade.query.first()
-    assert trade
+    create_mock_trades_usdt(fee)

-    # Simulate fulfilled LIMIT_BUY order for trade
-    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
-    trade.update_trade(oobj)
-
-    # Simulate fulfilled LIMIT_SELL order for trade
-    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
-    trade.update_trade(oobj)
-
-    trade.close_date = datetime.utcnow()
-    trade.is_open = False
    res = rpc._rpc_mix_tag_performance(None)

-    assert len(res) == 1
-    assert res[0]['mix_tag'] == 'Other Other'
+    assert len(res) == 3
+    assert res[0]['mix_tag'] == 'TEST3 roi'
    assert res[0]['count'] == 1
-    assert prec_satoshi(res[0]['profit_pct'], 6.2)
-
-    trade.enter_tag = "TESTBUY"
-    trade.exit_reason = "TESTSELL"
-    res = rpc._rpc_mix_tag_performance(None)
-
-    assert len(res) == 1
-    assert res[0]['mix_tag'] == 'TESTBUY TESTSELL'
-    assert res[0]['count'] == 1
-    assert prec_satoshi(res[0]['profit_pct'], 6.2)
+    assert res[0]['profit_pct'] == 10.0


 def test_mix_tag_performance_handle_2(mocker, default_conf, markets, fee):
--- a/tests/rpc/test_rpc_apiserver.py
+++ b/tests/rpc/test_rpc_apiserver.py
@ -1384,12 +1384,14 @@ def test_api_strategies(botclient):
    rc = client_get(client, f"{BASE_URI}/strategies")

    assert_response(rc)
+
    assert rc.json() == {'strategies': [
        'HyperoptableStrategy',
        'InformativeDecoratorTest',
        'StrategyTestV2',
        'StrategyTestV3',
-        'StrategyTestV3Futures',
+        'StrategyTestV3Analysis',
+        'StrategyTestV3Futures'
    ]}


--- a/tests/rpc/test_rpc_telegram.py
+++ b/tests/rpc/test_rpc_telegram.py
@ -27,8 +27,9 @@ from freqtrade.persistence.models import Order
 from freqtrade.rpc import RPC
 from freqtrade.rpc.rpc import RPCException
 from freqtrade.rpc.telegram import Telegram, authorized_only
-from tests.conftest import (CURRENT_TEST_STRATEGY, create_mock_trades, get_patched_freqtradebot,
-                            log_has, log_has_re, patch_exchange, patch_get_signal, patch_whitelist)
+from tests.conftest import (CURRENT_TEST_STRATEGY, create_mock_trades, create_mock_trades_usdt,
+                            get_patched_freqtradebot, log_has, log_has_re, patch_exchange,
+                            patch_get_signal, patch_whitelist)


 class DummyCls(Telegram):
@ -404,12 +405,10 @@ def test_status_table_handle(default_conf, update, ticker, fee, mocker) -> None:
    assert msg_mock.call_count == 1


-def test_daily_handle(default_conf, update, ticker, limit_buy_order, fee,
-                      limit_sell_order, mocker) -> None:
-    default_conf['max_open_trades'] = 1
+def test_daily_handle(default_conf_usdt, update, ticker, fee, mocker, time_machine) -> None:
    mocker.patch(
        'freqtrade.rpc.rpc.CryptoToFiatConverter._find_price',
-        return_value=15000.0
+        return_value=1.1
    )
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
@ -417,25 +416,12 @@ def test_daily_handle(default_conf, update, ticker, limit_buy_order, fee,
        get_fee=fee,
    )

-    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
-
-    patch_get_signal(freqtradebot)
+    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf_usdt)

+    # Move date to within day
+    time_machine.move_to('2022-06-11 08:00:00+00:00')
    # Create some test data
-    freqtradebot.enter_positions()
-    trade = Trade.query.first()
-    assert trade
-
-    # Simulate fulfilled LIMIT_BUY order for trade
-    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
-    trade.update_trade(oobj)
-
-    # Simulate fulfilled LIMIT_SELL order for trade
-    oobjs = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
-    trade.update_trade(oobjs)
-
-    trade.close_date = datetime.utcnow()
-    trade.is_open = False
+    create_mock_trades_usdt(fee)

    # Try valid data
    # /daily 2
@ -446,10 +432,11 @@ def test_daily_handle(default_conf, update, ticker, limit_buy_order, fee,
    assert "Daily Profit over the last 2 days</b>:" in msg_mock.call_args_list[0][0][0]
    assert 'Day ' in msg_mock.call_args_list[0][0][0]
    assert str(datetime.utcnow().date()) in msg_mock.call_args_list[0][0][0]
-    assert str('  0.00006217 BTC') in msg_mock.call_args_list[0][0][0]
-    assert str('  0.933 USD') in msg_mock.call_args_list[0][0][0]
-    assert str('  1 trade') in msg_mock.call_args_list[0][0][0]
-    assert str('  0 trade') in msg_mock.call_args_list[0][0][0]
+    assert '  13.83 USDT' in msg_mock.call_args_list[0][0][0]
+    assert '  15.21 USD' in msg_mock.call_args_list[0][0][0]
+    assert '(2)' in msg_mock.call_args_list[0][0][0]
+    assert '(2)  13.83 USDT  15.21 USD  1.31%' in msg_mock.call_args_list[0][0][0]
+    assert '(0)' in msg_mock.call_args_list[0][0][0]

    # Reset msg_mock
    msg_mock.reset_mock()
@ -458,32 +445,23 @@ def test_daily_handle(default_conf, update, ticker, limit_buy_order, fee,
    assert msg_mock.call_count == 1
    assert "Daily Profit over the last 7 days</b>:" in msg_mock.call_args_list[0][0][0]
    assert str(datetime.utcnow().date()) in msg_mock.call_args_list[0][0][0]
-    assert str('  0.00006217 BTC') in msg_mock.call_args_list[0][0][0]
-    assert str('  0.933 USD') in msg_mock.call_args_list[0][0][0]
-    assert str('  1 trade') in msg_mock.call_args_list[0][0][0]
-    assert str('  0 trade') in msg_mock.call_args_list[0][0][0]
+    assert str((datetime.utcnow() - timedelta(days=5)).date()) in msg_mock.call_args_list[0][0][0]
+    assert '  13.83 USDT' in msg_mock.call_args_list[0][0][0]
+    assert '  15.21 USD' in msg_mock.call_args_list[0][0][0]
+    assert '(2)' in msg_mock.call_args_list[0][0][0]
+    assert '(1)' in msg_mock.call_args_list[0][0][0]
+    assert '(0)' in msg_mock.call_args_list[0][0][0]

    # Reset msg_mock
    msg_mock.reset_mock()
-    freqtradebot.config['max_open_trades'] = 2
-    # Add two other trades
-    n = freqtradebot.enter_positions()
-    assert n == 2
-
-    trades = Trade.query.all()
-    for trade in trades:
-        trade.update_trade(oobj)
-        trade.update_trade(oobjs)
-        trade.close_date = datetime.utcnow()
-        trade.is_open = False

    # /daily 1
    context = MagicMock()
    context.args = ["1"]
    telegram._daily(update=update, context=context)
-    assert str('  0.00018651 BTC') in msg_mock.call_args_list[0][0][0]
-    assert str('  2.798 USD') in msg_mock.call_args_list[0][0][0]
-    assert str('  3 trades') in msg_mock.call_args_list[0][0][0]
+    assert '  13.83 USDT' in msg_mock.call_args_list[0][0][0]
+    assert '  15.21 USD' in msg_mock.call_args_list[0][0][0]
+    assert '(2)' in msg_mock.call_args_list[0][0][0]


 def test_daily_wrong_input(default_conf, update, ticker, mocker) -> None:
@ -512,15 +490,14 @@ def test_daily_wrong_input(default_conf, update, ticker, mocker) -> None:
    context = MagicMock()
    context.args = ["today"]
    telegram._daily(update=update, context=context)
-    assert str('Daily Profit over the last 7 days</b>:') in msg_mock.call_args_list[0][0][0]
+    assert 'Daily Profit over the last 7 days</b>:' in msg_mock.call_args_list[0][0][0]


-def test_weekly_handle(default_conf, update, ticker, limit_buy_order, fee,
-                       limit_sell_order, mocker) -> None:
-    default_conf['max_open_trades'] = 1
+def test_weekly_handle(default_conf_usdt, update, ticker, fee, mocker, time_machine) -> None:
+    default_conf_usdt['max_open_trades'] = 1
    mocker.patch(
        'freqtrade.rpc.rpc.CryptoToFiatConverter._find_price',
-        return_value=15000.0
+        return_value=1.1
    )
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
@ -528,25 +505,10 @@ def test_weekly_handle(default_conf, update, ticker, limit_buy_order, fee,
        get_fee=fee,
    )

-    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
-
-    patch_get_signal(freqtradebot)
-
-    # Create some test data
-    freqtradebot.enter_positions()
-    trade = Trade.query.first()
-    assert trade
-
-    # Simulate fulfilled LIMIT_BUY order for trade
-    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
-    trade.update_trade(oobj)
-
-    # Simulate fulfilled LIMIT_SELL order for trade
-    oobjs = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
-    trade.update_trade(oobjs)
-
-    trade.close_date = datetime.utcnow()
-    trade.is_open = False
+    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf_usdt)
+    # Move to saturday - so all trades are within that week
+    time_machine.move_to('2022-06-11')
+    create_mock_trades_usdt(fee)

    # Try valid data
    # /weekly 2
@ -560,10 +522,10 @@ def test_weekly_handle(default_conf, update, ticker, limit_buy_order, fee,
    today = datetime.utcnow().date()
    first_iso_day_of_current_week = today - timedelta(days=today.weekday())
    assert str(first_iso_day_of_current_week) in msg_mock.call_args_list[0][0][0]
-    assert str('  0.00006217 BTC') in msg_mock.call_args_list[0][0][0]
-    assert str('  0.933 USD') in msg_mock.call_args_list[0][0][0]
-    assert str('  1 trade') in msg_mock.call_args_list[0][0][0]
-    assert str('  0 trade') in msg_mock.call_args_list[0][0][0]
+    assert '  9.83 USDT' in msg_mock.call_args_list[0][0][0]
+    assert '  10.81 USD' in msg_mock.call_args_list[0][0][0]
+    assert '(3)' in msg_mock.call_args_list[0][0][0]
+    assert '(0)' in msg_mock.call_args_list[0][0][0]

    # Reset msg_mock
    msg_mock.reset_mock()
@ -573,44 +535,10 @@ def test_weekly_handle(default_conf, update, ticker, limit_buy_order, fee,
    assert "Weekly Profit over the last 8 weeks (starting from Monday)</b>:" \
           in msg_mock.call_args_list[0][0][0]
    assert 'Weekly' in msg_mock.call_args_list[0][0][0]
-    assert str('  0.00006217 BTC') in msg_mock.call_args_list[0][0][0]
-    assert str('  0.933 USD') in msg_mock.call_args_list[0][0][0]
-    assert str('  1 trade') in msg_mock.call_args_list[0][0][0]
-    assert str('  0 trade') in msg_mock.call_args_list[0][0][0]
-
-    # Reset msg_mock
-    msg_mock.reset_mock()
-    freqtradebot.config['max_open_trades'] = 2
-    # Add two other trades
-    n = freqtradebot.enter_positions()
-    assert n == 2
-
-    trades = Trade.query.all()
-    for trade in trades:
-        trade.update_trade(oobj)
-        trade.update_trade(oobjs)
-        trade.close_date = datetime.utcnow()
-        trade.is_open = False
-
-    # /weekly 1
-    # By default, the 8 previous weeks are shown
-    # So the previous modified trade should be excluded from the stats
-    context = MagicMock()
-    context.args = ["1"]
-    telegram._weekly(update=update, context=context)
-    assert str('  0.00018651 BTC') in msg_mock.call_args_list[0][0][0]
-    assert str('  2.798 USD') in msg_mock.call_args_list[0][0][0]
-    assert str('  3 trades') in msg_mock.call_args_list[0][0][0]
-
-
-def test_weekly_wrong_input(default_conf, update, ticker, mocker) -> None:
-    mocker.patch.multiple(
-        'freqtrade.exchange.Exchange',
-        fetch_ticker=ticker
-    )
-
-    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
-    patch_get_signal(freqtradebot)
+    assert '  9.83 USDT' in msg_mock.call_args_list[0][0][0]
+    assert '  10.81 USD' in msg_mock.call_args_list[0][0][0]
+    assert '(3)' in msg_mock.call_args_list[0][0][0]
+    assert '(0)' in msg_mock.call_args_list[0][0][0]

    # Try invalid data
    msg_mock.reset_mock()
@ -629,16 +557,17 @@ def test_weekly_wrong_input(default_conf, update, ticker, mocker) -> None:
    context = MagicMock()
    context.args = ["this week"]
    telegram._weekly(update=update, context=context)
-    assert str('Weekly Profit over the last 8 weeks (starting from Monday)</b>:') \
+    assert (
+        'Weekly Profit over the last 8 weeks (starting from Monday)</b>:'
        in msg_mock.call_args_list[0][0][0]
+    )


-def test_monthly_handle(default_conf, update, ticker, limit_buy_order, fee,
-                        limit_sell_order, mocker) -> None:
-    default_conf['max_open_trades'] = 1
+def test_monthly_handle(default_conf_usdt, update, ticker, fee, mocker, time_machine) -> None:
+    default_conf_usdt['max_open_trades'] = 1
    mocker.patch(
        'freqtrade.rpc.rpc.CryptoToFiatConverter._find_price',
-        return_value=15000.0
+        return_value=1.1
    )
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
@ -646,25 +575,10 @@ def test_monthly_handle(default_conf, update, ticker, limit_buy_order, fee,
        get_fee=fee,
    )

-    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
-
-    patch_get_signal(freqtradebot)
-
-    # Create some test data
-    freqtradebot.enter_positions()
-    trade = Trade.query.first()
-    assert trade
-
-    # Simulate fulfilled LIMIT_BUY order for trade
-    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
-    trade.update_trade(oobj)
-
-    # Simulate fulfilled LIMIT_SELL order for trade
-    oobjs = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
-    trade.update_trade(oobjs)
-
-    trade.close_date = datetime.utcnow()
-    trade.is_open = False
+    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf_usdt)
+    # Move to day within the month so all mock trades fall into this week.
+    time_machine.move_to('2022-06-11')
+    create_mock_trades_usdt(fee)

    # Try valid data
    # /monthly 2
@ -677,10 +591,10 @@ def test_monthly_handle(default_conf, update, ticker, limit_buy_order, fee,
    today = datetime.utcnow().date()
    current_month = f"{today.year}-{today.month:02} "
    assert current_month in msg_mock.call_args_list[0][0][0]
-    assert str('  0.00006217 BTC') in msg_mock.call_args_list[0][0][0]
-    assert str('  0.933 USD') in msg_mock.call_args_list[0][0][0]
-    assert str('  1 trade') in msg_mock.call_args_list[0][0][0]
-    assert str('  0 trade') in msg_mock.call_args_list[0][0][0]
+    assert '  9.83 USDT' in msg_mock.call_args_list[0][0][0]
+    assert '  10.81 USD' in msg_mock.call_args_list[0][0][0]
+    assert '(3)' in msg_mock.call_args_list[0][0][0]
+    assert '(0)' in msg_mock.call_args_list[0][0][0]

    # Reset msg_mock
    msg_mock.reset_mock()
@ -691,24 +605,13 @@ def test_monthly_handle(default_conf, update, ticker, limit_buy_order, fee,
    assert 'Monthly Profit over the last 6 months</b>:' in msg_mock.call_args_list[0][0][0]
    assert 'Month ' in msg_mock.call_args_list[0][0][0]
    assert current_month in msg_mock.call_args_list[0][0][0]
-    assert str('  0.00006217 BTC') in msg_mock.call_args_list[0][0][0]
-    assert str('  0.933 USD') in msg_mock.call_args_list[0][0][0]
-    assert str('  1 trade') in msg_mock.call_args_list[0][0][0]
-    assert str('  0 trade') in msg_mock.call_args_list[0][0][0]
+    assert '  9.83 USDT' in msg_mock.call_args_list[0][0][0]
+    assert '  10.81 USD' in msg_mock.call_args_list[0][0][0]
+    assert '(3)' in msg_mock.call_args_list[0][0][0]
+    assert '(0)' in msg_mock.call_args_list[0][0][0]

    # Reset msg_mock
    msg_mock.reset_mock()
-    freqtradebot.config['max_open_trades'] = 2
-    # Add two other trades
-    n = freqtradebot.enter_positions()
-    assert n == 2
-
-    trades = Trade.query.all()
-    for trade in trades:
-        trade.update_trade(oobj)
-        trade.update_trade(oobjs)
-        trade.close_date = datetime.utcnow()
-        trade.is_open = False

    # /monthly 12
    context = MagicMock()
@ -716,24 +619,14 @@ def test_monthly_handle(default_conf, update, ticker, limit_buy_order, fee,
    telegram._monthly(update=update, context=context)
    assert msg_mock.call_count == 1
    assert 'Monthly Profit over the last 12 months</b>:' in msg_mock.call_args_list[0][0][0]
-    assert str('  0.00018651 BTC') in msg_mock.call_args_list[0][0][0]
-    assert str('  2.798 USD') in msg_mock.call_args_list[0][0][0]
-    assert str('  3 trades') in msg_mock.call_args_list[0][0][0]
+    assert '  9.83 USDT' in msg_mock.call_args_list[0][0][0]
+    assert '  10.81 USD' in msg_mock.call_args_list[0][0][0]
+    assert '(3)' in msg_mock.call_args_list[0][0][0]

    # The one-digit months should contain a zero, Eg: September 2021 = "2021-09"
    # Since we loaded the last 12 months, any month should appear
    assert str('-09') in msg_mock.call_args_list[0][0][0]

-
-def test_monthly_wrong_input(default_conf, update, ticker, mocker) -> None:
-    mocker.patch.multiple(
-        'freqtrade.exchange.Exchange',
-        fetch_ticker=ticker
-    )
-
-    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
-    patch_get_signal(freqtradebot)
-
    # Try invalid data
    msg_mock.reset_mock()
    freqtradebot.state = State.RUNNING
@ -754,16 +647,16 @@ def test_monthly_wrong_input(default_conf, update, ticker, mocker) -> None:
    assert str('Monthly Profit over the last 6 months</b>:') in msg_mock.call_args_list[0][0][0]


-def test_profit_handle(default_conf, update, ticker, ticker_sell_up, fee,
-                       limit_buy_order, limit_sell_order, mocker) -> None:
-    mocker.patch('freqtrade.rpc.rpc.CryptoToFiatConverter._find_price', return_value=15000.0)
+def test_profit_handle(default_conf_usdt, update, ticker_usdt, ticker_sell_up, fee,
+                       limit_sell_order_usdt, mocker) -> None:
+    mocker.patch('freqtrade.rpc.rpc.CryptoToFiatConverter._find_price', return_value=1.1)
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
-        fetch_ticker=ticker,
+        fetch_ticker=ticker_usdt,
        get_fee=fee,
    )

-    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
+    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf_usdt)
    patch_get_signal(freqtradebot)

    telegram._profit(update=update, context=MagicMock())
@ -775,10 +668,6 @@ def test_profit_handle(default_conf, update, ticker, ticker_sell_up, fee,
    freqtradebot.enter_positions()
    trade = Trade.query.first()

-    # Simulate fulfilled LIMIT_BUY order for trade
-    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
-    trade.update_trade(oobj)
-
    context = MagicMock()
    # Test with invalid 2nd argument (should silently pass)
    context.args = ["aaa"]
@ -786,15 +675,16 @@ def test_profit_handle(default_conf, update, ticker, ticker_sell_up, fee,
    assert msg_mock.call_count == 1
    assert 'No closed trade' in msg_mock.call_args_list[-1][0][0]
    assert '*ROI:* All trades' in msg_mock.call_args_list[-1][0][0]
-    mocker.patch('freqtrade.wallets.Wallets.get_starting_balance', return_value=0.01)
-    assert ('∙ `-0.000005 BTC (-0.50%) (-0.0 \N{GREEK CAPITAL LETTER SIGMA}%)`'
+    mocker.patch('freqtrade.wallets.Wallets.get_starting_balance', return_value=1000)
+    assert ('∙ `0.298 USDT (0.50%) (0.03 \N{GREEK CAPITAL LETTER SIGMA}%)`'
            in msg_mock.call_args_list[-1][0][0])
    msg_mock.reset_mock()

    # Update the ticker with a market going up
    mocker.patch('freqtrade.exchange.Exchange.fetch_ticker', ticker_sell_up)
    # Simulate fulfilled LIMIT_SELL order for trade
-    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
+    oobj = Order.parse_from_ccxt_object(
+        limit_sell_order_usdt, limit_sell_order_usdt['symbol'], 'sell')
    trade.update_trade(oobj)

    trade.close_date = datetime.now(timezone.utc)
@ -805,15 +695,15 @@ def test_profit_handle(default_conf, update, ticker, ticker_sell_up, fee,
    telegram._profit(update=update, context=context)
    assert msg_mock.call_count == 1
    assert '*ROI:* Closed trades' in msg_mock.call_args_list[-1][0][0]
-    assert ('∙ `0.00006217 BTC (6.20%) (0.62 \N{GREEK CAPITAL LETTER SIGMA}%)`'
+    assert ('∙ `5.685 USDT (9.45%) (0.57 \N{GREEK CAPITAL LETTER SIGMA}%)`'
            in msg_mock.call_args_list[-1][0][0])
-    assert '∙ `0.933 USD`' in msg_mock.call_args_list[-1][0][0]
+    assert '∙ `6.253 USD`' in msg_mock.call_args_list[-1][0][0]
    assert '*ROI:* All trades' in msg_mock.call_args_list[-1][0][0]
-    assert ('∙ `0.00006217 BTC (6.20%) (0.62 \N{GREEK CAPITAL LETTER SIGMA}%)`'
+    assert ('∙ `5.685 USDT (9.45%) (0.57 \N{GREEK CAPITAL LETTER SIGMA}%)`'
            in msg_mock.call_args_list[-1][0][0])
-    assert '∙ `0.933 USD`' in msg_mock.call_args_list[-1][0][0]
+    assert '∙ `6.253 USD`' in msg_mock.call_args_list[-1][0][0]

-    assert '*Best Performing:* `ETH/BTC: 6.20%`' in msg_mock.call_args_list[-1][0][0]
+    assert '*Best Performing:* `ETH/USDT: 9.45%`' in msg_mock.call_args_list[-1][0][0]


@pytest.mark.parametrize('is_short', [True, False])
@ -1350,71 +1240,43 @@ def test_force_enter_no_pair(default_conf, update, mocker) -> None:
    assert fbuy_mock.call_count == 1


-def test_telegram_performance_handle(default_conf, update, ticker, fee,
-                                     limit_buy_order, limit_sell_order, mocker) -> None:
+def test_telegram_performance_handle(default_conf_usdt, update, ticker, fee, mocker) -> None:

    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
        fetch_ticker=ticker,
        get_fee=fee,
    )
-    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
-    patch_get_signal(freqtradebot)
+    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf_usdt)

    # Create some test data
-    freqtradebot.enter_positions()
-    trade = Trade.query.first()
-    assert trade
+    create_mock_trades_usdt(fee)

-    # Simulate fulfilled LIMIT_BUY order for trade
-    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
-    trade.update_trade(oobj)
-
-    # Simulate fulfilled LIMIT_SELL order for trade
-    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
-    trade.update_trade(oobj)
-
-    trade.close_date = datetime.utcnow()
-    trade.is_open = False
    telegram._performance(update=update, context=MagicMock())
    assert msg_mock.call_count == 1
    assert 'Performance' in msg_mock.call_args_list[0][0][0]
-    assert '<code>ETH/BTC\t0.00006217 BTC (6.20%) (1)</code>' in msg_mock.call_args_list[0][0][0]
+    assert '<code>XRP/USDT\t9.842 USDT (10.00%) (1)</code>' in msg_mock.call_args_list[0][0][0]


 def test_telegram_entry_tag_performance_handle(
-        default_conf, update, ticker, fee, limit_buy_order, limit_sell_order, mocker) -> None:
+        default_conf_usdt, update, ticker, fee, mocker) -> None:
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
        fetch_ticker=ticker,
        get_fee=fee,
    )
-    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
+    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf_usdt)
    patch_get_signal(freqtradebot)

-    # Create some test data
-    freqtradebot.enter_positions()
-    trade = Trade.query.first()
-    assert trade
+    create_mock_trades_usdt(fee)

-    # Simulate fulfilled LIMIT_BUY order for trade
-    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
-    trade.update_trade(oobj)
-
-    trade.enter_tag = "TESTBUY"
-    # Simulate fulfilled LIMIT_SELL order for trade
-    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
-    trade.update_trade(oobj)
-
-    trade.close_date = datetime.utcnow()
-    trade.is_open = False
    context = MagicMock()
    telegram._enter_tag_performance(update=update, context=context)
    assert msg_mock.call_count == 1
    assert 'Entry Tag Performance' in msg_mock.call_args_list[0][0][0]
-    assert '<code>TESTBUY\t0.00006217 BTC (6.20%) (1)</code>' in msg_mock.call_args_list[0][0][0]
+    assert '<code>TEST1\t3.987 USDT (5.00%) (1)</code>' in msg_mock.call_args_list[0][0][0]

-    context.args = [trade.pair]
+    context.args = ['XRP/USDT']
    telegram._enter_tag_performance(update=update, context=context)
    assert msg_mock.call_count == 2

@ -1427,37 +1289,24 @@ def test_telegram_entry_tag_performance_handle(
    assert "Error" in msg_mock.call_args_list[0][0][0]


-def test_telegram_exit_reason_performance_handle(default_conf, update, ticker, fee,
-                                                 limit_buy_order, limit_sell_order, mocker) -> None:
+def test_telegram_exit_reason_performance_handle(default_conf_usdt, update, ticker, fee,
+                                                 mocker) -> None:
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
        fetch_ticker=ticker,
        get_fee=fee,
    )
-    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
+    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf_usdt)
    patch_get_signal(freqtradebot)

-    # Create some test data
-    freqtradebot.enter_positions()
-    trade = Trade.query.first()
-    assert trade
-    trade.exit_reason = 'TESTSELL'
-    # Simulate fulfilled LIMIT_BUY order for trade
-    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
-    trade.update_trade(oobj)
+    create_mock_trades_usdt(fee)

-    # Simulate fulfilled LIMIT_SELL order for trade
-    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
-    trade.update_trade(oobj)
-
-    trade.close_date = datetime.utcnow()
-    trade.is_open = False
    context = MagicMock()
    telegram._exit_reason_performance(update=update, context=context)
    assert msg_mock.call_count == 1
    assert 'Exit Reason Performance' in msg_mock.call_args_list[0][0][0]
-    assert '<code>TESTSELL\t0.00006217 BTC (6.20%) (1)</code>' in msg_mock.call_args_list[0][0][0]
-    context.args = [trade.pair]
+    assert '<code>roi\t9.842 USDT (10.00%) (1)</code>' in msg_mock.call_args_list[0][0][0]
+    context.args = ['XRP/USDT']

    telegram._exit_reason_performance(update=update, context=context)
    assert msg_mock.call_count == 2
@ -1471,43 +1320,27 @@ def test_telegram_exit_reason_performance_handle(default_conf, update, ticker, f
    assert "Error" in msg_mock.call_args_list[0][0][0]


-def test_telegram_mix_tag_performance_handle(default_conf, update, ticker, fee,
-                                             limit_buy_order, limit_sell_order, mocker) -> None:
+def test_telegram_mix_tag_performance_handle(default_conf_usdt, update, ticker, fee,
+                                             mocker) -> None:
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
        fetch_ticker=ticker,
        get_fee=fee,
    )
-    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
+    telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf_usdt)
    patch_get_signal(freqtradebot)

    # Create some test data
-    freqtradebot.enter_positions()
-    trade = Trade.query.first()
-    assert trade
-
-    trade.enter_tag = "TESTBUY"
-    trade.exit_reason = "TESTSELL"
-
-    # Simulate fulfilled LIMIT_BUY order for trade
-    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
-    trade.update_trade(oobj)
-
-    # Simulate fulfilled LIMIT_SELL order for trade
-    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
-    trade.update_trade(oobj)
-
-    trade.close_date = datetime.utcnow()
-    trade.is_open = False
+    create_mock_trades_usdt(fee)

    context = MagicMock()
    telegram._mix_tag_performance(update=update, context=context)
    assert msg_mock.call_count == 1
    assert 'Mix Tag Performance' in msg_mock.call_args_list[0][0][0]
-    assert ('<code>TESTBUY TESTSELL\t0.00006217 BTC (6.20%) (1)</code>'
+    assert ('<code>TEST3 roi\t9.842 USDT (10.00%) (1)</code>'
            in msg_mock.call_args_list[0][0][0])

-    context.args = [trade.pair]
+    context.args = ['XRP/USDT']
    telegram._mix_tag_performance(update=update, context=context)
    assert msg_mock.call_count == 2

--- a/tests/rpc/test_rpc_webhook.py
+++ b/tests/rpc/test_rpc_webhook.py
@ -1,5 +1,6 @@
 # pragma pylint: disable=missing-docstring, C0103, protected-access

+from datetime import datetime, timedelta
 from unittest.mock import MagicMock

 import pytest
@ -7,6 +8,7 @@ from requests import RequestException

 from freqtrade.enums import ExitType, RPCMessageType
 from freqtrade.rpc import RPC
+from freqtrade.rpc.discord import Discord
 from freqtrade.rpc.webhook import Webhook
 from tests.conftest import get_patched_freqtradebot, log_has

@ -406,3 +408,42 @@ def test__send_msg_with_raw_format(default_conf, mocker, caplog):
    webhook._send_msg(msg)

    assert post.call_args[1] == {'data': msg['data'], 'headers': {'Content-Type': 'text/plain'}}
+
+
+def test_send_msg_discord(default_conf, mocker):
+
+    default_conf["discord"] = {
+        'enabled': True,
+        'webhook_url': "https://webhookurl..."
+    }
+    msg_mock = MagicMock()
+    mocker.patch("freqtrade.rpc.webhook.Webhook._send_msg", msg_mock)
+    discord = Discord(RPC(get_patched_freqtradebot(mocker, default_conf)), default_conf)
+
+    msg = {
+        'type': RPCMessageType.EXIT_FILL,
+        'trade_id': 1,
+        'exchange': 'Binance',
+        'pair': 'ETH/BTC',
+        'direction': 'Long',
+        'gain': "profit",
+        'close_rate': 0.005,
+        'amount': 0.8,
+        'order_type': 'limit',
+        'open_date': datetime.now() - timedelta(days=1),
+        'close_date': datetime.now(),
+        'open_rate': 0.004,
+        'current_rate': 0.005,
+        'profit_amount': 0.001,
+        'profit_ratio': 0.20,
+        'stake_currency': 'BTC',
+        'enter_tag': 'enter_tagggg',
+        'exit_reason': ExitType.STOP_LOSS.value,
+    }
+    discord.send_msg(msg=msg)
+
+    assert msg_mock.call_count == 1
+    assert 'embeds' in msg_mock.call_args_list[0][0][0]
+    assert 'title' in msg_mock.call_args_list[0][0][0]['embeds'][0]
+    assert 'color' in msg_mock.call_args_list[0][0][0]['embeds'][0]
+    assert 'fields' in msg_mock.call_args_list[0][0][0]['embeds'][0]
--- a/tests/strategy/strats/strategy_test_v3.py
+++ b/tests/strategy/strats/strategy_test_v3.py
@ -178,8 +178,8 @@ class StrategyTestV3(IStrategy):
        return dataframe

    def leverage(self, pair: str, current_time: datetime, current_rate: float,
-                 proposed_leverage: float, max_leverage: float, side: str,
-                 **kwargs) -> float:
+                 proposed_leverage: float, max_leverage: float, entry_tag: Optional[str],
+                 side: str, **kwargs) -> float:
        # Return 3.0 in all cases.
        # Bot-logic must make sure it's an allowed leverage and eventually adjust accordingly.

--- a/tests/strategy/strats/strategy_test_v3_analysis.py
+++ b/tests/strategy/strats/strategy_test_v3_analysis.py
@ -0,0 +1,175 @@
+# pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement
+
+import talib.abstract as ta
+from pandas import DataFrame
+
+import freqtrade.vendor.qtpylib.indicators as qtpylib
+from freqtrade.strategy import (BooleanParameter, DecimalParameter, IntParameter, IStrategy,
+                                RealParameter)
+
+
+class StrategyTestV3Analysis(IStrategy):
+    """
+    Strategy used by tests freqtrade bot.
+    Please do not modify this strategy, it's  intended for internal use only.
+    Please look at the SampleStrategy in the user_data/strategy directory
+    or strategy repository https://github.com/freqtrade/freqtrade-strategies
+    for samples and inspiration.
+    """
+    INTERFACE_VERSION = 3
+
+    # Minimal ROI designed for the strategy
+    minimal_roi = {
+        "40": 0.0,
+        "30": 0.01,
+        "20": 0.02,
+        "0": 0.04
+    }
+
+    # Optimal stoploss designed for the strategy
+    stoploss = -0.10
+
+    # Optimal timeframe for the strategy
+    timeframe = '5m'
+
+    # Optional order type mapping
+    order_types = {
+        'entry': 'limit',
+        'exit': 'limit',
+        'stoploss': 'limit',
+        'stoploss_on_exchange': False
+    }
+
+    # Number of candles the strategy requires before producing valid signals
+    startup_candle_count: int = 20
+
+    # Optional time in force for orders
+    order_time_in_force = {
+        'entry': 'gtc',
+        'exit': 'gtc',
+    }
+
+    buy_params = {
+        'buy_rsi': 35,
+        # Intentionally not specified, so "default" is tested
+        # 'buy_plusdi': 0.4
+    }
+
+    sell_params = {
+        'sell_rsi': 74,
+        'sell_minusdi': 0.4
+    }
+
+    buy_rsi = IntParameter([0, 50], default=30, space='buy')
+    buy_plusdi = RealParameter(low=0, high=1, default=0.5, space='buy')
+    sell_rsi = IntParameter(low=50, high=100, default=70, space='sell')
+    sell_minusdi = DecimalParameter(low=0, high=1, default=0.5001, decimals=3, space='sell',
+                                    load=False)
+    protection_enabled = BooleanParameter(default=True)
+    protection_cooldown_lookback = IntParameter([0, 50], default=30)
+
+    # TODO: Can this work with protection tests? (replace HyperoptableStrategy implicitly ... )
+    # @property
+    # def protections(self):
+    #     prot = []
+    #     if self.protection_enabled.value:
+    #         prot.append({
+    #             "method": "CooldownPeriod",
+    #             "stop_duration_candles": self.protection_cooldown_lookback.value
+    #         })
+    #     return prot
+
+    bot_started = False
+
+    def bot_start(self):
+        self.bot_started = True
+
+    def informative_pairs(self):
+
+        return []
+
+    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+
+        # Momentum Indicator
+        # ------------------------------------
+
+        # ADX
+        dataframe['adx'] = ta.ADX(dataframe)
+
+        # MACD
+        macd = ta.MACD(dataframe)
+        dataframe['macd'] = macd['macd']
+        dataframe['macdsignal'] = macd['macdsignal']
+        dataframe['macdhist'] = macd['macdhist']
+
+        # Minus Directional Indicator / Movement
+        dataframe['minus_di'] = ta.MINUS_DI(dataframe)
+
+        # Plus Directional Indicator / Movement
+        dataframe['plus_di'] = ta.PLUS_DI(dataframe)
+
+        # RSI
+        dataframe['rsi'] = ta.RSI(dataframe)
+
+        # Stoch fast
+        stoch_fast = ta.STOCHF(dataframe)
+        dataframe['fastd'] = stoch_fast['fastd']
+        dataframe['fastk'] = stoch_fast['fastk']
+
+        # Bollinger bands
+        bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
+        dataframe['bb_lowerband'] = bollinger['lower']
+        dataframe['bb_middleband'] = bollinger['mid']
+        dataframe['bb_upperband'] = bollinger['upper']
+
+        # EMA - Exponential Moving Average
+        dataframe['ema10'] = ta.EMA(dataframe, timeperiod=10)
+
+        return dataframe
+
+    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+
+        dataframe.loc[
+            (
+                (dataframe['rsi'] < self.buy_rsi.value) &
+                (dataframe['fastd'] < 35) &
+                (dataframe['adx'] > 30) &
+                (dataframe['plus_di'] > self.buy_plusdi.value)
+            ) |
+            (
+                (dataframe['adx'] > 65) &
+                (dataframe['plus_di'] > self.buy_plusdi.value)
+            ),
+            ['enter_long', 'enter_tag']] = 1, 'enter_tag_long'
+
+        dataframe.loc[
+            (
+                qtpylib.crossed_below(dataframe['rsi'], self.sell_rsi.value)
+            ),
+            ['enter_short', 'enter_tag']] = 1, 'enter_tag_short'
+
+        return dataframe
+
+    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        dataframe.loc[
+            (
+                (
+                    (qtpylib.crossed_above(dataframe['rsi'], self.sell_rsi.value)) |
+                    (qtpylib.crossed_above(dataframe['fastd'], 70))
+                ) &
+                (dataframe['adx'] > 10) &
+                (dataframe['minus_di'] > 0)
+            ) |
+            (
+                (dataframe['adx'] > 70) &
+                (dataframe['minus_di'] > self.sell_minusdi.value)
+            ),
+            ['exit_long', 'exit_tag']] = 1, 'exit_tag_long'
+
+        dataframe.loc[
+            (
+                qtpylib.crossed_above(dataframe['rsi'], self.buy_rsi.value)
+            ),
+            ['exit_long', 'exit_tag']] = 1, 'exit_tag_short'
+
+        return dataframe
--- a/tests/strategy/test_interface.py
+++ b/tests/strategy/test_interface.py
@ -20,7 +20,8 @@ from freqtrade.strategy.hyper import detect_parameters
 from freqtrade.strategy.parameters import (BaseParameter, BooleanParameter, CategoricalParameter,
                                           DecimalParameter, IntParameter, RealParameter)
 from freqtrade.strategy.strategy_wrapper import strategy_safe_wrapper
-from tests.conftest import CURRENT_TEST_STRATEGY, TRADE_SIDES, log_has, log_has_re
+from tests.conftest import (CURRENT_TEST_STRATEGY, TRADE_SIDES, create_mock_trades, log_has,
+                            log_has_re)

 from .strats.strategy_test_v3 import StrategyTestV3

@ -615,6 +616,7 @@ def test_leverage_callback(default_conf, side) -> None:
        proposed_leverage=1.0,
        max_leverage=5.0,
        side=side,
+        entry_tag=None,
        ) == 1

    default_conf['strategy'] = CURRENT_TEST_STRATEGY
@ -626,6 +628,7 @@ def test_leverage_callback(default_conf, side) -> None:
        proposed_leverage=1.0,
        max_leverage=5.0,
        side=side,
+        entry_tag='entry_tag_test',
        ) == 3


@ -810,6 +813,28 @@ def test_strategy_safe_wrapper(value):
    assert ret == value


+@pytest.mark.usefixtures("init_persistence")
+def test_strategy_safe_wrapper_trade_copy(fee):
+    create_mock_trades(fee)
+
+    def working_method(trade):
+        assert len(trade.orders) > 0
+        assert trade.orders
+        trade.orders = []
+        assert len(trade.orders) == 0
+        return trade
+
+    trade = Trade.get_open_trades()[0]
+    # Don't assert anything before strategy_wrapper.
+    # This ensures that relationship loading works correctly.
+    ret = strategy_safe_wrapper(working_method, message='DeadBeef')(trade=trade)
+    assert isinstance(ret, Trade)
+    assert id(trade) != id(ret)
+    # Did not modify the original order
+    assert len(trade.orders) > 0
+    assert len(ret.orders) == 0
+
+
 def test_hyperopt_parameters():
    from skopt.space import Categorical, Integer, Real
    with pytest.raises(OperationalException, match=r"Name is determined.*"):
--- a/tests/strategy/test_strategy_loading.py
+++ b/tests/strategy/test_strategy_loading.py
@ -34,7 +34,7 @@ def test_search_all_strategies_no_failed():
    directory = Path(__file__).parent / "strats"
    strategies = StrategyResolver.search_all_objects(directory, enum_failed=False)
    assert isinstance(strategies, list)
-    assert len(strategies) == 5
+    assert len(strategies) == 6
    assert isinstance(strategies[0], dict)


@ -42,10 +42,10 @@ def test_search_all_strategies_with_failed():
    directory = Path(__file__).parent / "strats"
    strategies = StrategyResolver.search_all_objects(directory, enum_failed=True)
    assert isinstance(strategies, list)
-    assert len(strategies) == 6
+    assert len(strategies) == 7
    # with enum_failed=True search_all_objects() shall find 2 good strategies
    # and 1 which fails to load
-    assert len([x for x in strategies if x['class'] is not None]) == 5
+    assert len([x for x in strategies if x['class'] is not None]) == 6
    assert len([x for x in strategies if x['class'] is None]) == 1


--- a/tests/test_freqtradebot.py
+++ b/tests/test_freqtradebot.py
@ -210,13 +210,14 @@ def test_edge_overrides_stoploss(limit_order, fee, caplog, mocker,
    #
    # mocking the ticker: price is falling ...
    enter_price = limit_order['buy']['price']
+    ticker_val = {
+            'bid': enter_price,
+            'ask': enter_price,
+            'last': enter_price,
+        }
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
-        fetch_ticker=MagicMock(return_value={
-            'bid': enter_price * buy_price_mult,
-            'ask': enter_price * buy_price_mult,
-            'last': enter_price * buy_price_mult,
-        }),
+        fetch_ticker=MagicMock(return_value=ticker_val),
        get_fee=fee,
    )
    #############################################
@ -229,9 +230,12 @@ def test_edge_overrides_stoploss(limit_order, fee, caplog, mocker,
    freqtrade.enter_positions()
    trade = Trade.query.first()
    caplog.clear()
-    oobj = Order.parse_from_ccxt_object(limit_order['buy'], 'ADA/USDT', 'buy')
-    trade.update_trade(oobj)
    #############################################
+    ticker_val.update({
+            'bid': enter_price * buy_price_mult,
+            'ask': enter_price * buy_price_mult,
+            'last': enter_price * buy_price_mult,
+    })

    # stoploss shoud be hit
    assert freqtrade.handle_trade(trade) is not ignore_strat_sl
@ -3771,6 +3775,7 @@ def test_exit_profit_only(
    trade = Trade.query.first()
    assert trade.is_short == is_short
    oobj = Order.parse_from_ccxt_object(limit_order[eside], limit_order[eside]['symbol'], eside)
+    trade.update_order(limit_order[eside])
    trade.update_trade(oobj)
    freqtrade.wallets.update()
    if profit_only:
@ -4059,6 +4064,7 @@ def test_trailing_stop_loss_positive(
    trade = Trade.query.first()
    assert trade.is_short == is_short
    oobj = Order.parse_from_ccxt_object(limit_order[eside], limit_order[eside]['symbol'], eside)
+    trade.update_order(limit_order[eside])
    trade.update_trade(oobj)
    caplog.set_level(logging.DEBUG)
    # stop-loss not reached
@ -4802,10 +4808,19 @@ def test_startup_update_open_orders(mocker, default_conf_usdt, fee, caplog, is_s
    assert len(Order.get_open_orders()) == 2

    caplog.clear()
-    mocker.patch('freqtrade.exchange.Exchange.fetch_order', side_effect=InvalidOrderException)
+    mocker.patch('freqtrade.exchange.Exchange.fetch_order', side_effect=ExchangeError)
    freqtrade.startup_update_open_orders()
    assert log_has_re(r"Error updating Order .*", caplog)

+    mocker.patch('freqtrade.exchange.Exchange.fetch_order', side_effect=InvalidOrderException)
+    hto_mock = mocker.patch('freqtrade.freqtradebot.FreqtradeBot.handle_timedout_order')
+    # Orders which are no longer found after X days should be assumed as canceled.
+    freqtrade.startup_update_open_orders()
+    assert log_has_re(r"Order is older than \d days.*", caplog)
+    assert hto_mock.call_count == 2
+    assert hto_mock.call_args_list[0][0][0]['status'] == 'canceled'
+    assert hto_mock.call_args_list[1][0][0]['status'] == 'canceled'
+

@pytest.mark.usefixtures("init_persistence")
@pytest.mark.parametrize("is_short", [False, True])