Merge branch 'develop' into feat/short

2021-11-06 15:24:52 +01:00 · 2021-11-06 15:24:52 +01:00 · ebc38159b8
commit ebc38159b8
parent c094ac5762 d99eaccb5a
57 changed files with 1202 additions and 197 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -9,7 +9,7 @@ assignees: ''
 <!-- 
 Have you searched for similar issues before posting it?

-If you have discovered a bug in the bot, please [search our issue tracker](https://github.com/freqtrade/freqtrade/issues?q=is%3Aissue). 
+If you have discovered a bug in the bot, please [search the issue tracker](https://github.com/freqtrade/freqtrade/issues?q=is%3Aissue). 
 If it hasn't been reported, please create a new issue.

 Please do not use bug reports to request new features.
--- a/.github/ISSUE_TEMPLATE/question.md
+++ b/.github/ISSUE_TEMPLATE/question.md
@ -22,4 +22,4 @@ Please do not use the question template to report bugs or to request new feature
  
 ## Your question

-*Ask the question you have not been able to find an answer in our [Documentation](https://www.freqtrade.io/en/latest/)*
+*Ask the question you have not been able to find an answer in the [Documentation](https://www.freqtrade.io/en/latest/)*
--- a/README.md
+++ b/README.md
@ -28,9 +28,10 @@ Please read the [exchange specific notes](docs/exchanges.md) to learn about even

 - [X] [Binance](https://www.binance.com/) ([*Note for binance users](docs/exchanges.md#binance-blacklist))
 - [X] [Bittrex](https://bittrex.com/)
- [X] [Kraken](https://kraken.com/)
 - [X] [FTX](https://ftx.com)
 - [X] [Gate.io](https://www.gate.io/ref/6266643)
+- [X] [Kraken](https://kraken.com/)
+- [X] [OKEX](https://www.okex.com/)
 - [ ] [potentially many others](https://github.com/ccxt/ccxt/). _(We cannot guarantee they will work)_

 ### Community tested
@ -44,7 +45,7 @@ Exchanges confirmed working by the community:

 We invite you to read the bot documentation to ensure you understand how the bot is working.

-Please find the complete documentation on our [website](https://www.freqtrade.io).
+Please find the complete documentation on the [freqtrade website](https://www.freqtrade.io).

 ## Features

@ -121,7 +122,7 @@ optional arguments:

 ### Telegram RPC commands

-Telegram is not mandatory. However, this is a great way to control your bot. More details and the full command list on our [documentation](https://www.freqtrade.io/en/latest/telegram-usage/)
+Telegram is not mandatory. However, this is a great way to control your bot. More details and the full command list on the [documentation](https://www.freqtrade.io/en/latest/telegram-usage/)

 - `/start`: Starts the trader.
 - `/stop`: Stops the trader.
@ -152,10 +153,10 @@ For any questions not covered by the documentation or for further information ab
 ### [Bugs / Issues](https://github.com/freqtrade/freqtrade/issues?q=is%3Aissue)

 If you discover a bug in the bot, please
-[search our issue tracker](https://github.com/freqtrade/freqtrade/issues?q=is%3Aissue)
+[search the issue tracker](https://github.com/freqtrade/freqtrade/issues?q=is%3Aissue)
 first. If it hasn't been reported, please
 [create a new issue](https://github.com/freqtrade/freqtrade/issues/new/choose) and
-ensure you follow the template guide so that our team can assist you as
+ensure you follow the template guide so that the team can assist you as
 quickly as possible.

 ### [Feature Requests](https://github.com/freqtrade/freqtrade/labels/enhancement)
@ -169,13 +170,13 @@ in the bug reports.

 ### [Pull Requests](https://github.com/freqtrade/freqtrade/pulls)

-Feel like our bot is missing a feature? We welcome your pull requests!
+Feel like the bot is missing a feature? We welcome your pull requests!

-Please read our
+Please read the
 [Contributing document](https://github.com/freqtrade/freqtrade/blob/develop/CONTRIBUTING.md)
 to understand the requirements before sending your pull-requests.

-Coding is not a necessity to contribute - maybe start with improving our documentation?
+Coding is not a necessity to contribute - maybe start with improving the documentation?
 Issues labeled [good first issue](https://github.com/freqtrade/freqtrade/labels/good%20first%20issue) can be good first contributions, and will help get you familiar with the codebase.

 **Note** before starting any major new feature work, *please open an issue describing what you are planning to do* or talk to us on [discord](https://discord.gg/p7nuUNVfP7) (please use the #dev channel for this). This will ensure that interested parties can give valuable feedback on the feature, and let others know that you are working on it.
--- a/docs/assets/frequi_url.png
+++ b/docs/assets/frequi_url.png
--- a/docs/backtesting.md
+++ b/docs/backtesting.md
@ -459,7 +459,7 @@ The output will show a table containing the realized absolute Profit (in stake c
 ### Further backtest-result analysis

 To further analyze your backtest results, you can [export the trades](#exporting-trades-to-file).
-You can then load the trades to perform further analysis as shown in our [data analysis](data-analysis.md#backtesting) backtesting section.
+You can then load the trades to perform further analysis as shown in the [data analysis](data-analysis.md#backtesting) backtesting section.

 ## Assumptions made by backtesting

@ -478,6 +478,7 @@ Since backtesting lacks some detailed information about what happens within a ca
 - Low happens before high for stoploss, protecting capital first
 - Trailing stoploss
  - Trailing Stoploss is only adjusted if it's below the candle's low (otherwise it would be triggered)
+  - On trade entry candles that trigger trailing stoploss, the "minimum offset" (`stop_positive_offset`) is assumed (instead of high) - and the stop is calculated from this point
  - High happens first - adjusting stoploss
  - Low uses the adjusted stoploss (so sells with large high-low difference are backtested correctly)
  - ROI applies before trailing-stop, ensuring profits are "top-capped" at ROI if both ROI and trailing stop applies
--- a/docs/configuration.md
+++ b/docs/configuration.md
@ -37,6 +37,15 @@ Using this scheme, all configuration settings will also be available as environm

 Please note that Environment variables will overwrite corresponding settings in your configuration, but command line Arguments will always win.

+Common example:
+
+```
+FREQTRADE__TELEGRAM__CHAT_ID=<telegramchatid>
+FREQTRADE__TELEGRAM__TOKEN=<telegramToken>
+FREQTRADE__EXCHANGE__KEY=<yourExchangeKey>
+FREQTRADE__EXCHANGE__SECRET=<yourExchangeSecret>
+```
+
 !!! Note
    Environment variables detected are logged at startup - so if you can't find why a value is not what you think it should be based on the configuration, make sure it's not loaded from an environment variable.

--- a/docs/developer.md
+++ b/docs/developer.md
@ -250,7 +250,23 @@ Most exchanges supported by CCXT should work out of the box.
 To quickly test the public endpoints of an exchange, add a configuration for your exchange to `test_ccxt_compat.py` and run these tests with `pytest --longrun tests/exchange/test_ccxt_compat.py`.
 Completing these tests successfully a good basis point (it's a requirement, actually), however these won't guarantee correct exchange functioning, as this only tests public endpoints, but no private endpoint (like generate order or similar).

-Also try to use `freqtrade download-data` for an extended timerange and verify that the data downloaded correctly (no holes, the specified timerange was actually downloaded).
+Also try to use `freqtrade download-data` for an extended timerange (multiple months) and verify that the data downloaded correctly (no holes, the specified timerange was actually downloaded).
+
+These are prerequisites to have an exchange listed as either Supported or Community tested (listed on the homepage).
+The below are "extras", which will make an exchange better (feature-complete) - but are not absolutely necessary for either of the 2 categories.
+
+Additional tests / steps to complete:
+
+* Verify data provided by `fetch_ohlcv()` - and eventually adjust `ohlcv_candle_limit` for this exchange
+* Check L2 orderbook limit range (API documentation) - and eventually set as necessary
+* Check if balance shows correctly (*)
+* Create market order (*)
+* Create limit order (*)
+* Complete trade (buy + sell) (*)
+  * Compare result calculation between exchange and bot
+  * Ensure fees are applied correctly (check the database against the exchange)
+
+(*) Requires API keys and Balance on the exchange.

 ### Stoploss On Exchange

--- a/docs/exchanges.md
+++ b/docs/exchanges.md
@ -46,7 +46,7 @@ In case of problems related to rate-limits (usually DDOS Exceptions in your logs
 ```

 This configuration enables kraken, as well as rate-limiting to avoid bans from the exchange.
-`"rateLimit": 3100` defines a wait-event of 0.2s between each call. This can also be completely disabled by setting `"enableRateLimit"` to false.
+`"rateLimit": 3100` defines a wait-event of 3.1s between each call. This can also be completely disabled by setting `"enableRateLimit"` to false.

 !!! Note
    Optimal settings for rate-limiting depend on the exchange and the size of the whitelist, so an ideal parameter will vary on many other settings.
@ -182,6 +182,23 @@ Kucoin supports [time_in_force](configuration.md#understand-order_time_in_force)
 For Kucoin, please add `"KCS/<STAKE>"` to your blacklist to avoid issues.
 Accounts having KCS accounts use this to pay for fees - if your first trade happens to be on `KCS`, further trades will consume this position and make the initial KCS trade unsellable as the expected amount is not there anymore.

+## OKEX
+
+OKEX requires a passphrase for each api key, you will therefore need to add this key into the configuration so your exchange section looks as follows:
+
+```json
+"exchange": {
+    "name": "okex",
+    "key": "your_exchange_key",
+    "secret": "your_exchange_secret",
+    "password": "your_exchange_api_key_password",
+    // ...
+}
+```
+
+!!! Warning
+    OKEX only provides 100 candles per api call. Therefore, the strategy will only have a pretty low amount of data available in backtesting mode.
+
 ## All exchanges

 Should you experience constant errors with Nonce (like `InvalidNonce`), it is best to regenerate the API keys. Resetting Nonce is difficult and it's usually easier to regenerate the API keys.
--- a/docs/faq.md
+++ b/docs/faq.md
@ -42,7 +42,7 @@ position for a trade. Be patient!
 ### I have made 12 trades already, why is my total profit negative?

 I understand your disappointment but unfortunately 12 trades is just
-not enough to say anything. If you run backtesting, you can see that our
+not enough to say anything. If you run backtesting, you can see that the
 current algorithm does leave you on the plus side, but that is after
 thousands of trades and even there, you will be left with losses on
 specific coins that you have traded tens if not hundreds of times. We
@ -93,6 +93,18 @@ If this happens for all pairs in the pairlist, this might indicate a recent exch

 Irrespectively of the reason, Freqtrade will fill up these candles with "empty" candles, where open, high, low and close are set to the previous candle close - and volume is empty. In a chart, this will look like a `_` - and is aligned with how exchanges usually represent 0 volume candles.

+### I'm getting "Outdated history for pair xxx" in the log
+
+The bot is trying to tell you that it got an outdated last candle (not the last complete candle).
+As a consequence, Freqtrade will not enter a trade for this pair - as trading on old information is usually not what is desired.
+
+This warning can point to one of the below problems:
+
+* Exchange downtime -> Check your exchange status page / blog / twitter feed for details.
+* Wrong system time -> Ensure your system-time is correct.
+* Barely traded pair -> Check the pair on the exchange webpage, look at the timeframe your strategy uses. If the pair does not have any volume in some candles (usually visualized with a "volume 0" bar, and a "_" as candle), this pair did not have any trades in this timeframe. These pairs should ideally be avoided, as they can cause problems with order-filling.
+* API problem -> API returns wrong data (this only here for completeness, and should not happen with supported exchanges).
+
 ### I'm getting the "RESTRICTED_MARKET" message in the log

 Currently known to happen for US Bittrex users.  
--- a/docs/index.md
+++ b/docs/index.md
@ -39,8 +39,9 @@ Please read the [exchange specific notes](exchanges.md) to learn about eventual,
 - [X] [Binance](https://www.binance.com/) ([*Note for binance users](docs/exchanges.md#binance-blacklist))
 - [X] [Bittrex](https://bittrex.com/)
 - [X] [FTX](https://ftx.com)
- [X] [Kraken](https://kraken.com/)
 - [X] [Gate.io](https://www.gate.io/ref/6266643)
+- [X] [Kraken](https://kraken.com/)
+- [X] [OKEX](https://www.okex.com/)
 - [ ] [potentially many others through <img alt="ccxt" width="30px" src="assets/ccxt-logo.svg" />](https://github.com/ccxt/ccxt/). _(We cannot guarantee they will work)_

 ### Community tested
@ -80,4 +81,4 @@ For any questions not covered by the documentation or for further information ab

 ## Ready to try?

-Begin by reading our installation guide [for docker](docker_quickstart.md) (recommended), or for [installation without docker](installation.md).
+Begin by reading the installation guide [for docker](docker_quickstart.md) (recommended), or for [installation without docker](installation.md).
--- a/docs/requirements-docs.txt
+++ b/docs/requirements-docs.txt
@ -1,4 +1,4 @@
 mkdocs==1.2.3
-mkdocs-material==7.3.4
+mkdocs-material==7.3.6
 mdx_truly_sane_lists==1.2
 pymdown-extensions==9.0
--- a/docs/rest-api.md
+++ b/docs/rest-api.md
@ -330,12 +330,15 @@ Since the access token has a short timeout (15 min) - the `token/refresh` reques

 ### CORS

-All web-based front-ends are subject to [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) - Cross-Origin Resource Sharing.
-Since most of the requests to the Freqtrade API must be authenticated, a proper CORS policy is key to avoid security problems.
-Also, the standard disallows `*` CORS policies for requests with credentials, so this setting must be set appropriately.
+This whole section is only necessary in cross-origin cases (where you multiple bot API's running on `localhost:8081`, `localhost:8082`, ...), and want to combine them into one FreqUI instance.

-Users can configure this themselves via the `CORS_origins` configuration setting.
-It consists of a list of allowed sites that are allowed to consume resources from the bot's API.
+??? info "Technical explanation"
+    All web-based front-ends are subject to [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) - Cross-Origin Resource Sharing.
+    Since most of the requests to the Freqtrade API must be authenticated, a proper CORS policy is key to avoid security problems.
+    Also, the standard disallows `*` CORS policies for requests with credentials, so this setting must be set appropriately.
+
+Users can allow access from different origin URL's to the bot API via the `CORS_origins` configuration setting.
+It consists of a list of allowed URL's that are allowed to consume resources from the bot's API.

 Assuming your application is deployed as `https://frequi.freqtrade.io/home/` - this would mean that the following configuration becomes necessary:

@ -348,5 +351,19 @@ Assuming your application is deployed as `https://frequi.freqtrade.io/home/` - t
 }
 ```

+In the following (pretty common) case, FreqUI is accessible on `http://localhost:8080/trade` (this is what you see in your navbar when navigating to freqUI).
+![freqUI url](assets/frequi_url.png)
+
+The correct configuration for this case is `http://localhost:8080` - the main part of the URL including the port.
+
+```jsonc
+{
+    //...
+    "jwt_secret_key": "somethingrandom",
+    "CORS_origins": ["http://localhost:8080"],
+    //...
+}
+```
+
 !!! Note
    We strongly recommend to also set `jwt_secret_key` to something random and known only to yourself to avoid unauthorized access to your bot.
--- a/docs/stoploss.md
+++ b/docs/stoploss.md
@ -182,7 +182,7 @@ For example, simplified math:
 * the bot buys an asset at a price of 100$
 * the stop loss is defined at -10%
 * the stop loss would get triggered once the asset drops below 90$
-* stoploss will remain at 90$ unless asset increases to or above our configured offset
+* stoploss will remain at 90$ unless asset increases to or above the configured offset
 * assuming the asset now increases to 103$ (where we have the offset configured)
 * the stop loss will now be -2% of 103$ = 100.94$
 * now the asset drops in value to 101\$, the stop loss will still be 100.94$ and would trigger at 100.94$
--- a/docs/strategy-advanced.md
+++ b/docs/strategy-advanced.md
@ -436,7 +436,7 @@ class AwesomeStrategy(IStrategy):

    # ... populate_* methods

-    # Set unfilledtimeout to 25 hours, since our maximum timeout from below is 24 hours.
+    # Set unfilledtimeout to 25 hours, since the maximum timeout from below is 24 hours.
    unfilledtimeout = {
        'buy': 60 * 25,
        'sell': 60 * 25
@ -475,7 +475,7 @@ class AwesomeStrategy(IStrategy):

    # ... populate_* methods

-    # Set unfilledtimeout to 25 hours, since our maximum timeout from below is 24 hours.
+    # Set unfilledtimeout to 25 hours, since the maximum timeout from below is 24 hours.
    unfilledtimeout = {
        'buy': 60 * 25,
        'sell': 60 * 25
--- a/docs/strategy-customization.md
+++ b/docs/strategy-customization.md
@ -511,9 +511,9 @@ The strategy might look something like this:

 *Scan through the top 10 pairs by volume using the `VolumePairList` every 5 minutes and use a 14 day RSI to buy and sell.*

-Due to the limited available data, it's very difficult to resample our `5m` candles into daily candles for use in a 14 day RSI. Most exchanges limit us to just 500 candles which effectively gives us around 1.74 daily candles. We need 14 days at least!
+Due to the limited available data, it's very difficult to resample `5m` candles into daily candles for use in a 14 day RSI. Most exchanges limit us to just 500 candles which effectively gives us around 1.74 daily candles. We need 14 days at least!

-Since we can't resample our data we will have to use an informative pair; and since our whitelist will be dynamic we don't know which pair(s) to use.
+Since we can't resample the data we will have to use an informative pair; and since the whitelist will be dynamic we don't know which pair(s) to use.

 This is where calling `self.dp.current_whitelist()` comes in handy.

@ -969,7 +969,7 @@ The following lists some common patterns which should be avoided to prevent frus

 ## Further strategy ideas

-To get additional Ideas for strategies, head over to our [strategy repository](https://github.com/freqtrade/freqtrade-strategies). Feel free to use them as they are - but results will depend on the current market situation, pairs used etc. - therefore please backtest the strategy for your exchange/desired pairs first, evaluate carefully, use at your own risk.
+To get additional Ideas for strategies, head over to the [strategy repository](https://github.com/freqtrade/freqtrade-strategies). Feel free to use them as they are - but results will depend on the current market situation, pairs used etc. - therefore please backtest the strategy for your exchange/desired pairs first, evaluate carefully, use at your own risk.
 Feel free to use any of them as inspiration for your own strategies.
 We're happy to accept Pull Requests containing new Strategies to that repo.

--- a/docs/utils.md
+++ b/docs/utils.md
@ -577,6 +577,46 @@ Common arguments:

 ```

+## Show previous Backtest results
+
+Allows you to show previous backtest results.
+Adding `--show-pair-list` outputs a sorted pair list you can easily copy/paste into your configuration (omitting bad pairs).
+
+??? Warning "Strategy overfitting"
+    Only using winning pairs can lead to an overfitted strategy, which will not work well on future data. Make sure to extensively test your strategy in dry-run before risking real money.
+
+```
+usage: freqtrade backtesting-show [-h] [-v] [--logfile FILE] [-V] [-c PATH]
+                                  [-d PATH] [--userdir PATH]
+                                  [--export-filename PATH] [--show-pair-list]
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --export-filename PATH
+                        Save backtest results to the file with this filename.
+                        Requires `--export` to be set as well. Example:
+                        `--export-filename=user_data/backtest_results/backtest
+                        _today.json`
+  --show-pair-list      Show backtesting pairlist sorted by profit.
+
+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
@ -48,7 +48,7 @@ Sample configuration (tested using IFTTT).
    },
 ```

-The url in `webhook.url` should point to the correct url for your webhook. If you're using [IFTTT](https://ifttt.com) (as shown in the sample above) please insert our event and key to the url.
+The url in `webhook.url` should point to the correct url for your webhook. If you're using [IFTTT](https://ifttt.com) (as shown in the sample above) please insert your event and key to the url.

 You can set the POST body format to Form-Encoded (default) or JSON-Encoded. Use `"format": "form"` or `"format": "json"` respectively. Example configuration for Mattermost Cloud integration:

--- a/freqtrade/commands/init.py
+++ b/freqtrade/commands/init.py
@ -16,7 +16,8 @@ from freqtrade.commands.hyperopt_commands import start_hyperopt_list, start_hype
 from freqtrade.commands.list_commands import (start_list_exchanges, start_list_markets,
                                              start_list_strategies, start_list_timeframes,
                                              start_show_trades)
-from freqtrade.commands.optimize_commands import start_backtesting, start_edge, start_hyperopt
+from freqtrade.commands.optimize_commands import (start_backtesting, start_backtesting_show,
+                                                  start_edge, start_hyperopt)
 from freqtrade.commands.pairlist_commands import start_test_pairlist
 from freqtrade.commands.plot_commands import start_plot_dataframe, start_plot_profit
 from freqtrade.commands.trade_commands import start_trading
--- a/freqtrade/commands/arguments.py
+++ b/freqtrade/commands/arguments.py
@ -41,6 +41,8 @@ ARGS_LIST_STRATEGIES = ["strategy_path", "print_one_column", "print_colorized"]

 ARGS_LIST_HYPEROPTS = ["hyperopt_path", "print_one_column", "print_colorized"]

+ARGS_BACKTEST_SHOW = ["exportfilename", "backtest_show_pair_list"]
+
 ARGS_LIST_EXCHANGES = ["print_one_column", "list_exchanges_all"]

 ARGS_LIST_TIMEFRAMES = ["exchange", "print_one_column"]
@ -94,7 +96,7 @@ ARGS_HYPEROPT_SHOW = ["hyperopt_list_best", "hyperopt_list_profitable", "hyperop

 NO_CONF_REQURIED = ["convert-data", "convert-trade-data", "download-data", "list-timeframes",
                    "list-markets", "list-pairs", "list-strategies", "list-data",
-                    "hyperopt-list", "hyperopt-show",
+                    "hyperopt-list", "hyperopt-show", "backtest-filter",
                    "plot-dataframe", "plot-profit", "show-trades", "trades-to-ohlcv"]

 NO_CONF_ALLOWED = ["create-userdir", "list-exchanges", "new-strategy"]
@ -173,7 +175,8 @@ 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_convert_data, start_convert_trades,
+        from freqtrade.commands import (start_backtesting, start_backtesting_show,
+                                        start_convert_data, 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,
@ -264,6 +267,15 @@ class Arguments:
        backtesting_cmd.set_defaults(func=start_backtesting)
        self._build_args(optionlist=ARGS_BACKTEST, parser=backtesting_cmd)

+        # Add backtesting-show subcommand
+        backtesting_show_cmd = subparsers.add_parser(
+            'backtesting-show',
+            help='Show past Backtest results',
+            parents=[_common_parser],
+        )
+        backtesting_show_cmd.set_defaults(func=start_backtesting_show)
+        self._build_args(optionlist=ARGS_BACKTEST_SHOW, parser=backtesting_show_cmd)
+
        # Add edge subcommand
        edge_cmd = subparsers.add_parser('edge', help='Edge module.',
                                         parents=[_common_parser, _strategy_parser])
--- a/freqtrade/commands/build_config_commands.py
+++ b/freqtrade/commands/build_config_commands.py
@ -83,11 +83,19 @@ def ask_user_config() -> Dict[str, Any]:
            if val == UNLIMITED_STAKE_AMOUNT
            else val
        },
+        {
+            "type": "select",
+            "name": "timeframe_in_config",
+            "message": "Tim",
+            "choices": ["Have the strategy define timeframe.", "Override in configuration."]
+        },
        {
            "type": "text",
            "name": "timeframe",
            "message": "Please insert your desired timeframe (e.g. 5m):",
            "default": "5m",
+            "when": lambda x: x["timeframe_in_config"] == 'Override in configuration.'
+
        },
        {
            "type": "text",
@ -107,6 +115,7 @@ def ask_user_config() -> Dict[str, Any]:
                "ftx",
                "kucoin",
                "gateio",
+                "okex",
                Separator(),
                "other",
            ],
@ -134,7 +143,7 @@ def ask_user_config() -> Dict[str, Any]:
            "type": "password",
            "name": "exchange_key_password",
            "message": "Insert Exchange API Key password",
-            "when": lambda x: not x['dry_run'] and x['exchange_name'] == 'kucoin'
+            "when": lambda x: not x['dry_run'] and x['exchange_name'] in ('kucoin', 'okex')
        },
        {
            "type": "confirm",
--- a/freqtrade/commands/cli_options.py
+++ b/freqtrade/commands/cli_options.py
@ -152,6 +152,12 @@ AVAILABLE_CLI_OPTIONS = {
        action='store_false',
        default=True,
    ),
+    "backtest_show_pair_list": Arg(
+        '--show-pair-list',
+        help='Show backtesting pairlist sorted by profit.',
+        action='store_true',
+        default=False,
+    ),
    "enable_protections": Arg(
        '--enable-protections', '--enableprotections',
        help='Enable protections for backtesting.'
--- a/freqtrade/commands/optimize_commands.py
+++ b/freqtrade/commands/optimize_commands.py
@ -54,6 +54,22 @@ def start_backtesting(args: Dict[str, Any]) -> None:
    backtesting.start()


+def start_backtesting_show(args: Dict[str, Any]) -> None:
+    """
+    Show previous backtest result
+    """
+
+    config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
+
+    from freqtrade.data.btanalysis import load_backtest_stats
+    from freqtrade.optimize.optimize_reports import show_backtest_results, show_sorted_pairlist
+
+    results = load_backtest_stats(config['exportfilename'])
+
+    show_backtest_results(config, results)
+    show_sorted_pairlist(config, results)
+
+
 def start_hyperopt(args: Dict[str, Any]) -> None:
    """
    Start hyperopt script
--- a/freqtrade/configuration/configuration.py
+++ b/freqtrade/configuration/configuration.py
@ -245,6 +245,10 @@ class Configuration:
        self._args_to_config(config, argname='timeframe_detail',
                             logstring='Parameter --timeframe-detail detected, '
                             'using {} for intra-candle backtesting ...')
+
+        self._args_to_config(config, argname='backtest_show_pair_list',
+                             logstring='Parameter --show-pair-list detected.')
+
        self._args_to_config(config, argname='stake_amount',
                             logstring='Parameter --stake-amount detected, '
                             'overriding stake_amount to: {} ...')
--- a/freqtrade/configuration/environment_vars.py
+++ b/freqtrade/configuration/environment_vars.py
@ -32,6 +32,7 @@ def flat_vars_to_nested_dict(env_dict: Dict[str, Any], prefix: str) -> Dict[str,
    :param prefix: Prefix to consider (usually FREQTRADE__)
    :return: Nested dict based on available and relevant variables.
    """
+    no_convert = ['CHAT_ID']
    relevant_vars: Dict[str, Any] = {}

    for env_var, val in sorted(env_dict.items()):
@ -39,9 +40,9 @@ def flat_vars_to_nested_dict(env_dict: Dict[str, Any], prefix: str) -> Dict[str,
            logger.info(f"Loading variable '{env_var}'")
            key = env_var.replace(prefix, '')
            for k in reversed(key.split('__')):
-                val = {k.lower(): get_var_typed(val) if type(val) != dict else val}
+                val = {k.lower(): get_var_typed(val)
+                       if type(val) != dict and k not in no_convert else val}
            relevant_vars = deep_merge_dicts(val, relevant_vars)
-
    return relevant_vars


--- a/freqtrade/enums/signaltype.py
+++ b/freqtrade/enums/signaltype.py
@ -16,6 +16,7 @@ class SignalTagType(Enum):
    Enum for signal columns
    """
    ENTER_TAG = "enter_tag"
+    EXIT_TAG = "exit_tag"


 class SignalDirection(Enum):
--- a/freqtrade/exchange/init.py
+++ b/freqtrade/exchange/init.py
@ -19,3 +19,4 @@ from freqtrade.exchange.gateio import Gateio
 from freqtrade.exchange.hitbtc import Hitbtc
 from freqtrade.exchange.kraken import Kraken
 from freqtrade.exchange.kucoin import Kucoin
+from freqtrade.exchange.okex import Okex
--- a/freqtrade/exchange/exchange.py
+++ b/freqtrade/exchange/exchange.py
@ -1710,7 +1710,7 @@ def is_exchange_known_ccxt(exchange_name: str, ccxt_module: CcxtModuleType = Non


 def is_exchange_officially_supported(exchange_name: str) -> bool:
-    return exchange_name in ['bittrex', 'binance', 'kraken']
+    return exchange_name in ['bittrex', 'binance', 'kraken', 'ftx', 'gateio', 'okex']


 def ccxt_exchanges(ccxt_module: CcxtModuleType = None) -> List[str]:
--- a/freqtrade/exchange/okex.py
+++ b/freqtrade/exchange/okex.py
@ -0,0 +1,18 @@
+import logging
+from typing import Dict
+
+from freqtrade.exchange import Exchange
+
+
+logger = logging.getLogger(__name__)
+
+
+class Okex(Exchange):
+    """
+    Okex exchange class. Contains adjustments needed for Freqtrade to work
+    with this exchange.
+    """
+
+    _ft_has: Dict = {
+        "ohlcv_candle_limit": 100,
+    }
--- a/freqtrade/freqtradebot.py
+++ b/freqtrade/freqtradebot.py
@ -855,6 +855,7 @@ class FreqtradeBot(LoggingMixin):
        logger.debug('Handling %s ...', trade)

        (enter, exit_) = (False, False)
+        exit_tag = None
        exit_signal_type = "exit_short" if trade.is_short else "exit_long"

        # TODO-lev: change to use_exit_signal, ignore_roi_if_enter_signal
@ -863,7 +864,7 @@ class FreqtradeBot(LoggingMixin):
            analyzed_df, _ = self.dataprovider.get_analyzed_dataframe(trade.pair,
                                                                      self.strategy.timeframe)

-            (enter, exit_) = self.strategy.get_exit_signal(
+            (enter, exit_, exit_tag) = self.strategy.get_exit_signal(
                trade.pair,
                self.strategy.timeframe,
                analyzed_df,
@ -872,7 +873,7 @@ class FreqtradeBot(LoggingMixin):

        logger.debug('checking exit')
        exit_rate = self.exchange.get_rate(trade.pair, refresh=True, side=trade.exit_side)
-        if self._check_and_execute_exit(trade, exit_rate, enter, exit_):
+        if self._check_and_execute_exit(trade, exit_rate, enter, exit_, exit_tag):
            return True

        logger.debug(f'Found no {exit_signal_type} signal for %s.', trade)
@ -1021,7 +1022,7 @@ class FreqtradeBot(LoggingMixin):
                                   f"for pair {trade.pair}.")

    def _check_and_execute_exit(self, trade: Trade, exit_rate: float,
-                                enter: bool, exit_: bool) -> bool:
+                                enter: bool, exit_: bool, exit_tag: Optional[str]) -> bool:
        """
        Check and execute trade exit
        """
@ -1035,8 +1036,9 @@ class FreqtradeBot(LoggingMixin):
        )

        if should_exit.sell_flag:
-            logger.info(f'Exit for {trade.pair} detected. Reason: {should_exit.sell_type}')
-            self.execute_trade_exit(trade, exit_rate, should_exit)
+            logger.info(f'Exit for {trade.pair} detected. Reason: {should_exit.sell_type}'
+                        f'Tag: {exit_tag if exit_tag is not None else "None"}')
+            self.execute_trade_exit(trade, exit_rate, should_exit, exit_tag)
            return True
        return False

@ -1250,6 +1252,7 @@ class FreqtradeBot(LoggingMixin):
        trade: Trade,
        limit: float,
        sell_reason: SellCheckTuple,  # TODO-lev update to exit_reason
+        exit_tag: Optional[str] = None
    ) -> bool:
        """
        Executes a trade exit for the given trade and limit
@ -1329,7 +1332,7 @@ class FreqtradeBot(LoggingMixin):
        trade.open_order_id = order['id']
        trade.sell_order_status = ''
        trade.close_rate_requested = limit
-        trade.sell_reason = sell_reason.sell_reason
+        trade.sell_reason = exit_tag or sell_reason.sell_reason
        # In case of market sell orders the order can be closed immediately
        if order.get('status', 'unknown') in ('closed', 'expired'):
            self.update_trade_state(trade, trade.open_order_id, order)
@ -1370,6 +1373,7 @@ class FreqtradeBot(LoggingMixin):
            'current_rate': current_rate,
            'profit_amount': profit_trade,
            'profit_ratio': profit_ratio,
+            'buy_tag': trade.buy_tag,
            'sell_reason': trade.sell_reason,
            'open_date': trade.open_date,
            'close_date': trade.close_date or datetime.utcnow(),
@ -1413,6 +1417,7 @@ class FreqtradeBot(LoggingMixin):
            'current_rate': current_rate,
            'profit_amount': profit_trade,
            'profit_ratio': profit_ratio,
+            'buy_tag': trade.buy_tag,
            'sell_reason': trade.sell_reason,
            'open_date': trade.open_date,
            'close_date': trade.close_date or datetime.now(timezone.utc),
@ -1459,6 +1464,11 @@ class FreqtradeBot(LoggingMixin):

        trade.update_order(order)

+        if self.exchange.check_order_canceled_empty(order):
+            # Trade has been cancelled on exchange
+            # Handling of this will happen in check_handle_timeout.
+            return True
+
        # Try update amount (binance-fix)
        try:
            new_amount = self.get_real_amount(trade, order)
@ -1470,10 +1480,6 @@ class FreqtradeBot(LoggingMixin):
        except DependencyException as exception:
            logger.warning("Could not update trade amount: %s", exception)

-        if self.exchange.check_order_canceled_empty(order):
-            # Trade has been cancelled on exchange
-            # Handling of this will happen in check_handle_timeout.
-            return True
        trade.update(order)
        Trade.commit()

--- a/freqtrade/optimize/backtesting.py
+++ b/freqtrade/optimize/backtesting.py
@ -46,6 +46,7 @@ ELONG_IDX = 6  # Exit long
 SHORT_IDX = 7
 ESHORT_IDX = 8  # Exit short
 ENTER_TAG_IDX = 9
+EXIT_TAG_IDX = 10


 class Backtesting:
@ -257,7 +258,7 @@ class Backtesting:
        # Every change to this headers list must evaluate further usages of the resulting tuple
        # and eventually change the constants for indexes at the top
        headers = ['date', 'open', 'high', 'low', 'close', 'enter_long', 'exit_long',
-                   'enter_short', 'exit_short', 'enter_tag']
+                   'enter_short', 'exit_short', 'enter_tag', 'exit_tag']
        data: Dict = {}
        self.progress.init_step(BacktestState.CONVERT, len(processed))

@ -283,7 +284,7 @@ class Backtesting:
                if col in df_analyzed.columns:
                    df_analyzed.loc[:, col] = df_analyzed.loc[:, col].shift(1)
                else:
-                    df_analyzed.loc[:, col] = 0 if col != 'enter_tag' else None
+                    df_analyzed.loc[:, col] = 0 if col not in ('enter_tag', 'exit_tag') else None

            # Update dataprovider cache
            self.dataprovider._set_cached_df(pair, self.timeframe, df_analyzed)
@ -326,7 +327,9 @@ class Backtesting:
                    # Worst case: price ticks tiny bit above open and dives down.
                    stop_rate = sell_row[OPEN_IDX] * (1 - abs(trade.stop_loss_pct))
                    assert stop_rate < sell_row[HIGH_IDX]
-                return stop_rate
+                # Limit lower-end to candle low to avoid sells below the low.
+                # This still remains "worst case" - but "worst realistic case".
+                return max(sell_row[LOW_IDX], stop_rate)

            # Set close_rate to stoploss
            return trade.stop_loss
@ -375,6 +378,16 @@ class Backtesting:
        if sell.sell_flag:
            trade.close_date = sell_candle_time
            trade.sell_reason = sell.sell_reason
+
+            # Checks and adds an exit tag, after checking that the length of the
+            # sell_row has the length for an exit tag column
+            if(
+                len(sell_row) > EXIT_TAG_IDX
+                and sell_row[EXIT_TAG_IDX] is not None
+                and len(sell_row[EXIT_TAG_IDX]) > 0
+            ):
+                trade.sell_reason = sell_row[EXIT_TAG_IDX]
+
            trade_dur = int((trade.close_date_utc - trade.open_date_utc).total_seconds() // 60)
            closerate = self._get_close_rate(sell_row, trade, sell, trade_dur)

--- a/freqtrade/optimize/optimize_reports.py
+++ b/freqtrade/optimize/optimize_reports.py
@ -55,6 +55,15 @@ def _get_line_header(first_column: str, stake_currency: str) -> List[str]:
            'Win  Draw  Loss  Win%']


+def _get_line_header_sell(first_column: str, stake_currency: str) -> List[str]:
+    """
+    Generate header lines (goes in line with _generate_result_line())
+    """
+    return [first_column, 'Sells', 'Avg Profit %', 'Cum Profit %',
+            f'Tot Profit {stake_currency}', 'Tot Profit %', 'Avg Duration',
+            'Win  Draw  Loss  Win%']
+
+
 def _generate_wins_draws_losses(wins, draws, losses):
    if wins > 0 and losses == 0:
        wl_ratio = '100'
@ -127,6 +136,71 @@ def generate_pair_metrics(data: Dict[str, Dict], stake_currency: str, starting_b
    return tabular_data


+def generate_tag_metrics(tag_type: str,
+                         starting_balance: int,
+                         results: DataFrame,
+                         skip_nan: bool = False) -> List[Dict]:
+    """
+    Generates and returns a list of metrics for the given tag trades and the results dataframe
+    :param starting_balance: Starting balance
+    :param results: Dataframe containing the backtest results
+    :param skip_nan: Print "left open" open trades
+    :return: List of Dicts containing the metrics per pair
+    """
+
+    tabular_data = []
+
+    if tag_type in results.columns:
+        for tag, count in results[tag_type].value_counts().iteritems():
+            result = results[results[tag_type] == tag]
+            if skip_nan and result['profit_abs'].isnull().all():
+                continue
+
+            tabular_data.append(_generate_tag_result_line(result, starting_balance, tag))
+
+        # Sort by total profit %:
+        tabular_data = sorted(tabular_data, key=lambda k: k['profit_total_abs'], reverse=True)
+
+        # Append Total
+        tabular_data.append(_generate_result_line(results, starting_balance, 'TOTAL'))
+        return tabular_data
+    else:
+        return []
+
+
+def _generate_tag_result_line(result: DataFrame, starting_balance: int, first_column: str) -> Dict:
+    """
+    Generate one result dict, with "first_column" as key.
+    """
+    profit_sum = result['profit_ratio'].sum()
+    # (end-capital - starting capital) / starting capital
+    profit_total = result['profit_abs'].sum() / starting_balance
+
+    return {
+        'key': first_column,
+        'trades': len(result),
+        'profit_mean': result['profit_ratio'].mean() if len(result) > 0 else 0.0,
+        'profit_mean_pct': result['profit_ratio'].mean() * 100.0 if len(result) > 0 else 0.0,
+        'profit_sum': profit_sum,
+        'profit_sum_pct': round(profit_sum * 100.0, 2),
+        'profit_total_abs': result['profit_abs'].sum(),
+        'profit_total': profit_total,
+        'profit_total_pct': round(profit_total * 100.0, 2),
+        'duration_avg': str(timedelta(
+                            minutes=round(result['trade_duration'].mean()))
+                            ) if not result.empty else '0:00',
+        # 'duration_max': str(timedelta(
+        #                     minutes=round(result['trade_duration'].max()))
+        #                     ) if not result.empty else '0:00',
+        # 'duration_min': str(timedelta(
+        #                     minutes=round(result['trade_duration'].min()))
+        #                     ) if not result.empty else '0:00',
+        'wins': len(result[result['profit_abs'] > 0]),
+        'draws': len(result[result['profit_abs'] == 0]),
+        'losses': len(result[result['profit_abs'] < 0]),
+    }
+
+
 def generate_sell_reason_stats(max_open_trades: int, results: DataFrame) -> List[Dict]:
    """
    Generate small table outlining Backtest results
@ -347,6 +421,10 @@ def generate_strategy_stats(btdata: Dict[str, DataFrame],
    pair_results = generate_pair_metrics(btdata, stake_currency=stake_currency,
                                         starting_balance=starting_balance,
                                         results=results, skip_nan=False)
+
+    buy_tag_results = generate_tag_metrics("buy_tag", starting_balance=starting_balance,
+                                           results=results, skip_nan=False)
+
    sell_reason_stats = generate_sell_reason_stats(max_open_trades=max_open_trades,
                                                   results=results)
    left_open_results = generate_pair_metrics(btdata, stake_currency=stake_currency,
@ -370,6 +448,7 @@ def generate_strategy_stats(btdata: Dict[str, DataFrame],
        'best_pair': best_pair,
        'worst_pair': worst_pair,
        'results_per_pair': pair_results,
+        'results_per_buy_tag': buy_tag_results,
        'sell_reason_summary': sell_reason_stats,
        'left_open_trades': left_open_results,
        # 'days_breakdown_stats': days_breakdown_stats,
@ -542,6 +621,37 @@ def text_table_sell_reason(sell_reason_stats: List[Dict[str, Any]], stake_curren
    return tabulate(output, headers=headers, tablefmt="orgtbl", stralign="right")


+def text_table_tags(tag_type: str, tag_results: List[Dict[str, Any]], stake_currency: str) -> str:
+    """
+    Generates and returns a text table for the given backtest data and the results dataframe
+    :param pair_results: List of Dictionaries - one entry per pair + final TOTAL row
+    :param stake_currency: stake-currency - used to correctly name headers
+    :return: pretty printed table with tabulate as string
+    """
+    if(tag_type == "buy_tag"):
+        headers = _get_line_header("TAG", stake_currency)
+    else:
+        headers = _get_line_header_sell("TAG", stake_currency)
+    floatfmt = _get_line_floatfmt(stake_currency)
+    output = [
+        [
+            t['key'] if t['key'] is not None and len(
+                t['key']) > 0 else "OTHER",
+            t['trades'],
+            t['profit_mean_pct'],
+            t['profit_sum_pct'],
+            t['profit_total_abs'],
+            t['profit_total_pct'],
+            t['duration_avg'],
+            _generate_wins_draws_losses(
+                t['wins'],
+                t['draws'],
+                t['losses'])] for t in tag_results]
+    # Ignore type as floatfmt does allow tuples but mypy does not know that
+    return tabulate(output, headers=headers,
+                    floatfmt=floatfmt, tablefmt="orgtbl", stralign="right")
+
+
 def text_table_periodic_breakdown(days_breakdown_stats: List[Dict[str, Any]],
                                  stake_currency: str, period: str) -> str:
    """
@ -687,6 +797,16 @@ def show_backtest_result(strategy: str, results: Dict[str, Any], stake_currency:
        print(' BACKTESTING REPORT '.center(len(table.splitlines()[0]), '='))
    print(table)

+    if results.get('results_per_buy_tag') is not None:
+        table = text_table_tags(
+            "buy_tag",
+            results['results_per_buy_tag'],
+            stake_currency=stake_currency)
+
+        if isinstance(table, str) and len(table) > 0:
+            print(' BUY TAG STATS '.center(len(table.splitlines()[0]), '='))
+        print(table)
+
    table = text_table_sell_reason(sell_reason_stats=results['sell_reason_summary'],
                                   stake_currency=stake_currency)
    if isinstance(table, str) and len(table) > 0:
@ -714,6 +834,7 @@ def show_backtest_result(strategy: str, results: Dict[str, Any], stake_currency:

    if isinstance(table, str) and len(table) > 0:
        print('=' * len(table.splitlines()[0]))
+
    print()


@ -735,3 +856,13 @@ def show_backtest_results(config: Dict, backtest_stats: Dict):
        print(table)
        print('=' * len(table.splitlines()[0]))
        print('\nFor more details, please look at the detail tables above')
+
+
+def show_sorted_pairlist(config: Dict, backtest_stats: Dict):
+    if config.get('backtest_show_pair_list', False):
+        for strategy, results in backtest_stats['strategy'].items():
+            print(f"Pairs for Strategy {strategy}: \n[")
+            for result in results['results_per_pair']:
+                if result["key"] != 'TOTAL':
+                    print(f'"{result["key"]}",  // {round(result["profit_mean_pct"], 2)}%')
+            print("]")
--- a/freqtrade/persistence/models.py
+++ b/freqtrade/persistence/models.py
@ -1080,13 +1080,131 @@ class Trade(_DECL_BASE, LocalTrade):
        return [
            {
                'pair': pair,
-                'profit': profit,
+                'profit_ratio': profit,
+                'profit': round(profit * 100, 2),  # Compatibility mode
+                'profit_pct': round(profit * 100, 2),
                'profit_abs': profit_abs,
                'count': count
            }
            for pair, profit, profit_abs, count in pair_rates
        ]

+    @staticmethod
+    def get_buy_tag_performance(pair: Optional[str]) -> List[Dict[str, Any]]:
+        """
+        Returns List of dicts containing all Trades, based on buy tag performance
+        Can either be average for all pairs or a specific pair provided
+        NOTE: Not supported in Backtesting.
+        """
+
+        filters = [Trade.is_open.is_(False)]
+        if(pair is not None):
+            filters.append(Trade.pair == pair)
+
+        buy_tag_perf = Trade.query.with_entities(
+            Trade.buy_tag,
+            func.sum(Trade.close_profit).label('profit_sum'),
+            func.sum(Trade.close_profit_abs).label('profit_sum_abs'),
+            func.count(Trade.pair).label('count')
+        ).filter(*filters)\
+            .group_by(Trade.buy_tag) \
+            .order_by(desc('profit_sum_abs')) \
+            .all()
+
+        return [
+            {
+                'buy_tag': buy_tag if buy_tag is not None else "Other",
+                'profit_ratio': profit,
+                'profit_pct': round(profit * 100, 2),
+                'profit_abs': profit_abs,
+                'count': count
+            }
+            for buy_tag, profit, profit_abs, count in buy_tag_perf
+        ]
+
+    @staticmethod
+    def get_sell_reason_performance(pair: Optional[str]) -> List[Dict[str, Any]]:
+        """
+        Returns List of dicts containing all Trades, based on sell reason performance
+        Can either be average for all pairs or a specific pair provided
+        NOTE: Not supported in Backtesting.
+        """
+
+        filters = [Trade.is_open.is_(False)]
+        if(pair is not None):
+            filters.append(Trade.pair == pair)
+
+        sell_tag_perf = Trade.query.with_entities(
+            Trade.sell_reason,
+            func.sum(Trade.close_profit).label('profit_sum'),
+            func.sum(Trade.close_profit_abs).label('profit_sum_abs'),
+            func.count(Trade.pair).label('count')
+        ).filter(*filters)\
+            .group_by(Trade.sell_reason) \
+            .order_by(desc('profit_sum_abs')) \
+            .all()
+
+        return [
+            {
+                'sell_reason': sell_reason if sell_reason is not None else "Other",
+                'profit_ratio': profit,
+                'profit_pct': round(profit * 100, 2),
+                'profit_abs': profit_abs,
+                'count': count
+            }
+            for sell_reason, profit, profit_abs, count in sell_tag_perf
+        ]
+
+    @staticmethod
+    def get_mix_tag_performance(pair: Optional[str]) -> List[Dict[str, Any]]:
+        """
+        Returns List of dicts containing all Trades, based on buy_tag + sell_reason performance
+        Can either be average for all pairs or a specific pair provided
+        NOTE: Not supported in Backtesting.
+        """
+
+        filters = [Trade.is_open.is_(False)]
+        if(pair is not None):
+            filters.append(Trade.pair == pair)
+
+        mix_tag_perf = Trade.query.with_entities(
+            Trade.id,
+            Trade.buy_tag,
+            Trade.sell_reason,
+            func.sum(Trade.close_profit).label('profit_sum'),
+            func.sum(Trade.close_profit_abs).label('profit_sum_abs'),
+            func.count(Trade.pair).label('count')
+        ).filter(*filters)\
+            .group_by(Trade.id) \
+            .order_by(desc('profit_sum_abs')) \
+            .all()
+
+        return_list: List[Dict] = []
+        for id, buy_tag, sell_reason, profit, profit_abs, count in mix_tag_perf:
+            buy_tag = buy_tag if buy_tag is not None else "Other"
+            sell_reason = sell_reason if sell_reason is not None else "Other"
+
+            if(sell_reason is not None and buy_tag is not None):
+                mix_tag = buy_tag + " " + sell_reason
+                i = 0
+                if not any(item["mix_tag"] == mix_tag for item in return_list):
+                    return_list.append({'mix_tag': mix_tag,
+                                        'profit': profit,
+                                        'profit_abs': profit_abs,
+                                        'count': count})
+                else:
+                    while i < len(return_list):
+                        if return_list[i]["mix_tag"] == mix_tag:
+                            return_list[i] = {
+                                'mix_tag': mix_tag,
+                                'profit': profit + return_list[i]["profit"],
+                                'profit_abs': profit_abs + return_list[i]["profit_abs"],
+                                'count': 1 + return_list[i]["count"]}
+                        i += 1
+
+        [x.update({'profit': round(x['profit'] * 100, 2)}) for x in return_list]
+        return return_list
+
    @staticmethod
    def get_best_pair(start_date: datetime = datetime.fromtimestamp(0)):
        """
--- a/freqtrade/rpc/api_server/api_schemas.py
+++ b/freqtrade/rpc/api_server/api_schemas.py
@ -63,6 +63,8 @@ class Count(BaseModel):
 class PerformanceEntry(BaseModel):
    pair: str
    profit: float
+    profit_ratio: float
+    profit_pct: float
    profit_abs: float
    count: int

--- a/freqtrade/rpc/rpc.py
+++ b/freqtrade/rpc/rpc.py
@ -683,10 +683,36 @@ class RPC:
        Shows a performance statistic from finished trades
        """
        pair_rates = Trade.get_overall_performance()
-        # Round and convert to %
-        [x.update({'profit': round(x['profit'] * 100, 2)}) for x in pair_rates]
+
        return pair_rates

+    def _rpc_buy_tag_performance(self, pair: Optional[str]) -> List[Dict[str, Any]]:
+        """
+        Handler for buy tag performance.
+        Shows a performance statistic from finished trades
+        """
+        buy_tags = Trade.get_buy_tag_performance(pair)
+
+        return buy_tags
+
+    def _rpc_sell_reason_performance(self, pair: Optional[str]) -> List[Dict[str, Any]]:
+        """
+        Handler for sell reason performance.
+        Shows a performance statistic from finished trades
+        """
+        sell_reasons = Trade.get_sell_reason_performance(pair)
+
+        return sell_reasons
+
+    def _rpc_mix_tag_performance(self, pair: Optional[str]) -> List[Dict[str, Any]]:
+        """
+        Handler for mix tag (buy_tag + sell_reason) performance.
+        Shows a performance statistic from finished trades
+        """
+        mix_tags = Trade.get_mix_tag_performance(pair)
+
+        return mix_tags
+
    def _rpc_count(self) -> Dict[str, float]:
        """ Returns the number of trades running """
        if self._freqtrade.state != State.RUNNING:
--- a/freqtrade/rpc/telegram.py
+++ b/freqtrade/rpc/telegram.py
@ -107,8 +107,8 @@ class Telegram(RPCHandler):
        #       this needs refactoring of the whole telegram module (same
        #       problem in _help()).
        valid_keys: List[str] = [r'/start$', r'/stop$', r'/status$', r'/status table$',
-                                 r'/trades$', r'/performance$', r'/daily$', r'/daily \d+$',
-                                 r'/profit$', r'/profit \d+',
+                                 r'/trades$', r'/performance$', r'/buys', r'/sells', r'/mix_tags',
+                                 r'/daily$', r'/daily \d+$', r'/profit$', r'/profit \d+',
                                 r'/stats$', r'/count$', r'/locks$', r'/balance$',
                                 r'/stopbuy$', r'/reload_config$', r'/show_config$',
                                 r'/logs$', r'/whitelist$', r'/blacklist$', r'/edge$',
@ -154,6 +154,9 @@ class Telegram(RPCHandler):
            CommandHandler('trades', self._trades),
            CommandHandler('delete', self._delete_trade),
            CommandHandler('performance', self._performance),
+            CommandHandler('buys', self._buy_tag_performance),
+            CommandHandler('sells', self._sell_reason_performance),
+            CommandHandler('mix_tags', self._mix_tag_performance),
            CommandHandler('stats', self._stats),
            CommandHandler('daily', self._daily),
            CommandHandler('count', self._count),
@ -175,6 +178,10 @@ class Telegram(RPCHandler):
            CallbackQueryHandler(self._profit, pattern='update_profit'),
            CallbackQueryHandler(self._balance, pattern='update_balance'),
            CallbackQueryHandler(self._performance, pattern='update_performance'),
+            CallbackQueryHandler(self._buy_tag_performance, pattern='update_buy_tag_performance'),
+            CallbackQueryHandler(self._sell_reason_performance,
+                                 pattern='update_sell_reason_performance'),
+            CallbackQueryHandler(self._mix_tag_performance, pattern='update_mix_tag_performance'),
            CallbackQueryHandler(self._count, pattern='update_count'),
            CallbackQueryHandler(self._forcebuy_inline),
        ]
@ -238,6 +245,7 @@ class Telegram(RPCHandler):
            microsecond=0) - msg['open_date'].replace(microsecond=0)
        msg['duration_min'] = msg['duration'].total_seconds() / 60

+        msg['buy_tag'] = msg['buy_tag'] if "buy_tag" in msg.keys() else None
        msg['emoji'] = self._get_sell_emoji(msg)

        # Check if all sell properties are available.
@ -253,6 +261,7 @@ class Telegram(RPCHandler):

        message = ("{emoji} *{exchange}:* Selling {pair} (#{trade_id})\n"
                   "*Profit:* `{profit_percent:.2f}%{profit_extra}`\n"
+                   "*Buy Tag:* `{buy_tag}`\n"
                   "*Sell Reason:* `{sell_reason}`\n"
                   "*Duration:* `{duration} ({duration_min:.1f} min)`\n"
                   "*Amount:* `{amount:.8f}`\n"
@ -852,7 +861,7 @@ class Telegram(RPCHandler):
                stat_line = (
                    f"{i+1}.\t <code>{trade['pair']}\t"
                    f"{round_coin_value(trade['profit_abs'], self._config['stake_currency'])} "
-                    f"({trade['profit']:.2f}%) "
+                    f"({trade['profit_pct']:.2f}%) "
                    f"({trade['count']})</code>\n")

                if len(output + stat_line) >= MAX_TELEGRAM_MESSAGE_LENGTH:
@ -867,6 +876,111 @@ class Telegram(RPCHandler):
        except RPCException as e:
            self._send_msg(str(e))

+    @authorized_only
+    def _buy_tag_performance(self, update: Update, context: CallbackContext) -> None:
+        """
+        Handler for /buys PAIR .
+        Shows a performance statistic from finished trades
+        :param bot: telegram bot
+        :param update: message update
+        :return: None
+        """
+        try:
+            pair = None
+            if context.args and isinstance(context.args[0], str):
+                pair = context.args[0]
+
+            trades = self._rpc._rpc_buy_tag_performance(pair)
+            output = "<b>Buy Tag Performance:</b>\n"
+            for i, trade in enumerate(trades):
+                stat_line = (
+                    f"{i+1}.\t <code>{trade['buy_tag']}\t"
+                    f"{round_coin_value(trade['profit_abs'], self._config['stake_currency'])} "
+                    f"({trade['profit_pct']:.2f}%) "
+                    f"({trade['count']})</code>\n")
+
+                if len(output + stat_line) >= MAX_TELEGRAM_MESSAGE_LENGTH:
+                    self._send_msg(output, parse_mode=ParseMode.HTML)
+                    output = stat_line
+                else:
+                    output += stat_line
+
+            self._send_msg(output, parse_mode=ParseMode.HTML,
+                           reload_able=True, callback_path="update_buy_tag_performance",
+                           query=update.callback_query)
+        except RPCException as e:
+            self._send_msg(str(e))
+
+    @authorized_only
+    def _sell_reason_performance(self, update: Update, context: CallbackContext) -> None:
+        """
+        Handler for /sells.
+        Shows a performance statistic from finished trades
+        :param bot: telegram bot
+        :param update: message update
+        :return: None
+        """
+        try:
+            pair = None
+            if context.args and isinstance(context.args[0], str):
+                pair = context.args[0]
+
+            trades = self._rpc._rpc_sell_reason_performance(pair)
+            output = "<b>Sell Reason Performance:</b>\n"
+            for i, trade in enumerate(trades):
+                stat_line = (
+                    f"{i+1}.\t <code>{trade['sell_reason']}\t"
+                    f"{round_coin_value(trade['profit_abs'], self._config['stake_currency'])} "
+                    f"({trade['profit_pct']:.2f}%) "
+                    f"({trade['count']})</code>\n")
+
+                if len(output + stat_line) >= MAX_TELEGRAM_MESSAGE_LENGTH:
+                    self._send_msg(output, parse_mode=ParseMode.HTML)
+                    output = stat_line
+                else:
+                    output += stat_line
+
+            self._send_msg(output, parse_mode=ParseMode.HTML,
+                           reload_able=True, callback_path="update_sell_reason_performance",
+                           query=update.callback_query)
+        except RPCException as e:
+            self._send_msg(str(e))
+
+    @authorized_only
+    def _mix_tag_performance(self, update: Update, context: CallbackContext) -> None:
+        """
+        Handler for /mix_tags.
+        Shows a performance statistic from finished trades
+        :param bot: telegram bot
+        :param update: message update
+        :return: None
+        """
+        try:
+            pair = None
+            if context.args and isinstance(context.args[0], str):
+                pair = context.args[0]
+
+            trades = self._rpc._rpc_mix_tag_performance(pair)
+            output = "<b>Mix Tag Performance:</b>\n"
+            for i, trade in enumerate(trades):
+                stat_line = (
+                    f"{i+1}.\t <code>{trade['mix_tag']}\t"
+                    f"{round_coin_value(trade['profit_abs'], self._config['stake_currency'])} "
+                    f"({trade['profit']:.2f}%) "
+                    f"({trade['count']})</code>\n")
+
+                if len(output + stat_line) >= MAX_TELEGRAM_MESSAGE_LENGTH:
+                    self._send_msg(output, parse_mode=ParseMode.HTML)
+                    output = stat_line
+                else:
+                    output += stat_line
+
+            self._send_msg(output, parse_mode=ParseMode.HTML,
+                           reload_able=True, callback_path="update_mix_tag_performance",
+                           query=update.callback_query)
+        except RPCException as e:
+            self._send_msg(str(e))
+
    @authorized_only
    def _count(self, update: Update, context: CallbackContext) -> None:
        """
@ -1043,6 +1157,9 @@ class Telegram(RPCHandler):
                   "         *table :* `will display trades in a table`\n"
                   "                `pending buy orders are marked with an asterisk (*)`\n"
                   "                `pending sell orders are marked with a double asterisk (**)`\n"
+                   "*/buys <pair|none>:* `Shows the buy_tag performance`\n"
+                   "*/sells <pair|none>:* `Shows the sell reason performance`\n"
+                   "*/mix_tags <pair|none>:* `Shows combined buy tag + sell reason performance`\n"
                   "*/trades [limit]:* `Lists last closed trades (limited to 10 by default)`\n"
                   "*/profit [<n>]:* `Lists cumulative profit from all finished trades, "
                   "over the last n days`\n"
--- a/freqtrade/strategy/interface.py
+++ b/freqtrade/strategy/interface.py
@ -530,6 +530,7 @@ class IStrategy(ABC, HyperStrategyMixin):
            dataframe[SignalType.ENTER_SHORT.value] = 0
            dataframe[SignalType.EXIT_SHORT.value] = 0
            dataframe[SignalTagType.ENTER_TAG.value] = None
+            dataframe[SignalTagType.EXIT_TAG.value] = None

        # Other Defs in strategy that want to be called every loop here
        # twitter_sell = self.watch_twitter_feed(dataframe, metadata)
@ -643,7 +644,7 @@ class IStrategy(ABC, HyperStrategyMixin):
        timeframe: str,
        dataframe: DataFrame,
        is_short: bool = None
-    ) -> Tuple[bool, bool]:
+    ) -> Tuple[bool, bool, Optional[str]]:
        """
        Calculates current exit signal based based on the buy/short or sell/exit_short
        columns of the dataframe.
@ -657,19 +658,21 @@ class IStrategy(ABC, HyperStrategyMixin):
        """
        latest, latest_date = self.get_latest_candle(pair, timeframe, dataframe)
        if latest is None:
-            return False, False
+            return False, False, None

        if is_short:
            enter = latest.get(SignalType.ENTER_SHORT.value, 0) == 1
            exit_ = latest.get(SignalType.EXIT_SHORT.value, 0) == 1
+
        else:
            enter = latest[SignalType.ENTER_LONG.value] == 1
            exit_ = latest.get(SignalType.EXIT_LONG.value, 0) == 1
+        exit_tag = latest.get(SignalTagType.EXIT_TAG.value, None)

        logger.debug(f"exit-trigger: {latest['date']} (pair={pair}) "
                     f"enter={enter} exit={exit_}")

-        return enter, exit_
+        return enter, exit_, exit_tag

    def get_entry_signal(
        self,
--- a/freqtrade/templates/base_config.json.j2
+++ b/freqtrade/templates/base_config.json.j2
@ -10,8 +10,7 @@
    "stake_currency": "{{ stake_currency }}",
    "stake_amount": {{ stake_amount }},
    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "{{ fiat_display_currency }}",
-    "timeframe": "{{ timeframe }}",
+    "fiat_display_currency": "{{ fiat_display_currency }}",{{ ('\n    "timeframe": "' + timeframe + '",') if timeframe else '' }}
    "dry_run": {{ dry_run | lower }},
    "cancel_open_orders_on_exit": false,
    "unfilledtimeout": {
--- a/freqtrade/templates/subtemplates/exchange_okex.j2
+++ b/freqtrade/templates/subtemplates/exchange_okex.j2
@ -0,0 +1,12 @@
+"exchange": {
+    "name": "{{ exchange_name | lower }}",
+    "key": "{{ exchange_key }}",
+    "secret": "{{ exchange_secret }}",
+    "password": "{{ exchange_key_password }}",
+    "ccxt_config": {},
+    "ccxt_async_config": {},
+    "pair_whitelist": [
+    ],
+    "pair_blacklist": [
+    ]
+}
--- a/requirements-hyperopt.txt
+++ b/requirements-hyperopt.txt
@ -3,9 +3,9 @@

 # Required for hyperopt
 scipy==1.7.1
-scikit-learn==1.0
+scikit-learn==1.0.1
 scikit-optimize==0.9.0
-filelock==3.3.1
+filelock==3.3.2
 joblib==1.1.0
 psutil==5.8.0
 progressbar2==3.55.0
--- a/requirements.txt
+++ b/requirements.txt
@ -2,7 +2,7 @@ numpy==1.21.3
 pandas==1.3.4
 pandas-ta==0.3.14b

-ccxt==1.59.2
+ccxt==1.60.11
 # Pin cryptography for now due to rust build errors with piwheels
 cryptography==35.0.0
 aiohttp==3.7.4.post0
--- a/setup.py
+++ b/setup.py
@ -43,7 +43,7 @@ setup(
    ],
    install_requires=[
        # from requirements.txt
-        'ccxt>=1.50.48',
+        'ccxt>=1.60.11',
        'SQLAlchemy',
        'python-telegram-bot>=13.4',
        'arrow>=0.17.0',
--- a/setup.sh
+++ b/setup.sh
@ -1,12 +1,16 @@
 #!/usr/bin/env bash
 #encoding=utf8

+function echo_block() {
+    echo "----------------------------"
+    echo $1
+    echo "----------------------------"
+}
+
 function check_installed_pip() {
   ${PYTHON} -m pip > /dev/null
   if [ $? -ne 0 ]; then
-        echo "-----------------------------"
-        echo "Installing Pip for ${PYTHON}"
-        echo "-----------------------------"
+        echo_block "Installing Pip for ${PYTHON}"
        curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
        ${PYTHON} get-pip.py
        rm get-pip.py
@ -37,9 +41,7 @@ function check_installed_python() {
 }

 function updateenv() {
-    echo "-------------------------"
-    echo "Updating your virtual env"
-    echo "-------------------------"
+    echo_block "Updating your virtual env"
    if [ ! -f .env/bin/activate ]; then
        echo "Something went wrong, no virtual environment found."
        exit 1
@ -110,18 +112,14 @@ function install_mac_newer_python_dependencies() {

    if [ ! $(brew --prefix --installed hdf5 2>/dev/null) ]
    then
-        echo "-------------------------"
-        echo "Installing hdf5"
-        echo "-------------------------"
+        echo_block "Installing hdf5"
        brew install hdf5
    fi
    export HDF5_DIR=$(brew --prefix)

    if [ ! $(brew --prefix --installed c-blosc 2>/dev/null) ]
    then
-        echo "-------------------------"
-        echo "Installing c-blosc"
-        echo "-------------------------"
+        echo_block "Installing c-blosc"
        brew install c-blosc
    fi
    export CBLOSC_DIR=$(brew --prefix)
@ -131,9 +129,7 @@ function install_mac_newer_python_dependencies() {
 function install_macos() {
    if [ ! -x "$(command -v brew)" ]
    then
-        echo "-------------------------"
-        echo "Installing Brew"
-        echo "-------------------------"
+        echo_block "Installing Brew"
        /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
    fi
    #Gets number after decimal in python version
@ -148,7 +144,14 @@ function install_macos() {
 # Install bot Debian_ubuntu
 function install_debian() {
    sudo apt-get update
-    sudo apt-get install -y build-essential autoconf libtool pkg-config make wget git $(echo lib${PYTHON}-dev ${PYTHON}-venv)
+    sudo apt-get install -y gcc build-essential autoconf libtool pkg-config make wget git $(echo lib${PYTHON}-dev ${PYTHON}-venv)
+    install_talib
+}
+
+# Install bot RedHat_CentOS
+function install_redhat() {
+    sudo yum update
+    sudo yum install -y gcc gcc-c++ make autoconf libtool pkg-config wget git $(echo ${PYTHON}-devel | sed 's/\.//g')
    install_talib
 }

@ -160,9 +163,7 @@ function update() {

 # Reset Develop or Stable branch
 function reset() {
-    echo "----------------------------"
-    echo "Resetting branch and virtual env"
-    echo "----------------------------"
+    echo_block "Resetting branch and virtual env"

    if [ "1" == $(git branch -vv |grep -cE "\* develop|\* stable") ]
    then
@ -200,48 +201,39 @@ function reset() {
 }

 function config() {
-
-    echo "-------------------------"
-    echo "Please use 'freqtrade new-config -c config.json' to generate a new configuration file."
-    echo "-------------------------"
+    echo_block "Please use 'freqtrade new-config -c config.json' to generate a new configuration file."
 }

 function install() {
-    echo "-------------------------"
-    echo "Installing mandatory dependencies"
-    echo "-------------------------"
    
-    if [ "$(uname -s)" == "Darwin" ]
-    then
+    echo_block "Installing mandatory dependencies"
+
+    if [ "$(uname -s)" == "Darwin" ]; then
        echo "macOS detected. Setup for this system in-progress"
        install_macos
-    elif [ -x "$(command -v apt-get)" ]
-    then
+    elif [ -x "$(command -v apt-get)" ]; then
        echo "Debian/Ubuntu detected. Setup for this system in-progress"
        install_debian
+    elif [ -x "$(command -v yum)" ]; then
+        echo "Red Hat/CentOS detected. Setup for this system in-progress"
+        install_redhat
    else
        echo "This script does not support your OS."
-        echo "If you have Python3.6 or Python3.7, pip, virtualenv, ta-lib you can continue."
+        echo "If you have Python version 3.7 - 3.9, pip, virtualenv, ta-lib you can continue."
        echo "Wait 10 seconds to continue the next install steps or use ctrl+c to interrupt this shell."
        sleep 10
    fi
    echo
    reset
    config
-    echo "-------------------------"
-    echo "Run the bot !"
-    echo "-------------------------"
+    echo_block "Run the bot !"
    echo "You can now use the bot by executing 'source .env/bin/activate; freqtrade <subcommand>'."
    echo "You can see the list of available bot sub-commands by executing 'source .env/bin/activate; freqtrade --help'."
    echo "You verify that freqtrade is installed successfully by running 'source .env/bin/activate; freqtrade --version'."
 }

 function plot() {
-    echo "
-    -----------------------------------------
-    Installing dependencies for Plotting scripts
-    -----------------------------------------
-    "
+    echo_block "Installing dependencies for Plotting scripts"
    ${PYTHON} -m pip install plotly --upgrade
 }

--- a/tests/commands/test_commands.py
+++ b/tests/commands/test_commands.py
@ -8,12 +8,12 @@ from zipfile import ZipFile
 import arrow
 import pytest

-from freqtrade.commands import (start_convert_data, start_convert_trades, start_create_userdir,
-                                start_download_data, start_hyperopt_list, start_hyperopt_show,
-                                start_install_ui, start_list_data, start_list_exchanges,
-                                start_list_markets, start_list_strategies, start_list_timeframes,
-                                start_new_strategy, start_show_trades, start_test_pairlist,
-                                start_trading, start_webserver)
+from freqtrade.commands import (start_backtesting_show, start_convert_data, start_convert_trades,
+                                start_create_userdir, start_download_data, start_hyperopt_list,
+                                start_hyperopt_show, start_install_ui, start_list_data,
+                                start_list_exchanges, start_list_markets, start_list_strategies,
+                                start_list_timeframes, start_new_strategy, start_show_trades,
+                                start_test_pairlist, start_trading, start_webserver)
 from freqtrade.commands.deploy_commands import (clean_ui_subdir, download_and_install_ui,
                                                get_ui_download_url, read_ui_version)
 from freqtrade.configuration import setup_utils_configuration
@ -1390,3 +1390,19 @@ def test_show_trades(mocker, fee, capsys, caplog):

    with pytest.raises(OperationalException, match=r"--db-url is required for this command."):
        start_show_trades(pargs)
+
+
+def test_backtesting_show(mocker, testdatadir, capsys):
+    sbr = mocker.patch('freqtrade.optimize.optimize_reports.show_backtest_results')
+    args = [
+        "backtesting-show",
+        "--export-filename",
+        f"{testdatadir / 'backtest-result_new.json'}",
+        "--show-pair-list"
+    ]
+    pargs = get_args(args)
+    pargs['config'] = None
+    start_backtesting_show(pargs)
+    assert sbr.call_count == 1
+    out, err = capsys.readouterr()
+    assert "Pairs for Strategy" in out
--- a/tests/conftest.py
+++ b/tests/conftest.py
@ -215,7 +215,8 @@ def patch_get_signal(
    exit_long=False,
    enter_short=False,
    exit_short=False,
-    enter_tag: Optional[str] = None
+    enter_tag: Optional[str] = None,
+    exit_tag: Optional[str] = None,
 ) -> None:
    """
    :param mocker: mocker to patch IStrategy class
@ -237,9 +238,9 @@ def patch_get_signal(

    def patched_get_exit_signal(pair, timeframe, dataframe, is_short):
        if is_short:
-            return enter_short, exit_short
+            return enter_short, exit_short, exit_tag
        else:
-            return enter_long, exit_long
+            return enter_long, exit_long, exit_tag

    # returns (enter, exit)
    freqtrade.strategy.get_exit_signal = patched_get_exit_signal
@ -247,7 +248,7 @@ def patch_get_signal(
    freqtrade.exchange.refresh_latest_ohlcv = lambda p: None


-def create_mock_trades(fee, is_short: bool, use_db: bool = True):
+def create_mock_trades(fee, is_short: bool = False, use_db: bool = True):
    """
    Create some fake trades ...
    """
--- a/tests/conftest_trades.py
+++ b/tests/conftest_trades.py
@ -102,6 +102,7 @@ def mock_trade_2(fee, is_short: bool):
        open_order_id=f'dry_run_sell_{direc(is_short)}_12345',
        strategy='StrategyTestV3',
        timeframe=5,
+        buy_tag='TEST1',
        sell_reason='sell_signal',
        open_date=datetime.now(tz=timezone.utc) - timedelta(minutes=20),
        close_date=datetime.now(tz=timezone.utc) - timedelta(minutes=2),
@ -257,6 +258,7 @@ def mock_trade_5(fee, is_short: bool):
        open_rate=0.123,
        exchange='binance',
        strategy='SampleStrategy',
+        buy_tag='TEST1',
        stoploss_order_id=f'prod_stoploss_{direc(is_short)}_3455',
        timeframe=5,
        is_short=is_short
@ -312,6 +314,7 @@ def mock_trade_6(fee, is_short: bool):
        open_rate=0.15,
        exchange='binance',
        strategy='SampleStrategy',
+        buy_tag='TEST2',
        open_order_id=f"prod_sell_{direc(is_short)}_6",
        timeframe=5,
    )
--- a/tests/exchange/test_ccxt_compat.py
+++ b/tests/exchange/test_ccxt_compat.py
@ -47,6 +47,11 @@ EXCHANGES = {
        'hasQuoteVolume': True,
        'timeframe': '5m',
    },
+    'okex': {
+        'pair': 'BTC/USDT',
+        'hasQuoteVolume': True,
+        'timeframe': '5m',
+    },
 }


--- a/tests/optimize/init.py
+++ b/tests/optimize/init.py
@ -58,4 +58,12 @@ def _build_backtest_dataframe(data):
        frame[column] = frame[column].astype('float64')
    if 'enter_tag' not in columns:
        frame['enter_tag'] = None
+    if 'exit_tag' not in columns:
+        frame['exit_tag'] = None
+
+    # Ensure all candles make kindof sense
+    assert all(frame['low'] <= frame['close'])
+    assert all(frame['low'] <= frame['open'])
+    assert all(frame['high'] >= frame['close'])
+    assert all(frame['high'] >= frame['open'])
    return frame
--- a/tests/optimize/test_backtest_detail.py
+++ b/tests/optimize/test_backtest_detail.py
@ -17,10 +17,10 @@ tc0 = BTContainer(data=[
    # D  O     H     L     C     V    B  S
    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],  # enter trade (signal on last candle)
-    [2, 4987, 5012, 4986, 4600, 6172, 0, 0],  # exit with stoploss hit
-    [3, 5010, 5000, 4980, 5010, 6172, 0, 1],
-    [4, 5010, 4987, 4977, 4995, 6172, 0, 0],
-    [5, 4995, 4995, 4995, 4950, 6172, 0, 0]],
+    [2, 4987, 5012, 4986, 4986, 6172, 0, 0],  # exit with stoploss hit
+    [3, 5010, 5010, 4980, 5010, 6172, 0, 1],
+    [4, 5010, 5011, 4977, 4995, 6172, 0, 0],
+    [5, 4995, 4995, 4950, 4950, 6172, 0, 0]],
    stop_loss=-0.01, roi={"0": 1}, profit_perc=0.002, use_sell_signal=True,
    trades=[BTrade(sell_reason=SellType.SELL_SIGNAL, open_tick=1, close_tick=4)]
 )
@ -32,9 +32,9 @@ tc1 = BTContainer(data=[
    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],  # enter trade (signal on last candle)
    [2, 4987, 5012, 4600, 4600, 6172, 0, 0],  # exit with stoploss hit
-    [3, 4975, 5000, 4980, 4977, 6172, 0, 0],
-    [4, 4977, 4987, 4977, 4995, 6172, 0, 0],
-    [5, 4995, 4995, 4995, 4950, 6172, 0, 0]],
+    [3, 4975, 5000, 4975, 4977, 6172, 0, 0],
+    [4, 4977, 4995, 4977, 4995, 6172, 0, 0],
+    [5, 4995, 4995, 4950, 4950, 6172, 0, 0]],
    stop_loss=-0.01, roi={"0": 1}, profit_perc=-0.01,
    trades=[BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=2)]
 )
@ -69,7 +69,7 @@ tc3 = BTContainer(data=[
    [3, 4975, 5000, 4950, 4962, 6172, 1, 0],
    [4, 4975, 5000, 4950, 4962, 6172, 0, 0],  # enter trade 2 (signal on last candle)
    [5, 4962, 4987, 4000, 4000, 6172, 0, 0],  # exit with stoploss hit
-    [6, 4950, 4975, 4975, 4950, 6172, 0, 0]],
+    [6, 4950, 4975, 4950, 4950, 6172, 0, 0]],
    stop_loss=-0.02, roi={"0": 1}, profit_perc=-0.04,
    trades=[BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=2),
            BTrade(sell_reason=SellType.STOP_LOSS, open_tick=4, close_tick=5)]
@ -99,7 +99,7 @@ tc5 = BTContainer(data=[
    [1, 5000, 5025, 4980, 4987, 6172, 0, 0],  # enter trade (signal on last candle)
    [2, 4987, 5025, 4975, 4987, 6172, 0, 0],
    [3, 4975, 6000, 4975, 6000, 6172, 0, 0],  # ROI
-    [4, 4962, 4987, 4972, 4950, 6172, 0, 0],
+    [4, 4962, 4987, 4962, 4972, 6172, 0, 0],
    [5, 4950, 4975, 4925, 4950, 6172, 0, 0]],
    stop_loss=-0.01, roi={"0": 0.03}, profit_perc=0.03,
    trades=[BTrade(sell_reason=SellType.ROI, open_tick=1, close_tick=3)]
@ -113,7 +113,7 @@ tc6 = BTContainer(data=[
    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],  # enter trade (signal on last candle)
    [2, 4987, 5300, 4850, 5050, 6172, 0, 0],  # Exit with stoploss
    [3, 4975, 5000, 4950, 4962, 6172, 0, 0],
-    [4, 4962, 4987, 4972, 4950, 6172, 0, 0],
+    [4, 4962, 4987, 4950, 4950, 6172, 0, 0],
    [5, 4950, 4975, 4925, 4950, 6172, 0, 0]],
    stop_loss=-0.02, roi={"0": 0.05}, profit_perc=-0.02,
    trades=[BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=2)]
@ -127,7 +127,7 @@ tc7 = BTContainer(data=[
    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],
    [2, 4987, 5300, 4950, 5050, 6172, 0, 0],
    [3, 4975, 5000, 4950, 4962, 6172, 0, 0],
-    [4, 4962, 4987, 4972, 4950, 6172, 0, 0],
+    [4, 4962, 4987, 4950, 4950, 6172, 0, 0],
    [5, 4950, 4975, 4925, 4950, 6172, 0, 0]],
    stop_loss=-0.02, roi={"0": 0.03}, profit_perc=0.03,
    trades=[BTrade(sell_reason=SellType.ROI, open_tick=1, close_tick=2)]
@ -167,7 +167,7 @@ tc9 = BTContainer(data=[
 tc10 = BTContainer(data=[
    # D   O     H     L     C    V    B  S
    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
-    [1, 5000, 5050, 4950, 5100, 6172, 0, 0],
+    [1, 5000, 5100, 4950, 5100, 6172, 0, 0],
    [2, 5100, 5251, 5100, 5100, 6172, 0, 0],
    [3, 4850, 5050, 4650, 4750, 6172, 0, 0],
    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
@ -183,7 +183,7 @@ tc10 = BTContainer(data=[
 tc11 = BTContainer(data=[
    # D   O     H     L     C    V    B  S
    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
-    [1, 5000, 5050, 4950, 5100, 6172, 0, 0],
+    [1, 5000, 5100, 4950, 5100, 6172, 0, 0],
    [2, 5100, 5251, 5100, 5100, 6172, 0, 0],
    [3, 5000, 5150, 4650, 4750, 6172, 0, 0],
    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
@ -199,7 +199,7 @@ tc11 = BTContainer(data=[
 tc12 = BTContainer(data=[
    # D   O     H     L     C    V    B  S
    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
-    [1, 5000, 5050, 4950, 5100, 6172, 0, 0],
+    [1, 5000, 5100, 4950, 5100, 6172, 0, 0],
    [2, 5100, 5251, 4650, 5100, 6172, 0, 0],
    [3, 4850, 5050, 4650, 4750, 6172, 0, 0],
    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
@ -216,8 +216,8 @@ tc13 = BTContainer(data=[
    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
    [1, 5000, 5100, 4950, 5100, 6172, 0, 0],
    [2, 5100, 5251, 4850, 5100, 6172, 0, 0],
-    [3, 4850, 5050, 4850, 4750, 6172, 0, 0],
-    [4, 4750, 4950, 4850, 4750, 6172, 0, 0]],
+    [3, 4850, 5050, 4750, 4750, 6172, 0, 0],
+    [4, 4750, 4950, 4750, 4750, 6172, 0, 0]],
    stop_loss=-0.10, roi={"0": 0.01}, profit_perc=0.01,
    trades=[BTrade(sell_reason=SellType.ROI, open_tick=1, close_tick=1)]
 )
@ -229,7 +229,7 @@ tc14 = BTContainer(data=[
    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
    [1, 5000, 5100, 4600, 5100, 6172, 0, 0],
    [2, 5100, 5251, 4850, 5100, 6172, 0, 0],
-    [3, 4850, 5050, 4850, 4750, 6172, 0, 0],
+    [3, 4850, 5050, 4750, 4750, 6172, 0, 0],
    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
    stop_loss=-0.05, roi={"0": 0.10}, profit_perc=-0.05,
    trades=[BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=1)]
@ -243,7 +243,7 @@ tc15 = BTContainer(data=[
    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
    [1, 5000, 5100, 4900, 5100, 6172, 1, 0],
    [2, 5100, 5251, 4650, 5100, 6172, 0, 0],
-    [3, 4850, 5050, 4850, 4750, 6172, 0, 0],
+    [3, 4850, 5050, 4750, 4750, 6172, 0, 0],
    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
    stop_loss=-0.05, roi={"0": 0.01}, profit_perc=-0.04,
    trades=[BTrade(sell_reason=SellType.ROI, open_tick=1, close_tick=1),
@ -259,7 +259,7 @@ tc16 = BTContainer(data=[
    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],
    [2, 4987, 5300, 4950, 5050, 6172, 0, 0],
    [3, 4975, 5000, 4940, 4962, 6172, 0, 0],  # ForceSell on ROI (roi=-1)
-    [4, 4962, 4987, 4972, 4950, 6172, 0, 0],
+    [4, 4962, 4987, 4950, 4950, 6172, 0, 0],
    [5, 4950, 4975, 4925, 4950, 6172, 0, 0]],
    stop_loss=-0.10, roi={"0": 0.10, "65": -1}, profit_perc=-0.012,
    trades=[BTrade(sell_reason=SellType.ROI, open_tick=1, close_tick=3)]
@ -275,7 +275,7 @@ tc17 = BTContainer(data=[
    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],
    [2, 4987, 5300, 4950, 5050, 6172, 0, 0],
    [3, 4980, 5000, 4940, 4962, 6172, 0, 0],  # ForceSell on ROI (roi=-1)
-    [4, 4962, 4987, 4972, 4950, 6172, 0, 0],
+    [4, 4962, 4987, 4950, 4950, 6172, 0, 0],
    [5, 4950, 4975, 4925, 4950, 6172, 0, 0]],
    stop_loss=-0.10, roi={"0": 0.10, "120": -1}, profit_perc=-0.004,
    trades=[BTrade(sell_reason=SellType.ROI, open_tick=1, close_tick=3)]
@ -291,7 +291,7 @@ tc18 = BTContainer(data=[
    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],
    [2, 4987, 5300, 4950, 5200, 6172, 0, 0],
    [3, 5200, 5220, 4940, 4962, 6172, 0, 0],  # Sell on ROI (sells on open)
-    [4, 4962, 4987, 4972, 4950, 6172, 0, 0],
+    [4, 4962, 4987, 4950, 4950, 6172, 0, 0],
    [5, 4950, 4975, 4925, 4950, 6172, 0, 0]],
    stop_loss=-0.10, roi={"0": 0.10, "120": 0.01}, profit_perc=0.04,
    trades=[BTrade(sell_reason=SellType.ROI, open_tick=1, close_tick=3)]
@ -306,8 +306,8 @@ tc19 = BTContainer(data=[
    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],
    [2, 4987, 5300, 4950, 5200, 6172, 0, 0],
    [3, 5000, 5300, 4940, 4962, 6172, 0, 0],  # Sell on ROI
-    [4, 4962, 4987, 4972, 4950, 6172, 0, 0],
-    [5, 4550, 4975, 4925, 4950, 6172, 0, 0]],
+    [4, 4962, 4987, 4950, 4950, 6172, 0, 0],
+    [5, 4550, 4975, 4550, 4950, 6172, 0, 0]],
    stop_loss=-0.10, roi={"0": 0.10, "120": 0.01}, profit_perc=0.01,
    trades=[BTrade(sell_reason=SellType.ROI, open_tick=1, close_tick=3)]
 )
@ -321,8 +321,8 @@ tc20 = BTContainer(data=[
    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],
    [2, 4987, 5300, 4950, 5200, 6172, 0, 0],
    [3, 5200, 5300, 4940, 4962, 6172, 0, 0],  # Sell on ROI
-    [4, 4962, 4987, 4972, 4950, 6172, 0, 0],
-    [5, 4550, 4975, 4925, 4950, 6172, 0, 0]],
+    [4, 4962, 4987, 4950, 4950, 6172, 0, 0],
+    [5, 4925, 4975, 4925, 4950, 6172, 0, 0]],
    stop_loss=-0.10, roi={"0": 0.10, "119": 0.01}, profit_perc=0.01,
    trades=[BTrade(sell_reason=SellType.ROI, open_tick=1, close_tick=3)]
 )
@ -334,7 +334,7 @@ tc20 = BTContainer(data=[
 tc21 = BTContainer(data=[
    # D   O     H     L     C    V    B  S
    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
-    [1, 5000, 5050, 4950, 5100, 6172, 0, 0],
+    [1, 5000, 5100, 4950, 5100, 6172, 0, 0],
    [2, 5100, 5251, 4650, 5100, 6172, 0, 0],
    [3, 4850, 5050, 4650, 4750, 6172, 0, 0],
    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
@ -350,7 +350,7 @@ tc21 = BTContainer(data=[
 tc22 = BTContainer(data=[
    # D   O     H     L     C    V    B  S
    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
-    [1, 5000, 5050, 4950, 5100, 6172, 0, 0],
+    [1, 5000, 5100, 4950, 5100, 6172, 0, 0],
    [2, 5100, 5251, 5100, 5100, 6172, 0, 0],
    [3, 4850, 5050, 4650, 4750, 6172, 0, 0],
    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
@ -369,7 +369,7 @@ tc22 = BTContainer(data=[
 tc23 = BTContainer(data=[
    # D   O     H     L     C    V    B  S
    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
-    [1, 5000, 5050, 4950, 5100, 6172, 0, 0],
+    [1, 5000, 5100, 4950, 5100, 6172, 0, 0],
    [2, 5100, 5251, 5100, 5100, 6172, 0, 0],
    [3, 4850, 5251, 4650, 4750, 6172, 0, 0],
    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
@ -386,10 +386,10 @@ tc24 = BTContainer(data=[
    # D  O     H     L     C     V    B  S
    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],  # enter trade (signal on last candle)
-    [2, 4987, 5012, 4986, 4600, 6172, 0, 0],
-    [3, 5010, 5000, 4855, 5010, 6172, 0, 1],  # Triggers stoploss + sellsignal
-    [4, 5010, 4987, 4977, 4995, 6172, 0, 0],
-    [5, 4995, 4995, 4995, 4950, 6172, 0, 0]],
+    [2, 4987, 5012, 4986, 4986, 6172, 0, 0],
+    [3, 5010, 5010, 4855, 5010, 6172, 0, 1],  # Triggers stoploss + sellsignal
+    [4, 5010, 5010, 4977, 4995, 6172, 0, 0],
+    [5, 4995, 4995, 4950, 4950, 6172, 0, 0]],
    stop_loss=-0.01, roi={"0": 1}, profit_perc=-0.01, use_sell_signal=True,
    trades=[BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=3)]
 )
@ -401,10 +401,10 @@ tc25 = BTContainer(data=[
    # D  O     H     L     C     V    B  S
    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],  # enter trade (signal on last candle)
-    [2, 4987, 5012, 4986, 4600, 6172, 0, 0],
-    [3, 5010, 5000, 4986, 5010, 6172, 0, 1],
-    [4, 5010, 4987, 4855, 4995, 6172, 0, 0],  # Triggers stoploss + sellsignal acted on
-    [5, 4995, 4995, 4995, 4950, 6172, 0, 0]],
+    [2, 4987, 5012, 4986, 4986, 6172, 0, 0],
+    [3, 5010, 5010, 4986, 5010, 6172, 0, 1],
+    [4, 5010, 5010, 4855, 4995, 6172, 0, 0],  # Triggers stoploss + sellsignal acted on
+    [5, 4995, 4995, 4950, 4950, 6172, 0, 0]],
    stop_loss=-0.01, roi={"0": 1}, profit_perc=0.002, use_sell_signal=True,
    trades=[BTrade(sell_reason=SellType.SELL_SIGNAL, open_tick=1, close_tick=4)]
 )
@ -416,10 +416,10 @@ tc26 = BTContainer(data=[
    # D  O     H     L     C     V    B  S
    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],  # enter trade (signal on last candle)
-    [2, 4987, 5012, 4986, 4600, 6172, 0, 0],
+    [2, 4987, 5012, 4986, 4986, 6172, 0, 0],
    [3, 5010, 5251, 4986, 5010, 6172, 0, 1],  # Triggers ROI, sell-signal
-    [4, 5010, 4987, 4855, 4995, 6172, 0, 0],
-    [5, 4995, 4995, 4995, 4950, 6172, 0, 0]],
+    [4, 5010, 5010, 4855, 4995, 6172, 0, 0],
+    [5, 4995, 4995, 4950, 4950, 6172, 0, 0]],
    stop_loss=-0.10, roi={"0": 0.05}, profit_perc=0.05, use_sell_signal=True,
    trades=[BTrade(sell_reason=SellType.ROI, open_tick=1, close_tick=3)]
 )
@ -432,10 +432,10 @@ tc27 = BTContainer(data=[
    # D  O     H     L     C     V    B  S
    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],  # enter trade (signal on last candle)
-    [2, 4987, 5012, 4986, 4600, 6172, 0, 0],
+    [2, 4987, 5012, 4986, 4986, 6172, 0, 0],
    [3, 5010, 5012, 4986, 5010, 6172, 0, 1],  # sell-signal
    [4, 5010, 5251, 4855, 4995, 6172, 0, 0],  # Triggers ROI, sell-signal acted on
-    [5, 4995, 4995, 4995, 4950, 6172, 0, 0]],
+    [5, 4995, 4995, 4950, 4950, 6172, 0, 0]],
    stop_loss=-0.10, roi={"0": 0.05}, profit_perc=0.05, use_sell_signal=True,
    trades=[BTrade(sell_reason=SellType.ROI, open_tick=1, close_tick=4)]
 )
@ -447,7 +447,7 @@ tc27 = BTContainer(data=[
 tc28 = BTContainer(data=[
    # D   O     H     L     C    V    B  S
    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
-    [1, 5000, 5050, 4950, 5100, 6172, 0, 0],
+    [1, 5000, 5100, 4950, 5100, 6172, 0, 0],
    [2, 5100, 5251, 5100, 5100, 6172, 0, 0],
    [3, 4850, 5050, 4650, 4750, 6172, 0, 0],
    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
@ -463,7 +463,7 @@ tc28 = BTContainer(data=[
 tc29 = BTContainer(data=[
    # D   O     H     L     C    V    B  S
    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
-    [1, 5000, 5050, 5000, 4900, 6172, 0, 0],    # enter trade (signal on last candle)
+    [1, 5000, 5050, 5000, 5000, 6172, 0, 0],    # enter trade (signal on last candle)
    [2, 4900, 5250, 4500, 5100, 6172, 0, 0],    # Triggers trailing-stoploss
    [3, 5100, 5100, 4650, 4750, 6172, 0, 0],
    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
@ -477,7 +477,7 @@ tc29 = BTContainer(data=[
 tc30 = BTContainer(data=[
    # D   O     H     L     C    V    B  S
    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
-    [1, 5000, 5500, 5000, 4900, 6172, 0, 0],    # enter trade (signal on last candle) and stop
+    [1, 5000, 5500, 4900, 4900, 6172, 0, 0],    # enter trade (signal on last candle) and stop
    [2, 4900, 5250, 4500, 5100, 6172, 0, 0],
    [3, 5100, 5100, 4650, 4750, 6172, 0, 0],
    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
@ -491,7 +491,7 @@ tc30 = BTContainer(data=[
 tc31 = BTContainer(data=[
    # D   O     H     L     C    V    B  S
    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
-    [1, 5000, 5500, 5000, 4900, 6172, 0, 0],    # enter trade (signal on last candle) and stop
+    [1, 5000, 5500, 4900, 4900, 6172, 0, 0],    # enter trade (signal on last candle) and stop
    [2, 4900, 5250, 4500, 5100, 6172, 0, 0],
    [3, 5100, 5100, 4650, 4750, 6172, 0, 0],
    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
@ -506,7 +506,7 @@ tc31 = BTContainer(data=[
 tc32 = BTContainer(data=[
    # D   O     H     L     C    V    B  S
    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
-    [1, 5000, 5500, 5000, 4900, 6172, 0, 0],    # enter trade (signal on last candle) and stop
+    [1, 5000, 5500, 4951, 5000, 6172, 0, 0],    # enter trade and stop
    [2, 4900, 5250, 4500, 5100, 6172, 0, 0],
    [3, 5100, 5100, 4650, 4750, 6172, 0, 0],
    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
@ -521,7 +521,7 @@ tc32 = BTContainer(data=[
 tc33 = BTContainer(data=[
    # D   O     H     L     C    V    EL XL ES Xs  BT
    [0, 5000, 5050, 4950, 5000, 6172, 1, 0, 0, 0, 'buy_signal_01'],
-    [1, 5000, 5500, 5000, 4900, 6172, 0, 0, 0, 0, None],  # enter trade and stop
+    [1, 5000, 5500, 4951, 5000, 6172, 0, 0, 0, 0, None],    # enter trade and stop
    [2, 4900, 5250, 4500, 5100, 6172, 0, 0, 0, 0, None],
    [3, 5100, 5100, 4650, 4750, 6172, 0, 0, 0, 0, None],
    [4, 4750, 4950, 4350, 4750, 6172, 0, 0, 0, 0, None]],
--- a/tests/optimize/test_backtesting.py
+++ b/tests/optimize/test_backtesting.py
@ -579,6 +579,7 @@ def test_backtest__get_sell_trade_entry(default_conf, fee, mocker) -> None:
        0,  # exit_hsort
        '',  # Long Signal Name
        '',  # Short Signal Name
+        '',  # Exit Signal Name
    ]

    trade = backtesting._enter_trade(pair, row=row, direction='long')
@ -596,27 +597,29 @@ def test_backtest__get_sell_trade_entry(default_conf, fee, mocker) -> None:
        0,  # exit_short
        '',  # long Signal Name
        '',  # Short Signal Name
+        '',  # Exit Signal Name
+
    ]
    row_detail = pd.DataFrame(
        [
            [
                pd.Timestamp(year=2020, month=1, day=1, hour=5, minute=0, tzinfo=timezone.utc),
-                200, 200.1, 197, 199, 1, 0, 0, 0, '', '',
+                200, 200.1, 197, 199, 1, 0, 0, 0, '', '', '',
            ], [
                pd.Timestamp(year=2020, month=1, day=1, hour=5, minute=1, tzinfo=timezone.utc),
-                199, 199.7, 199, 199.5, 0, 0, 0, 0, '', ''
+                199, 199.7, 199, 199.5, 0, 0, 0, 0, '', '', '',
            ], [
                pd.Timestamp(year=2020, month=1, day=1, hour=5, minute=2, tzinfo=timezone.utc),
-                199.5, 200.8, 199, 200.9, 0, 0, 0, 0, '', ''
+                199.5, 200.8, 199, 200.9, 0, 0, 0, 0, '', '', '',
            ], [
                pd.Timestamp(year=2020, month=1, day=1, hour=5, minute=3, tzinfo=timezone.utc),
-                200.5, 210.5, 193, 210.5, 0, 0, 0, 0, '', ''  # ROI sell (?)
+                200.5, 210.5, 193, 210.5, 0, 0, 0, 0, '', '', '',  # ROI sell (?)
            ], [
                pd.Timestamp(year=2020, month=1, day=1, hour=5, minute=4, tzinfo=timezone.utc),
-                200, 200.1, 193, 199, 0, 0, 0, 0, '', ''
+                200, 200.1, 193, 199, 0, 0, 0, 0, '', '', '',
            ],
        ], columns=['date', 'open', 'high', 'low', 'close', 'enter_long', 'exit_long',
-                    'enter_short', 'exit_short', 'long_tag', 'short_tag']
+                    'enter_short', 'exit_short', 'long_tag', 'short_tag', 'exit_tag']
    )

    # No data available.
@ -631,7 +634,7 @@ def test_backtest__get_sell_trade_entry(default_conf, fee, mocker) -> None:
    # Assign empty ... no result.
    backtesting.detail_data[pair] = pd.DataFrame(
        [], columns=['date', 'open', 'high', 'low', 'close', 'enter_long', 'exit_long',
-                     'enter_short', 'exit_short', 'long_tag', 'short_tag'])
+                     'enter_short', 'exit_short', 'long_tag', 'short_tag', 'exit_tag'])

    res = backtesting._get_sell_trade_entry(trade, row)
    assert res is None
@ -695,7 +698,7 @@ def test_backtest_one(default_conf, fee, mocker, testdatadir) -> None:
         'min_rate': [0.10370188, 0.10300000000000001],
         'max_rate': [0.10501, 0.1038888],
         'is_open': [False, False],
-         'buy_tag': [None, None],
+         'buy_tag': [None, None]
         })
    pd.testing.assert_frame_equal(results, expected)
    data_pair = processed[pair]
--- a/tests/optimize/test_optimize_reports.py
+++ b/tests/optimize/test_optimize_reports.py
@ -10,7 +10,8 @@ from arrow import Arrow
 from freqtrade.configuration import TimeRange
 from freqtrade.constants import DATETIME_PRINT_FORMAT, LAST_BT_RESULT_FN
 from freqtrade.data import history
-from freqtrade.data.btanalysis import get_latest_backtest_filename, load_backtest_data
+from freqtrade.data.btanalysis import (get_latest_backtest_filename, load_backtest_data,
+                                       load_backtest_stats)
 from freqtrade.edge import PairInfo
 from freqtrade.enums import SellType
 from freqtrade.optimize.optimize_reports import (_get_resample_from_period, generate_backtest_stats,
@ -19,9 +20,9 @@ from freqtrade.optimize.optimize_reports import (_get_resample_from_period, gene
                                                 generate_periodic_breakdown_stats,
                                                 generate_sell_reason_stats,
                                                 generate_strategy_comparison,
-                                                 generate_trading_stats, store_backtest_stats,
-                                                 text_table_bt_results, text_table_sell_reason,
-                                                 text_table_strategy)
+                                                 generate_trading_stats, show_sorted_pairlist,
+                                                 store_backtest_stats, text_table_bt_results,
+                                                 text_table_sell_reason, text_table_strategy)
 from freqtrade.resolvers.strategy_resolver import StrategyResolver
 from tests.conftest import CURRENT_TEST_STRATEGY
 from tests.data.test_history import _backup_file, _clean_test_file
@ -408,3 +409,16 @@ def test__get_resample_from_period():
    assert _get_resample_from_period('month') == '1M'
    with pytest.raises(ValueError, match=r"Period noooo is not supported."):
        _get_resample_from_period('noooo')
+
+
+def test_show_sorted_pairlist(testdatadir, default_conf, capsys):
+    filename = testdatadir / "backtest-result_new.json"
+    bt_data = load_backtest_stats(filename)
+    default_conf['backtest_show_pair_list'] = True
+
+    show_sorted_pairlist(default_conf, bt_data)
+
+    out, err = capsys.readouterr()
+    assert 'Pairs for Strategy StrategyTestV2: \n[' in out
+    assert 'TOTAL' not in out
+    assert '"ETH/BTC",  // ' in out
--- a/tests/rpc/test_rpc.py
+++ b/tests/rpc/test_rpc.py
@ -839,8 +839,226 @@ def test_performance_handle(default_conf, ticker, limit_buy_order, fee,
    assert len(res) == 1
    assert res[0]['pair'] == 'ETH/BTC'
    assert res[0]['count'] == 1
+    assert prec_satoshi(res[0]['profit_pct'], 6.2)
+
+
+def test_buy_tag_performance_handle(default_conf, ticker, limit_buy_order, fee,
+                                    limit_sell_order, mocker) -> None:
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        get_balances=MagicMock(return_value=ticker),
+        fetch_ticker=ticker,
+        get_fee=fee,
+    )
+
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+    patch_get_signal(freqtradebot)
+    rpc = RPC(freqtradebot)
+
+    # Create some test data
+    freqtradebot.enter_positions()
+    trade = Trade.query.first()
+    assert trade
+
+    # Simulate fulfilled LIMIT_BUY order for trade
+    trade.update(limit_buy_order)
+
+    # Simulate fulfilled LIMIT_SELL order for trade
+    trade.update(limit_sell_order)
+
+    trade.close_date = datetime.utcnow()
+    trade.is_open = False
+    res = rpc._rpc_buy_tag_performance(None)
+
+    assert len(res) == 1
+    assert res[0]['buy_tag'] == 'Other'
+    assert res[0]['count'] == 1
+    assert prec_satoshi(res[0]['profit_pct'], 6.2)
+
+    trade.buy_tag = "TEST_TAG"
+    res = rpc._rpc_buy_tag_performance(None)
+
+    assert len(res) == 1
+    assert res[0]['buy_tag'] == 'TEST_TAG'
+    assert res[0]['count'] == 1
+    assert prec_satoshi(res[0]['profit_pct'], 6.2)
+
+
+def test_buy_tag_performance_handle_2(mocker, default_conf, markets, fee):
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        markets=PropertyMock(return_value=markets)
+    )
+
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+    create_mock_trades(fee)
+    rpc = RPC(freqtradebot)
+
+    res = rpc._rpc_buy_tag_performance(None)
+
+    assert len(res) == 2
+    assert res[0]['buy_tag'] == 'TEST1'
+    assert res[0]['count'] == 1
+    assert prec_satoshi(res[0]['profit_pct'], 0.5)
+    assert res[1]['buy_tag'] == 'Other'
+    assert res[1]['count'] == 1
+    assert prec_satoshi(res[1]['profit_pct'], 1.0)
+
+    # Test for a specific pair
+    res = rpc._rpc_buy_tag_performance('ETC/BTC')
+    assert len(res) == 1
+    assert res[0]['count'] == 1
+    assert res[0]['buy_tag'] == 'TEST1'
+    assert prec_satoshi(res[0]['profit_pct'], 0.5)
+
+
+def test_sell_reason_performance_handle(default_conf, ticker, limit_buy_order, fee,
+                                        limit_sell_order, mocker) -> None:
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        get_balances=MagicMock(return_value=ticker),
+        fetch_ticker=ticker,
+        get_fee=fee,
+    )
+
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+    patch_get_signal(freqtradebot)
+    rpc = RPC(freqtradebot)
+
+    # Create some test data
+    freqtradebot.enter_positions()
+    trade = Trade.query.first()
+    assert trade
+
+    # Simulate fulfilled LIMIT_BUY order for trade
+    trade.update(limit_buy_order)
+
+    # Simulate fulfilled LIMIT_SELL order for trade
+    trade.update(limit_sell_order)
+
+    trade.close_date = datetime.utcnow()
+    trade.is_open = False
+    res = rpc._rpc_sell_reason_performance(None)
+
+    assert len(res) == 1
+    assert res[0]['sell_reason'] == 'Other'
+    assert res[0]['count'] == 1
+    assert prec_satoshi(res[0]['profit_pct'], 6.2)
+
+    trade.sell_reason = "TEST1"
+    res = rpc._rpc_sell_reason_performance(None)
+
+    assert len(res) == 1
+    assert res[0]['sell_reason'] == 'TEST1'
+    assert res[0]['count'] == 1
+    assert prec_satoshi(res[0]['profit_pct'], 6.2)
+
+
+def test_sell_reason_performance_handle_2(mocker, default_conf, markets, fee):
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        markets=PropertyMock(return_value=markets)
+    )
+
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+    create_mock_trades(fee)
+    rpc = RPC(freqtradebot)
+
+    res = rpc._rpc_sell_reason_performance(None)
+
+    assert len(res) == 2
+    assert res[0]['sell_reason'] == 'sell_signal'
+    assert res[0]['count'] == 1
+    assert prec_satoshi(res[0]['profit_pct'], 0.5)
+    assert res[1]['sell_reason'] == 'roi'
+    assert res[1]['count'] == 1
+    assert prec_satoshi(res[1]['profit_pct'], 1.0)
+
+    # Test for a specific pair
+    res = rpc._rpc_sell_reason_performance('ETC/BTC')
+    assert len(res) == 1
+    assert res[0]['count'] == 1
+    assert res[0]['sell_reason'] == 'sell_signal'
+    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:
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        get_balances=MagicMock(return_value=ticker),
+        fetch_ticker=ticker,
+        get_fee=fee,
+    )
+
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+    patch_get_signal(freqtradebot)
+    rpc = RPC(freqtradebot)
+
+    # Create some test data
+    freqtradebot.enter_positions()
+    trade = Trade.query.first()
+    assert trade
+
+    # Simulate fulfilled LIMIT_BUY order for trade
+    trade.update(limit_buy_order)
+
+    # Simulate fulfilled LIMIT_SELL order for trade
+    trade.update(limit_sell_order)
+
+    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 res[0]['count'] == 1
    assert prec_satoshi(res[0]['profit'], 6.2)

+    trade.buy_tag = "TESTBUY"
+    trade.sell_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'], 6.2)
+
+
+def test_mix_tag_performance_handle_2(mocker, default_conf, markets, fee):
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        markets=PropertyMock(return_value=markets)
+    )
+
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+    create_mock_trades(fee)
+    rpc = RPC(freqtradebot)
+
+    res = rpc._rpc_mix_tag_performance(None)
+
+    assert len(res) == 2
+    assert res[0]['mix_tag'] == 'TEST1 sell_signal'
+    assert res[0]['count'] == 1
+    assert prec_satoshi(res[0]['profit'], 0.5)
+    assert res[1]['mix_tag'] == 'Other roi'
+    assert res[1]['count'] == 1
+    assert prec_satoshi(res[1]['profit'], 1.0)
+
+    # Test for a specific pair
+    res = rpc._rpc_mix_tag_performance('ETC/BTC')
+
+    assert len(res) == 1
+    assert res[0]['count'] == 1
+    assert res[0]['mix_tag'] == 'TEST1 sell_signal'
+    assert prec_satoshi(res[0]['profit'], 0.5)
+

 def test_rpc_count(mocker, default_conf, ticker, fee) -> None:
    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
--- a/tests/rpc/test_rpc_apiserver.py
+++ b/tests/rpc/test_rpc_apiserver.py
@ -820,8 +820,10 @@ def test_api_performance(botclient, fee):
    rc = client_get(client, f"{BASE_URI}/performance")
    assert_response(rc)
    assert len(rc.json()) == 2
-    assert rc.json() == [{'count': 1, 'pair': 'LTC/ETH', 'profit': 7.61, 'profit_abs': 0.01872279},
-                         {'count': 1, 'pair': 'XRP/ETH', 'profit': -5.57, 'profit_abs': -0.1150375}]
+    assert rc.json() == [{'count': 1, 'pair': 'LTC/ETH', 'profit': 7.61, 'profit_pct': 7.61,
+                          'profit_ratio': 0.07609203, 'profit_abs': 0.01872279},
+                         {'count': 1, 'pair': 'XRP/ETH', 'profit': -5.57, 'profit_pct': -5.57,
+                          'profit_ratio': -0.05570419, 'profit_abs': -0.1150375}]


 # TODO-lev: @pytest.mark.parametrize('is_short,side', [
--- a/tests/rpc/test_rpc_telegram.py
+++ b/tests/rpc/test_rpc_telegram.py
@ -93,7 +93,8 @@ def test_telegram_init(default_conf, mocker, caplog) -> None:

    message_str = ("rpc.telegram is listening for following commands: [['status'], ['profit'], "
                   "['balance'], ['start'], ['stop'], ['forcesell'], ['forcebuy'], ['trades'], "
-                   "['delete'], ['performance'], ['stats'], ['daily'], ['count'], ['locks'], "
+                   "['delete'], ['performance'], ['buys'], ['sells'], ['mix_tags'], "
+                   "['stats'], ['daily'], ['count'], ['locks'], "
                   "['unlock', 'delete_locks'], ['reload_config', 'reload_conf'], "
                   "['show_config', 'show_conf'], ['stopbuy'], "
                   "['whitelist'], ['blacklist'], ['logs'], ['edge'], ['help'], ['version']"
@ -715,6 +716,7 @@ def test_telegram_forcesell_handle(default_conf, update, ticker, fee,
        'profit_ratio': 0.0629778,
        'stake_currency': 'BTC',
        'fiat_currency': 'USD',
+        'buy_tag': ANY,
        'sell_reason': SellType.FORCE_SELL.value,
        'open_date': ANY,
        'close_date': ANY,
@ -778,6 +780,7 @@ def test_telegram_forcesell_down_handle(default_conf, update, ticker, fee,
        'profit_ratio': -0.05482878,
        'stake_currency': 'BTC',
        'fiat_currency': 'USD',
+        'buy_tag': ANY,
        'sell_reason': SellType.FORCE_SELL.value,
        'open_date': ANY,
        'close_date': ANY,
@ -831,6 +834,7 @@ def test_forcesell_all_handle(default_conf, update, ticker, fee, mocker) -> None
        'profit_ratio': -0.00408133,
        'stake_currency': 'BTC',
        'fiat_currency': 'USD',
+        'buy_tag': ANY,
        'sell_reason': SellType.FORCE_SELL.value,
        'open_date': ANY,
        'close_date': ANY,
@ -976,6 +980,102 @@ def test_performance_handle(default_conf, update, ticker, fee,
    assert '<code>ETH/BTC\t0.00006217 BTC (6.20%) (1)</code>' in msg_mock.call_args_list[0][0][0]


+def test_buy_tag_performance_handle(default_conf, update, ticker, fee,
+                                    limit_buy_order, limit_sell_order, 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)
+
+    # Create some test data
+    freqtradebot.enter_positions()
+    trade = Trade.query.first()
+    assert trade
+
+    # Simulate fulfilled LIMIT_BUY order for trade
+    trade.update(limit_buy_order)
+
+    trade.buy_tag = "TESTBUY"
+    # Simulate fulfilled LIMIT_SELL order for trade
+    trade.update(limit_sell_order)
+
+    trade.close_date = datetime.utcnow()
+    trade.is_open = False
+
+    telegram._buy_tag_performance(update=update, context=MagicMock())
+    assert msg_mock.call_count == 1
+    assert 'Buy 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]
+
+
+def test_sell_reason_performance_handle(default_conf, update, ticker, fee,
+                                        limit_buy_order, limit_sell_order, 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)
+
+    # Create some test data
+    freqtradebot.enter_positions()
+    trade = Trade.query.first()
+    assert trade
+
+    # Simulate fulfilled LIMIT_BUY order for trade
+    trade.update(limit_buy_order)
+
+    trade.sell_reason = 'TESTSELL'
+    # Simulate fulfilled LIMIT_SELL order for trade
+    trade.update(limit_sell_order)
+
+    trade.close_date = datetime.utcnow()
+    trade.is_open = False
+
+    telegram._sell_reason_performance(update=update, context=MagicMock())
+    assert msg_mock.call_count == 1
+    assert 'Sell 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]
+
+
+def test_mix_tag_performance_handle(default_conf, update, ticker, fee,
+                                    limit_buy_order, limit_sell_order, 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)
+
+    # Create some test data
+    freqtradebot.enter_positions()
+    trade = Trade.query.first()
+    assert trade
+
+    # Simulate fulfilled LIMIT_BUY order for trade
+    trade.update(limit_buy_order)
+
+    trade.buy_tag = "TESTBUY"
+    trade.sell_reason = "TESTSELL"
+
+    # Simulate fulfilled LIMIT_SELL order for trade
+    trade.update(limit_sell_order)
+
+    trade.close_date = datetime.utcnow()
+    trade.is_open = False
+
+    telegram._mix_tag_performance(update=update, context=MagicMock())
+    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>'
+            in msg_mock.call_args_list[0][0][0])
+
+
 def test_count_handle(default_conf, update, ticker, fee, mocker) -> None:
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
@ -1386,6 +1486,7 @@ def test_send_msg_sell_notification(default_conf, mocker) -> None:
        'profit_ratio': -0.57405275,
        'stake_currency': 'ETH',
        'fiat_currency': 'USD',
+        'buy_tag': 'buy_signal1',
        'sell_reason': SellType.STOP_LOSS.value,
        'open_date': arrow.utcnow().shift(hours=-1),
        'close_date': arrow.utcnow(),
@ -1393,6 +1494,7 @@ def test_send_msg_sell_notification(default_conf, mocker) -> None:
    assert msg_mock.call_args[0][0] \
        == ('\N{WARNING SIGN} *Binance:* Selling KEY/ETH (#1)\n'
            '*Profit:* `-57.41% (loss: -0.05746268 ETH / -24.812 USD)`\n'
+            '*Buy Tag:* `buy_signal1`\n'
            '*Sell Reason:* `stop_loss`\n'
            '*Duration:* `1:00:00 (60.0 min)`\n'
            '*Amount:* `1333.33333333`\n'
@ -1416,6 +1518,7 @@ def test_send_msg_sell_notification(default_conf, mocker) -> None:
        'profit_amount': -0.05746268,
        'profit_ratio': -0.57405275,
        'stake_currency': 'ETH',
+        'buy_tag': 'buy_signal1',
        'sell_reason': SellType.STOP_LOSS.value,
        'open_date': arrow.utcnow().shift(days=-1, hours=-2, minutes=-30),
        'close_date': arrow.utcnow(),
@ -1423,6 +1526,7 @@ def test_send_msg_sell_notification(default_conf, mocker) -> None:
    assert msg_mock.call_args[0][0] \
        == ('\N{WARNING SIGN} *Binance:* Selling KEY/ETH (#1)\n'
            '*Profit:* `-57.41%`\n'
+            '*Buy Tag:* `buy_signal1`\n'
            '*Sell Reason:* `stop_loss`\n'
            '*Duration:* `1 day, 2:30:00 (1590.0 min)`\n'
            '*Amount:* `1333.33333333`\n'
@ -1487,6 +1591,7 @@ def test_send_msg_sell_fill_notification(default_conf, mocker) -> None:
        'profit_ratio': -0.57405275,
        'stake_currency': 'ETH',
        'fiat_currency': 'USD',
+        'buy_tag': 'buy_signal1',
        'sell_reason': SellType.STOP_LOSS.value,
        'open_date': arrow.utcnow().shift(hours=-1),
        'close_date': arrow.utcnow(),
@ -1578,12 +1683,14 @@ def test_send_msg_sell_notification_no_fiat(default_conf, mocker) -> None:
        'profit_ratio': -0.57405275,
        'stake_currency': 'ETH',
        'fiat_currency': 'USD',
+        'buy_tag': 'buy_signal1',
        'sell_reason': SellType.STOP_LOSS.value,
        'open_date': arrow.utcnow().shift(hours=-2, minutes=-35, seconds=-3),
        'close_date': arrow.utcnow(),
    })
    assert msg_mock.call_args[0][0] == ('\N{WARNING SIGN} *Binance:* Selling KEY/ETH (#1)\n'
                                        '*Profit:* `-57.41%`\n'
+                                        '*Buy Tag:* `buy_signal1`\n'
                                        '*Sell Reason:* `stop_loss`\n'
                                        '*Duration:* `2:35:03 (155.1 min)`\n'
                                        '*Amount:* `1333.33333333`\n'
--- a/tests/strategy/test_interface.py
+++ b/tests/strategy/test_interface.py
@ -42,29 +42,29 @@ def test_returns_latest_signal(ohlcv_history):
    mocked_history.loc[1, 'exit_long'] = 1

    assert _STRATEGY.get_entry_signal('ETH/BTC', '5m', mocked_history) == (None, None)
-    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history) == (False, True)
-    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history, True) == (False, False)
+    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history) == (False, True, None)
+    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history, True) == (False, False, None)
    mocked_history.loc[1, 'exit_long'] = 0
    mocked_history.loc[1, 'enter_long'] = 1

    assert _STRATEGY.get_entry_signal(
        'ETH/BTC', '5m', mocked_history) == (SignalDirection.LONG, None)
-    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history) == (True, False)
-    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history, True) == (False, False)
+    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history) == (True, False, None)
+    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history, True) == (False, False, None)
    mocked_history.loc[1, 'exit_long'] = 0
    mocked_history.loc[1, 'enter_long'] = 0

    assert _STRATEGY.get_entry_signal('ETH/BTC', '5m', mocked_history) == (None, None)
-    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history) == (False, False)
-    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history, True) == (False, False)
+    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history) == (False, False, None)
+    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history, True) == (False, False, None)
    mocked_history.loc[1, 'exit_long'] = 0
    mocked_history.loc[1, 'enter_long'] = 1
    mocked_history.loc[1, 'enter_tag'] = 'buy_signal_01'

    assert _STRATEGY.get_entry_signal(
        'ETH/BTC', '5m', mocked_history) == (SignalDirection.LONG, 'buy_signal_01')
-    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history) == (True, False)
-    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history, True) == (False, False)
+    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history) == (True, False, None)
+    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history, True) == (False, False, None)

    mocked_history.loc[1, 'exit_long'] = 0
    mocked_history.loc[1, 'enter_long'] = 0
@ -74,15 +74,18 @@ def test_returns_latest_signal(ohlcv_history):

    assert _STRATEGY.get_entry_signal(
        'ETH/BTC', '5m', mocked_history) == (SignalDirection.SHORT, 'sell_signal_01')
-    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history) == (False, False)
-    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history, True) == (True, False)
+    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history) == (False, False, None)
+    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history, True) == (True, False, None)

    mocked_history.loc[1, 'enter_short'] = 0
    mocked_history.loc[1, 'exit_short'] = 1
+    mocked_history.loc[1, 'exit_tag'] = 'sell_signal_02'
    assert _STRATEGY.get_entry_signal(
        'ETH/BTC', '5m', mocked_history) == (None, None)
-    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history) == (False, False)
-    assert _STRATEGY.get_exit_signal('ETH/BTC', '5m', mocked_history, True) == (False, True)
+    assert _STRATEGY.get_exit_signal(
+        'ETH/BTC', '5m', mocked_history) == (False, False, 'sell_signal_02')
+    assert _STRATEGY.get_exit_signal(
+        'ETH/BTC', '5m', mocked_history, True) == (False, True, 'sell_signal_02')


 def test_analyze_pair_empty(default_conf, mocker, caplog, ohlcv_history):
@ -711,7 +714,7 @@ def test_strategy_safe_wrapper(value):

    ret = strategy_safe_wrapper(working_method, message='DeadBeef')(value)

-    assert type(ret) == type(value)
+    assert isinstance(ret, type(value))
    assert ret == value


--- a/tests/test_configuration.py
+++ b/tests/test_configuration.py
@ -1360,6 +1360,7 @@ def test_flat_vars_to_nested_dict(caplog):
        'FREQTRADE__ASK_STRATEGY__PRICE_SIDE': 'bid',
        'FREQTRADE__ASK_STRATEGY__cccc': '500',
        'FREQTRADE__STAKE_AMOUNT': '200.05',
+        'FREQTRADE__TELEGRAM__CHAT_ID': '2151',
        'NOT_RELEVANT': '200.0',  # Will be ignored
    }
    expected = {
@ -1374,6 +1375,9 @@ def test_flat_vars_to_nested_dict(caplog):
            },
            'some_setting': True,
            'some_false_setting': False,
+        },
+        'telegram': {
+            'chat_id': '2151'
        }
    }
    res = flat_vars_to_nested_dict(test_args, ENV_VAR_PREFIX)
--- a/tests/test_freqtradebot.py
+++ b/tests/test_freqtradebot.py
@ -236,7 +236,7 @@ def test_edge_overrides_stoploss(limit_order, fee, caplog, mocker,
    # stoploss shoud be hit
    assert freqtrade.handle_trade(trade) is not ignore_strat_sl
    if not ignore_strat_sl:
-        assert log_has('Exit for NEO/BTC detected. Reason: stop_loss', caplog)
+        assert log_has_re('Exit for NEO/BTC detected. Reason: stop_loss.*', caplog)
        assert trade.sell_reason == SellType.STOP_LOSS.value


@ -458,7 +458,6 @@ def test_create_trade_no_signal(default_conf_usdt, fee, mocker) -> None:
    )
    default_conf_usdt['stake_amount'] = 10
    freqtrade = FreqtradeBot(default_conf_usdt)
-    # patch_get_signal(freqtrade, enter_long=False)
    patch_get_signal(freqtrade, enter_long=False, exit_long=False)

    Trade.query = MagicMock()
@ -1800,6 +1799,15 @@ def test_update_trade_state(
    freqtrade.update_trade_state(trade, '123')

    assert log_has_re('Found open order for.*', caplog)
+    limit_buy_order_usdt_new = deepcopy(limit_order)
+    limit_buy_order_usdt_new['filled'] = 0.0
+    limit_buy_order_usdt_new['status'] = 'canceled'
+
+    mocker.patch('freqtrade.freqtradebot.FreqtradeBot.get_real_amount', side_effect=ValueError)
+    mocker.patch('freqtrade.exchange.Exchange.fetch_order', return_value=limit_buy_order_usdt_new)
+    res = freqtrade.update_trade_state(trade, '123')
+    # Cancelled empty
+    assert res is True


@pytest.mark.parametrize("is_short", [False, True])
@ -1956,7 +1964,8 @@ def test_handle_trade(
    assert trade.is_open is True
    freqtrade.wallets.update()

-    patch_get_signal(freqtrade, enter_long=False, exit_short=is_short, exit_long=not is_short)
+    patch_get_signal(freqtrade, enter_long=False, exit_short=is_short,
+                     exit_long=not is_short, exit_tag='sell_signal1')
    assert freqtrade.handle_trade(trade) is True
    assert trade.open_order_id == exit_order['id']

@ -1967,6 +1976,7 @@ def test_handle_trade(
    assert trade.close_profit == close_profit
    assert trade.calc_profit() == 5.685
    assert trade.close_date is not None
+    assert trade.sell_reason == 'sell_signal1'


@pytest.mark.parametrize("is_short", [False, True])
@ -2851,6 +2861,7 @@ def test_execute_trade_exit_up(default_conf_usdt, ticker_usdt, fee, ticker_usdt_
        'limit': 2.0 if is_short else 2.2,
        'amount': amt,
        'order_type': 'limit',
+        'buy_tag': None,
        'open_rate': open_rate,
        'current_rate': 2.01 if is_short else 2.3,
        'profit_amount': 0.29554455 if is_short else 5.685,
@ -2906,6 +2917,7 @@ def test_execute_trade_exit_down(default_conf_usdt, ticker_usdt, fee, ticker_usd
        'limit': 2.2 if is_short else 2.01,
        'amount': 29.70297029 if is_short else 30.0,
        'order_type': 'limit',
+        'buy_tag': None,
        'open_rate': 2.02 if is_short else 2.0,
        'current_rate': 2.2 if is_short else 2.0,
        'profit_amount': -5.65990099 if is_short else -0.00075,
@ -2980,6 +2992,7 @@ def test_execute_trade_exit_custom_exit_price(
        'limit': limit,
        'amount': amount,
        'order_type': 'limit',
+        'buy_tag': None,
        'open_rate': open_rate,
        'current_rate': current_rate,
        'profit_amount': profit_amount,
@ -3043,6 +3056,7 @@ def test_execute_trade_exit_down_stoploss_on_exchange_dry_run(
        'limit': 2.02 if is_short else 1.98,
        'amount': 29.70297029 if is_short else 30.0,
        'order_type': 'limit',
+        'buy_tag': None,
        'open_rate': 2.02 if is_short else 2.0,
        'current_rate': 2.2 if is_short else 2.0,
        'profit_amount': -0.3 if is_short else -0.8985,
@ -3295,6 +3309,7 @@ def test_execute_trade_exit_market_order(
        'limit': limit,
        'amount': round(amount, 9),
        'order_type': 'market',
+        'buy_tag': None,
        'open_rate': open_rate,
        'current_rate': current_rate,
        'profit_amount': profit_amount,
--- a/tests/test_persistence.py
+++ b/tests/test_persistence.py
@ -2108,6 +2108,10 @@ def test_Trade_object_idem():
        'get_open_trades_without_assigned_fees',
        'get_open_order_trades',
        'get_trades',
+        'get_sell_reason_performance',
+        'get_buy_tag_performance',
+        'get_mix_tag_performance',
+
    )

    # Parent (LocalTrade) should have the same attributes