Merge pull request #6134 from freqtrade/new_release

New release 2021.12

.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.

.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/)*

.github/dependabot.yml

@@ -5,9 +5,17 @@ updates:
   schedule:
     interval: daily
   open-pull-requests-limit: 10
+
 - package-ecosystem: pip
   directory: "/"
   schedule:
     interval: weekly
   open-pull-requests-limit: 10
   target-branch: develop
+
+- package-ecosystem: "github-actions"
+  directory: "/"
+  schedule:
+    interval: "weekly"
+  open-pull-requests-limit: 10
+  target-branch: develop

.github/workflows/ci.yml

@@ -101,16 +101,13 @@ jobs:
       run: |
         mypy freqtrade scripts
 
-    - name: Slack Notification
-      uses: lazy-actions/slatify@v3.0.0
+    - name: Discord notification
+      uses: rjstone/discord-webhook-notify@v1
       if: failure() && ( github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork == false)
       with:
-        type: ${{ job.status }}
-        job_name: '*Freqtrade CI ${{ matrix.os }}*'
-        mention: 'here'
-        mention_if: 'failure'
-        channel: '#notifications'
-        url: ${{ secrets.SLACK_WEBHOOK }}
+          severity: error
+          details: Freqtrade CI failed on ${{ matrix.os }}
+          webhookUrl: ${{ secrets.DISCORD_WEBHOOK }}
 
   build_macos:
     runs-on: ${{ matrix.os }}
@@ -194,17 +191,13 @@ jobs:
       run: |
         mypy freqtrade scripts
 
-    - name: Slack Notification
-      uses: lazy-actions/slatify@v3.0.0
+    - name: Discord notification
+      uses: rjstone/discord-webhook-notify@v1
       if: failure() && ( github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork == false)
       with:
-        type: ${{ job.status }}
-        job_name: '*Freqtrade CI ${{ matrix.os }}*'
-        mention: 'here'
-        mention_if: 'failure'
-        channel: '#notifications'
-        url: ${{ secrets.SLACK_WEBHOOK }}
-
+          severity: error
+          details: Test Succeeded!
+          webhookUrl: ${{ secrets.DISCORD_WEBHOOK }}
 
   build_windows:
 
@@ -257,16 +250,13 @@ jobs:
       run: |
         mypy freqtrade scripts
 
-    - name: Slack Notification
-      uses: lazy-actions/slatify@v3.0.0
+    - name: Discord notification
+      uses: rjstone/discord-webhook-notify@v1
       if: failure() && ( github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork == false)
       with:
-        type: ${{ job.status }}
-        job_name: '*Freqtrade CI windows*'
-        mention: 'here'
-        mention_if: 'failure'
-        channel: '#notifications'
-        url: ${{ secrets.SLACK_WEBHOOK }}
+          severity: error
+          details: Test Failed
+          webhookUrl: ${{ secrets.DISCORD_WEBHOOK }}
 
   docs_check:
     runs-on: ubuntu-20.04
@@ -288,14 +278,13 @@ jobs:
         pip install mkdocs
         mkdocs build
 
-    - name: Slack Notification
-      uses: lazy-actions/slatify@v3.0.0
+    - name: Discord notification
+      uses: rjstone/discord-webhook-notify@v1
       if: failure() && ( github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork == false)
       with:
-        type: ${{ job.status }}
-        job_name: '*Freqtrade Docs*'
-        channel: '#notifications'
-        url: ${{ secrets.SLACK_WEBHOOK }}
+          severity: error
+          details: Freqtrade doc test failed!
+          webhookUrl: ${{ secrets.DISCORD_WEBHOOK }}
 
   cleanup-prior-runs:
     runs-on: ubuntu-20.04
@@ -306,7 +295,7 @@ jobs:
       env:
         GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
 
-  # Notify on slack only once - when CI completes (and after deploy) in case it's successfull
+  # Notify only once - when CI completes (and after deploy) in case it's successfull
   notify-complete:
     needs: [ build_linux, build_macos, build_windows, docs_check ]
     runs-on: ubuntu-20.04
@@ -320,14 +309,13 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-    - name: Slack Notification
-      uses: lazy-actions/slatify@v3.0.0
+    - name: Discord notification
+      uses: rjstone/discord-webhook-notify@v1
       if: always() && steps.check.outputs.has-permission && ( github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork == false)
       with:
-        type: ${{ job.status }}
-        job_name: '*Freqtrade CI*'
-        channel: '#notifications'
-        url: ${{ secrets.SLACK_WEBHOOK }}
+          severity: info
+          details: Test Completed!
+          webhookUrl: ${{ secrets.DISCORD_WEBHOOK }}
 
   deploy:
     needs: [ build_linux, build_macos, build_windows, docs_check ]
@@ -385,7 +373,7 @@ jobs:
 
     - name: Set up Docker Buildx
       id: buildx
-      uses: crazy-max/ghaction-docker-buildx@v1
+      uses: crazy-max/ghaction-docker-buildx@v3.3.1
       with:
         buildx-version: latest
         qemu-version: latest
@@ -400,17 +388,13 @@ jobs:
       run: |
         build_helpers/publish_docker_multi.sh
 
-
-    - name: Slack Notification
-      uses: lazy-actions/slatify@v3.0.0
+    - name: Discord notification
+      uses: rjstone/discord-webhook-notify@v1
       if: always() && ( github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork == false)
       with:
-        type: ${{ job.status }}
-        job_name: '*Freqtrade CI Deploy*'
-        mention: 'here'
-        mention_if: 'failure'
-        channel: '#notifications'
-        url: ${{ secrets.SLACK_WEBHOOK }}
+          severity: info
+          details: Deploy Succeeded!
+          webhookUrl: ${{ secrets.DISCORD_WEBHOOK }}
 
 
   deploy_arm:

.github/workflows/docker_update_readme.yml

@@ -10,7 +10,7 @@ jobs:
     steps:
     - uses: actions/checkout@v1
     - name: Docker Hub Description
-      uses: peter-evans/dockerhub-description@v2.1.0
+      uses: peter-evans/dockerhub-description@v2.4.3
       env:
         DOCKERHUB_USERNAME: ${{ secrets.DOCKER_USERNAME }}
         DOCKERHUB_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}

.travis.yml

@@ -1,55 +0,0 @@
-os:
-- linux
-dist: bionic
-language: python
-python:
-- 3.8
-services:
-  - docker
-env:
-  global:
-    - IMAGE_NAME=freqtradeorg/freqtrade
-install:
-- cd build_helpers && ./install_ta-lib.sh ${HOME}/dependencies; cd ..
-- export LD_LIBRARY_PATH=${HOME}/dependencies/lib:$LD_LIBRARY_PATH
-- export TA_LIBRARY_PATH=${HOME}/dependencies/lib
-- export TA_INCLUDE_PATH=${HOME}/dependencies/include
-- pip install -r requirements-dev.txt
-- pip install -e .
-jobs:
-
-  include:
-    - stage: tests
-      script:
-      - pytest --random-order --cov=freqtrade --cov-config=.coveragerc
-      # Allow failure for coveralls
-      # - coveralls || true
-      name: pytest
-    - script:
-      - cp config_examples/config_bittrex.example.json config.json
-      - freqtrade create-userdir --userdir user_data
-      - freqtrade backtesting --datadir tests/testdata --strategy SampleStrategy
-      name: backtest
-    - script:
-      - cp config_examples/config_bittrex.example.json config.json
-      - freqtrade create-userdir --userdir user_data
-      - freqtrade hyperopt --datadir tests/testdata -e 5 --strategy SampleStrategy --hyperopt-loss SharpeHyperOptLossDaily
-      name: hyperopt
-    - script: flake8
-      name: flake8
-    - script:
-      # Test Documentation boxes -
-      # !!! <TYPE>: is not allowed!
-      # !!! <TYPE> "title" - Title needs to be quoted!
-      - grep -Er '^!{3}\s\S+:|^!{3}\s\S+\s[^"]' docs/*; test $? -ne 0
-      name: doc syntax
-    - script: mypy freqtrade scripts
-      name: mypy
-
-notifications:
-  slack:
-    secure: bKLXmOrx8e2aPZl7W8DA5BdPAXWGpI5UzST33oc1G/thegXcDVmHBTJrBs4sZak6bgAclQQrdZIsRd2eFYzHLalJEaw6pk7hoAw8SvLnZO0ZurWboz7qg2+aZZXfK4eKl/VUe4sM9M4e/qxjkK+yWG7Marg69c4v1ypF7ezUi1fPYILYw8u0paaiX0N5UX8XNlXy+PBlga2MxDjUY70MuajSZhPsY2pDUvYnMY1D/7XN3cFW0g+3O8zXjF0IF4q1Z/1ASQe+eYjKwPQacE+O8KDD+ZJYoTOFBAPllrtpO1jnOPFjNGf3JIbVMZw4bFjIL0mSQaiSUaUErbU3sFZ5Or79rF93XZ81V7uEZ55vD8KMfR2CB1cQJcZcj0v50BxLo0InkFqa0Y8Nra3sbpV4fV5Oe8pDmomPJrNFJnX6ULQhQ1gTCe0M5beKgVms5SITEpt4/Y0CmLUr6iHDT0CUiyMIRWAXdIgbGh1jfaWOMksybeRevlgDsIsNBjXmYI1Sw2ZZR2Eo2u4R6zyfyjOMLwYJ3vgq9IrACv2w5nmf0+oguMWHf6iWi2hiOqhlAN1W74+3HsYQcqnuM3LGOmuCnPprV1oGBqkPXjIFGpy21gNx4vHfO1noLUyJnMnlu2L7SSuN1CdLsnjJ1hVjpJjPfqB4nn8g12x87TqM1bOm+3Q=
-cache:
-  pip: True
-  directories:
-    - $HOME/dependencies

CONTRIBUTING.md

@@ -56,6 +56,13 @@ To help with that, we encourage you to install the git pre-commit
 hook that will warn you when you try to commit code that fails these checks. 
 Guide for installing them is [here](http://flake8.pycqa.org/en/latest/user/using-hooks.html).
 
+##### Additional styles applied
+
+* Have docstrings on all public methods
+* Use double-quotes for docstrings
+* Multiline docstrings should be indented to the level of the first quote
+* Doc-strings should follow the reST format (`:param xxx: ...`, `:return: ...`, `:raises KeyError: ... `)
+
 ### 3. Test if all type-hints are correct
 
 #### Run mypy

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.9.7-slim-buster as base
+FROM python:3.9.9-slim-bullseye as base
 
 # Setup env
 ENV LANG C.UTF-8

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.

build_helpers/install_windows.ps1

@@ -6,13 +6,13 @@ python -m pip install --upgrade pip
 $pyv = python -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"
 
 if ($pyv -eq '3.7') {
-    pip install build_helpers\TA_Lib-0.4.21-cp37-cp37m-win_amd64.whl
+    pip install build_helpers\TA_Lib-0.4.22-cp37-cp37m-win_amd64.whl
 }
 if ($pyv -eq '3.8') {
-    pip install build_helpers\TA_Lib-0.4.21-cp38-cp38-win_amd64.whl
+    pip install build_helpers\TA_Lib-0.4.22-cp38-cp38-win_amd64.whl
 }
 if ($pyv -eq '3.9') {
-    pip install build_helpers\TA_Lib-0.4.21-cp39-cp39-win_amd64.whl
+    pip install build_helpers\TA_Lib-0.4.22-cp39-cp39-win_amd64.whl
 }
 
 pip install -r requirements-dev.txt

config_examples/config_full.example.json

@@ -28,6 +28,7 @@
     "unfilledtimeout": {
         "buy": 10,
         "sell": 30,
+        "exit_timeout_count": 0,
         "unit": "minutes"
     },
     "bid_strategy": {

docker/Dockerfile.armhf

@@ -1,4 +1,4 @@
-FROM python:3.7.10-slim-buster as base
+FROM python:3.9.9-slim-bullseye as base
 
 # Setup env
 ENV LANG C.UTF-8

docs/advanced-hyperopt.md

@@ -13,7 +13,7 @@ A sample of this can be found below, which is identical to the Default Hyperopt
 
 ``` python
 from datetime import datetime
-from typing import Dict
+from typing import Any, Dict
 
 from pandas import DataFrame
 

docs/backtesting.md

@@ -115,7 +115,7 @@ The result of backtesting will confirm if your bot has better odds of making a p
 All profit calculations include fees, and freqtrade will use the exchange's default fees for the calculation.
 
 !!! Warning "Using dynamic pairlists for backtesting"
-    Using dynamic pairlists is possible, however it relies on the current market conditions - which will not reflect the historic status of the pairlist.
+    Using dynamic pairlists is possible (not all of the handlers are allowed to be used in backtest mode), however it relies on the current market conditions - which will not reflect the historic status of the pairlist.
     Also, when using pairlists other than StaticPairlist, reproducibility of backtesting-results cannot be guaranteed.
     Please read the [pairlists documentation](plugins.md#pairlists) for more information.
 
@@ -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

docs/bot-basics.md

@@ -56,7 +56,11 @@ This loop will be repeated again and again until the bot is stopped.
 * Calculate buy / sell signals (calls `populate_buy_trend()` and `populate_sell_trend()` once per pair).
 * Loops per candle simulating entry and exit points.
   * Confirm trade buy / sell (calls `confirm_trade_entry()` and `confirm_trade_exit()` if implemented in the strategy).
+  * Call `custom_entry_price()` (if implemented in the strategy) to determine entry price (Prices are moved to be within the opening candle).
+  * Determine stake size by calling the `custom_stake_amount()` callback.
   * Call `custom_stoploss()` and `custom_sell()` to find custom exit points.
+  * For sells based on sell-signal and custom-sell: Call `custom_exit_price()` to determine exit price (Prices are moved to be within the closing candle).
+
 * Generate backtest report output
 
 !!! Note

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.
 
@@ -93,6 +102,7 @@ Mandatory parameters are marked as **Required**, which means that they are requi
 | `unfilledtimeout.buy` | **Required.** How long (in minutes or seconds) the bot will wait for an unfilled buy order to complete, after which the order will be cancelled and repeated at current (new) price, as long as there is a signal. [Strategy Override](#parameters-in-the-strategy).<br> **Datatype:** Integer
 | `unfilledtimeout.sell` | **Required.** How long (in minutes or seconds) the bot will wait for an unfilled sell order to complete, after which the order will be cancelled and repeated at current (new) price, as long as there is a signal. [Strategy Override](#parameters-in-the-strategy).<br> **Datatype:** Integer
 | `unfilledtimeout.unit` | Unit to use in unfilledtimeout setting. Note: If you set unfilledtimeout.unit to "seconds", "internals.process_throttle_secs" must be inferior or equal to timeout [Strategy Override](#parameters-in-the-strategy). <br> *Defaults to `minutes`.* <br> **Datatype:** String
+| `unfilledtimeout.exit_timeout_count` | How many times can exit orders time out. Once this number of timeouts is reached, an emergency sell is triggered. 0 to disable and allow unlimited order cancels. [Strategy Override](#parameters-in-the-strategy).<br>*Defaults to `0`.* <br> **Datatype:** Integer
 | `bid_strategy.price_side` | Select the side of the spread the bot should look at to get the buy rate. [More information below](#buy-price-side).<br> *Defaults to `bid`.* <br> **Datatype:** String (either `ask` or `bid`).
 | `bid_strategy.ask_last_balance` | **Required.** Interpolate the bidding price. More information [below](#buy-price-without-orderbook-enabled).
 | `bid_strategy.use_order_book` | Enable buying using the rates in [Order Book Bids](#buy-price-with-orderbook-enabled). <br> **Datatype:** Boolean
@@ -116,14 +126,16 @@ Mandatory parameters are marked as **Required**, which means that they are requi
 | `exchange.key` | API key to use for the exchange. Only required when you are in production mode.<br>**Keep it in secret, do not disclose publicly.** <br> **Datatype:** String
 | `exchange.secret` | API secret to use for the exchange. Only required when you are in production mode.<br>**Keep it in secret, do not disclose publicly.** <br> **Datatype:** String
 | `exchange.password` | API password to use for the exchange. Only required when you are in production mode and for exchanges that use password for API requests.<br>**Keep it in secret, do not disclose publicly.** <br> **Datatype:** String
+| `exchange.uid` | API uid to use for the exchange. Only required when you are in production mode and for exchanges that use uid for API requests.<br>**Keep it in secret, do not disclose publicly.** <br> **Datatype:** String
 | `exchange.pair_whitelist` | List of pairs to use by the bot for trading and to check for potential trades during backtesting. Supports regex pairs as `.*/BTC`. Not used by VolumePairList. [More information](plugins.md#pairlists-and-pairlist-handlers). <br> **Datatype:** List
 | `exchange.pair_blacklist` | List of pairs the bot must absolutely avoid for trading and backtesting. [More information](plugins.md#pairlists-and-pairlist-handlers). <br> **Datatype:** List
-| `exchange.ccxt_config` | Additional CCXT parameters passed to both ccxt instances (sync and async). This is usually the correct place for ccxt configurations. Parameters may differ from exchange to exchange and are documented in the [ccxt documentation](https://ccxt.readthedocs.io/en/latest/manual.html#instantiation) <br> **Datatype:** Dict
+| `exchange.ccxt_config` | Additional CCXT parameters passed to both ccxt instances (sync and async). This is usually the correct place for additional ccxt configurations. Parameters may differ from exchange to exchange and are documented in the [ccxt documentation](https://ccxt.readthedocs.io/en/latest/manual.html#instantiation). Please avoid adding exchange secrets here (use the dedicated fields instead), as they may be contained in logs. <br> **Datatype:** Dict
 | `exchange.ccxt_sync_config` | Additional CCXT parameters passed to the regular (sync) ccxt instance. Parameters may differ from exchange to exchange and are documented in the [ccxt documentation](https://ccxt.readthedocs.io/en/latest/manual.html#instantiation) <br> **Datatype:** Dict
 | `exchange.ccxt_async_config` | Additional CCXT parameters passed to the async ccxt instance. Parameters may differ from exchange to exchange  and are documented in the [ccxt documentation](https://ccxt.readthedocs.io/en/latest/manual.html#instantiation) <br> **Datatype:** Dict
 | `exchange.markets_refresh_interval` | The interval in minutes in which markets are reloaded. <br>*Defaults to `60` minutes.* <br> **Datatype:** Positive Integer
 | `exchange.skip_pair_validation` | Skip pairlist validation on startup.<br>*Defaults to `false`<br> **Datatype:** Boolean
 | `exchange.skip_open_order_update` | Skips open order updates on startup should the exchange cause problems. Only relevant in live conditions.<br>*Defaults to `false`<br> **Datatype:** Boolean
+| `exchange.unknown_fee_rate` | Fallback value to use when calculating trading fees. This can be useful for exchanges which have fees in non-tradable currencies. The value provided here will be multiplied with the "fee cost".<br>*Defaults to `None`<br> **Datatype:** float
 | `exchange.log_responses` | Log relevant exchange responses. For debug mode only - use with care.<br>*Defaults to `false`<br> **Datatype:** Boolean
 | `edge.*` | Please refer to [edge configuration document](edge.md) for detailed explanation.
 | `experimental.block_bad_exchanges` | Block exchanges known to not work with freqtrade. Leave on default unless you want to test if that exchange works now. <br>*Defaults to `true`.* <br> **Datatype:** Boolean
@@ -192,9 +204,8 @@ There are several methods to configure how much of the stake currency the bot wi
 #### Minimum trade stake
 
 The minimum stake amount will depend on exchange and pair and is usually listed in the exchange support pages.
-Assuming the minimum tradable amount for XRP/USD is 20 XRP (given by the exchange), and the price is 0.6$.
 
-The minimum stake amount to buy this pair is, therefore, `20 * 0.6 ~= 12`.
+Assuming the minimum tradable amount for XRP/USD is 20 XRP (given by the exchange), and the price is 0.6$, the minimum stake amount to buy this pair is `20 * 0.6 ~= 12`.
 This exchange has also a limit on USD - where all orders must be > 10$ - which however does not apply in this case.
 
 To guarantee safe execution, freqtrade will not allow buying with a stake-amount of 10.1$, instead, it'll make sure that there's enough space to place a stoploss below the pair (+ an offset, defined by `amount_reserve_percent`, which defaults to 5%).
@@ -204,7 +215,7 @@ With a reserve of 5%, the minimum stake amount would be ~12.6$ (`12 * (1 + 0.05)
 To limit this calculation in case of large stoploss values, the calculated minimum stake-limit will never be more than 50% above the real limit.
 
 !!! Warning
-    Since the limits on exchanges are usually stable and are not updated often, some pairs can show pretty high minimum limits, simply because the price increased a lot since the last limit adjustment by the exchange.
+    Since the limits on exchanges are usually stable and are not updated often, some pairs can show pretty high minimum limits, simply because the price increased a lot since the last limit adjustment by the exchange. Freqtrade adjusts the stake-amount to this value, unless it's > 30% more than the calculated/desired stake-amount - in which case the trade is rejected.
 
 #### Tradable balance
 

docs/developer.md

@@ -26,6 +26,8 @@ Alternatively (e.g. if your system is not supported by the setup.sh script), fol
 
 This will install all required tools for development, including `pytest`, `flake8`, `mypy`, and `coveralls`.
 
+Before opening a pull request, please familiarize yourself with our [Contributing Guidelines](https://github.com/freqtrade/freqtrade/blob/develop/CONTRIBUTING.md).
+
 ### Devcontainer setup
 
 The fastest and easiest way to get started is to use [VSCode](https://code.visualstudio.com/) with the Remote container extension.
@@ -250,7 +252,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
 
@@ -306,9 +324,8 @@ jupyter nbconvert --ClearOutputPreprocessor.enabled=True --to markdown freqtrade
 This documents some decisions taken for the CI Pipeline.
 
 * CI runs on all OS variants, Linux (ubuntu), macOS and Windows.
-* Docker images are build for the branches `stable` and `develop`.
+* Docker images are build for the branches `stable` and `develop`, and are built as multiarch builds, supporting multiple platforms via the same tag.
 * Docker images containing Plot dependencies are also available as `stable_plot` and `develop_plot`.
-* Raspberry PI Docker images are postfixed with `_pi` - so tags will be `:stable_pi` and `develop_pi`.
 * Docker images contain a file, `/freqtrade/freqtrade_commit` containing the commit this image is based of.
 * Full docker image rebuilds are run once a week via schedule.
 * Deployments run on ubuntu.

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,28 @@ 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.
+
+## Gate.io
+
+Gate.io allows the use of `POINT` to pay for fees. As this is not a tradable currency (no regular market available), automatic fee calculations will fail (and default to a fee of 0).
+The configuration parameter `exchange.unknown_fee_rate` can be used to specify the exchange rate between Point and the stake currency. Obviously, changing the stake-currency will also require changes to this value.
+
 ## 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.

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
@@ -54,6 +54,21 @@ you can't say much from few trades.
 
 Yes. You can edit your config and use the `/reload_config` command to reload the configuration. The bot will stop, reload the configuration and strategy and will restart with the new configuration and strategy.
 
+### Why does my bot not sell everything it bought?
+
+This is called "coin dust" and can happen on all exchanges.
+It happens because many exchanges subtract fees from the "receiving currency" - so you buy 100 COIN - but you only get 99.9 COIN.
+As COIN is trading in full lot sizes (1COIN steps), you cannot sell 0.9 COIN (or 99.9 COIN) - but you need to round down to 99 COIN.
+
+This is not a bot-problem, but will also happen while manual trading.
+
+While freqtrade can handle this (it'll sell 99 COIN), fees are often below the minimum tradable lot-size (you can only trade full COIN, not 0.9 COIN).
+Leaving the dust (0.9 COIN) on the exchange makes usually sense, as the next time freqtrade buys COIN, it'll eat into the remaining small balance, this time selling everything it bought, and therefore slowly declining the dust balance (although it most likely will never reach exactly 0).
+
+Where possible (e.g. on binance), the use of the exchange's dedicated fee currency will fix this.  
+On binance, it's sufficient to have BNB in your account, and have "Pay fees in BNB" enabled in your profile. Your BNB balance will slowly decline (as it's used to pay fees) - but you'll no longer encounter dust (Freqtrade will include the fees in the profit calculations).
+Other exchanges don't offer such possibilities, where it's simply something you'll have to accept or move to a different exchange.
+
 ### I want to use incomplete candles
 
 Freqtrade will not provide incomplete candles to strategies. Using incomplete candles will lead to repainting and consequently to strategies with "ghost" buys, which are impossible to both backtest, and verify after they happened.
@@ -78,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.  

docs/hyperopt.md

@@ -116,7 +116,7 @@ optional arguments:
                         ShortTradeDurHyperOptLoss, OnlyProfitHyperOptLoss,
                         SharpeHyperOptLoss, SharpeHyperOptLossDaily,
                         SortinoHyperOptLoss, SortinoHyperOptLossDaily,
-                        MaxDrawDownHyperOptLoss
+                        CalmarHyperOptLoss, MaxDrawDownHyperOptLoss
   --disable-param-export
                         Disable automatic hyperopt parameter export.
   --ignore-missing-spaces, --ignore-unparameterized-spaces
@@ -524,6 +524,7 @@ Currently, the following loss functions are builtin:
 * `SortinoHyperOptLoss` - optimizes Sortino Ratio calculated on trade returns relative to **downside** standard deviation.
 * `SortinoHyperOptLossDaily` - optimizes Sortino Ratio calculated on **daily** trade returns relative to **downside** standard deviation.
 * `MaxDrawDownHyperOptLoss` - Optimizes Maximum drawdown.
+* `CalmarHyperOptLoss` - Optimizes Calmar Ratio calculated on trade returns relative to max drawdown.
 
 Creation of a custom loss function is covered in the [Advanced Hyperopt](advanced-hyperopt.md) part of the documentation.
 

docs/includes/pairlists.md

@@ -196,9 +196,9 @@ Trade count is used as a tie breaker.
 You can use the `minutes` parameter to only consider performance of the past X minutes (rolling window).
 Not defining this parameter (or setting it to 0) will use all-time performance.
 
-The optional `min_profit` parameter defines the minimum profit a pair must have to be considered.
+The optional `min_profit` (as ratio -> a setting of `0.01` corresponds to 1%) parameter defines the minimum profit a pair must have to be considered.
 Pairs below this level will be filtered out.
-Using this parameter without `minutes` is highly discouraged, as it can lead to an empty pairlist without without a way to recover.
+Using this parameter without `minutes` is highly discouraged, as it can lead to an empty pairlist without a way to recover.
 
 ```json
 "pairlists": [
@@ -206,11 +206,13 @@ Using this parameter without `minutes` is highly discouraged, as it can lead to
     {
         "method": "PerformanceFilter",
         "minutes": 1440,  // rolling 24h
-        "min_profit": 0.01
+        "min_profit": 0.01  // minimal profit 1%
     }
 ],
 ```
 
+As this Filter uses past performance of the bot, it'll have some startup-period - and should only be used after the bot has a few 100 trades in the database.
+
 !!! Warning "Backtesting"
     `PerformanceFilter` does not support backtesting mode.
 
@@ -218,6 +220,9 @@ Using this parameter without `minutes` is highly discouraged, as it can lead to
 
 Filters low-value coins which would not allow setting stoplosses.
 
+!!! Warning "Backtesting"
+    `PrecisionFilter` does not support backtesting mode using multiple strategies.
+
 #### PriceFilter
 
 The `PriceFilter` allows filtering of pairs by price. Currently the following price filters are supported:
@@ -255,7 +260,7 @@ Min price precision for SHITCOIN/BTC is 8 decimals. If its price is 0.00000011 -
 Shuffles (randomizes) pairs in the pairlist. It can be used for preventing the bot from trading some of the pairs more frequently then others when you want all pairs be treated with the same priority.
 
 !!! Tip
-    You may set the `seed` value for this Pairlist to obtain reproducible results, which can be useful for repeated backtesting sessions. If `seed` is not set, the pairs are shuffled in the non-repeatable random order.
+    You may set the `seed` value for this Pairlist to obtain reproducible results, which can be useful for repeated backtesting sessions. If `seed` is not set, the pairs are shuffled in the non-repeatable random order. ShuffleFilter will automatically detect runmodes and apply the `seed` only for backtesting modes - if a `seed` value is set.
 
 #### SpreadFilter
 
@@ -290,7 +295,7 @@ If the trading range over the last 10 days is <1% or >99%, remove the pair from
 
 #### VolatilityFilter
 
-Volatility is the degree of historical variation of a pairs over time, is is measured by the standard deviation of logarithmic daily returns. Returns are assumed to be normally distributed, although actual distribution might be different. In a normal distribution, 68% of observations fall within one standard deviation and 95% of observations fall within two standard deviations. Assuming a volatility of 0.05 means that the expected returns for 20 out of 30 days is expected to be less than 5% (one standard deviation). Volatility is a positive ratio of the expected deviation of return and can be greater than 1.00. Please refer to the wikipedia definition of [`volatility`](https://en.wikipedia.org/wiki/Volatility_(finance)).
+Volatility is the degree of historical variation of a pairs over time, it is measured by the standard deviation of logarithmic daily returns. Returns are assumed to be normally distributed, although actual distribution might be different. In a normal distribution, 68% of observations fall within one standard deviation and 95% of observations fall within two standard deviations. Assuming a volatility of 0.05 means that the expected returns for 20 out of 30 days is expected to be less than 5% (one standard deviation). Volatility is a positive ratio of the expected deviation of return and can be greater than 1.00. Please refer to the wikipedia definition of [`volatility`](https://en.wikipedia.org/wiki/Volatility_(finance)).
 
 This filter removes pairs if the average volatility over a `lookback_days` days is below `min_volatility` or above `max_volatility`. Since this is a filter that requires additional data, the results are cached for `refresh_period`.
 
@@ -344,5 +349,5 @@ The below example blacklists `BNB/BTC`, uses `VolumePairList` with `20` assets,
         "refresh_period": 86400
     },
     {"method": "ShuffleFilter", "seed": 42}
-    ],
+],
 ```

docs/index.md

@@ -36,11 +36,12 @@ Freqtrade is a crypto-currency algorithmic trading software developed in python
 
 Please read the [exchange specific notes](exchanges.md) to learn about eventual, special configurations needed for each exchange.
 
-- [X] [Binance](https://www.binance.com/) ([*Note for binance users](docs/exchanges.md#binance-blacklist))
+- [X] [Binance](https://www.binance.com/) ([*Note for binance users](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).

docs/installation.md

@@ -36,6 +36,10 @@ The easiest way to install and run Freqtrade is to clone the bot Github reposito
 
 These requirements apply to both [Script Installation](#script-installation) and [Manual Installation](#manual-installation).
 
+!!! Note "ARM64 systems"
+    If you are running an ARM64 system (like a MacOS M1 or an Oracle VM), please use [docker](docker_quickstart.md) to run freqtrade.
+    While native installation is possible with some manual effort, this is not supported at the moment.
+
 ### Install guide
 
 * [Python >= 3.7.x](http://docs.python-guide.org/en/latest/starting/installation/)
@@ -52,6 +56,10 @@ OS Specific steps are listed first, the [Common](#common) section below is neces
 !!! Note
     Python3.7 or higher and the corresponding pip are assumed to be available.
 
+!!! Warning "Python 3.10 support"
+    Due to issues with dependencies, freqtrade is currently unable to support python 3.10.
+    We're working on supporting python 3.10, are however dependant on support from dependencies.
+
 === "Debian/Ubuntu"
     #### Install necessary dependencies
 
@@ -60,7 +68,7 @@ OS Specific steps are listed first, the [Common](#common) section below is neces
     sudo apt-get update
 
     # install packages
-    sudo apt install -y python3-pip python3-venv python3-dev python3-pandas git
+    sudo apt install -y python3-pip python3-venv python3-dev python3-pandas git curl
     ```
 
 === "RaspberryPi/Raspbian"
@@ -71,7 +79,7 @@ OS Specific steps are listed first, the [Common](#common) section below is neces
 
 
     ```bash
-    sudo apt-get install python3-venv libatlas-base-dev cmake
+    sudo apt-get install python3-venv libatlas-base-dev cmake curl
     # Use pywheels.org to speed up installation
     sudo echo "[global]\nextra-index-url=https://www.piwheels.org/simple" > tee /etc/pip.conf
 

docs/plotting.md

@@ -164,7 +164,7 @@ The resulting plot will have the following elements:
 
 An advanced plot configuration can be specified in the strategy in the `plot_config` parameter.
 
-Additional features when using plot_config include:
+Additional features when using `plot_config` include:
 
 * Specify colors per indicator
 * Specify additional subplots
@@ -174,6 +174,7 @@ The sample plot configuration below specifies fixed colors for the indicators. O
 It also allows multiple subplots to display both MACD and RSI at the same time.
 
 Plot type can be configured using `type` key. Possible types are:
+
 * `scatter` corresponding to `plotly.graph_objects.Scatter` class (default).
 * `bar` corresponding to `plotly.graph_objects.Bar` class.
 
@@ -182,40 +183,89 @@ Extra parameters to `plotly.graph_objects.*` constructor can be specified in `pl
 Sample configuration with inline comments explaining the process:
 
 ``` python
-    plot_config = {
-        'main_plot': {
-            # Configuration for main plot indicators.
-            # Specifies `ema10` to be red, and `ema50` to be a shade of gray
-            'ema10': {'color': 'red'},
-            'ema50': {'color': '#CCCCCC'},
-            # By omitting color, a random color is selected.
-            'sar': {},
-	    # fill area between senkou_a and senkou_b
-	    'senkou_a': {
-	        'color': 'green', #optional
-	        'fill_to': 'senkou_b',
-	        'fill_label': 'Ichimoku Cloud', #optional
-	        'fill_color': 'rgba(255,76,46,0.2)', #optional
-	    },
-	    # plot senkou_b, too. Not only the area to it.
-	    'senkou_b': {}
+@property
+def plot_config(self):
+    """
+        There are a lot of solutions how to build the return dictionary.
+        The only important point is the return value.
+        Example:
+            plot_config = {'main_plot': {}, 'subplots': {}}
+
+    """
+    plot_config = {}
+    plot_config['main_plot'] = {
+        # Configuration for main plot indicators.
+        # Assumes 2 parameters, emashort and emalong to be specified.
+        f'ema_{self.emashort.value}': {'color': 'red'},
+        f'ema_{self.emalong.value}': {'color': '#CCCCCC'},
+        # By omitting color, a random color is selected.
+        'sar': {},
+        # fill area between senkou_a and senkou_b
+        'senkou_a': {
+            'color': 'green', #optional
+            'fill_to': 'senkou_b',
+            'fill_label': 'Ichimoku Cloud', #optional
+            'fill_color': 'rgba(255,76,46,0.2)', #optional
         },
-        'subplots': {
-            # Create subplot MACD
-            "MACD": {
-                'macd': {'color': 'blue', 'fill_to': 'macdhist'},
-                'macdsignal': {'color': 'orange'},
-                'macdhist': {'type': 'bar', 'plotly': {'opacity': 0.9}}
-            },
-            # Additional subplot RSI
-            "RSI": {
-                'rsi': {'color': 'red'}
-            }
+        # plot senkou_b, too. Not only the area to it.
+        'senkou_b': {}
+    }
+    plot_config['subplots'] = {
+         # Create subplot MACD
+        "MACD": {
+            'macd': {'color': 'blue', 'fill_to': 'macdhist'},
+            'macdsignal': {'color': 'orange'},
+            'macdhist': {'type': 'bar', 'plotly': {'opacity': 0.9}}
+        },
+        # Additional subplot RSI
+        "RSI": {
+            'rsi': {'color': 'red'}
         }
     }
 
+    return plot_config
 ```
 
+??? Note "As attribute (former method)"
+    Assigning plot_config is also possible as Attribute (this used to be the default way).
+    This has the disadvantage that strategy parameters are not available, preventing certain configurations from working.
+
+    ``` python
+        plot_config = {
+            'main_plot': {
+                # Configuration for main plot indicators.
+                # Specifies `ema10` to be red, and `ema50` to be a shade of gray
+                'ema10': {'color': 'red'},
+                'ema50': {'color': '#CCCCCC'},
+                # By omitting color, a random color is selected.
+                'sar': {},
+            # fill area between senkou_a and senkou_b
+            'senkou_a': {
+                'color': 'green', #optional
+                'fill_to': 'senkou_b',
+                'fill_label': 'Ichimoku Cloud', #optional
+                'fill_color': 'rgba(255,76,46,0.2)', #optional
+            },
+            # plot senkou_b, too. Not only the area to it.
+            'senkou_b': {}
+            },
+            'subplots': {
+                # Create subplot MACD
+                "MACD": {
+                    'macd': {'color': 'blue', 'fill_to': 'macdhist'},
+                    'macdsignal': {'color': 'orange'},
+                    'macdhist': {'type': 'bar', 'plotly': {'opacity': 0.9}}
+                },
+                # Additional subplot RSI
+                "RSI": {
+                    'rsi': {'color': 'red'}
+                }
+            }
+        }
+
+    ```
+
+
 !!! Note
     The above configuration assumes that `ema10`, `ema50`, `senkou_a`, `senkou_b`,
     `macd`, `macdsignal`, `macdhist` and `rsi` are columns in the DataFrame created by the strategy.

docs/requirements-docs.txt

@@ -1,4 +1,4 @@
 mkdocs==1.2.3
-mkdocs-material==7.3.4
+mkdocs-material==8.1.3
 mdx_truly_sane_lists==1.2
-pymdown-extensions==9.0
+pymdown-extensions==9.1

docs/rest-api.md

@@ -38,6 +38,11 @@ Sample configuration:
 !!! Danger "Security warning"
     By default, the configuration listens on localhost only (so it's not reachable from other systems). We strongly recommend to not expose this API to the internet and choose a strong, unique password, since others will potentially be able to control your bot.
 
+??? Note "API/UI Access on a remote servers"
+    If you're running on a VPS, you should consider using either a ssh tunnel, or setup a VPN (openVPN, wireguard) to connect to your bot.
+    This will ensure that freqUI is not directly exposed to the internet, which is not recommended for security reasons (freqUI does not support https out of the box).
+    Setup of these tools is not part of this tutorial, however many good tutorials can be found on the internet.
+
 You can then access the API by going to `http://127.0.0.1:8080/api/v1/ping` in a browser to check if the API is running correctly.
 This should return the response:
 
@@ -330,12 +335,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 +356,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.

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$

docs/strategy-advanced.md

@@ -77,43 +77,6 @@ class AwesomeStrategy(IStrategy):
 
 ***
 
-## Custom sell signal
-
-It is possible to define custom sell signals, indicating that specified position should be sold. This is very useful when we need to customize sell conditions for each individual trade, or if you need the trade profit to take the sell decision. 
-
-For example you could implement a 1:2 risk-reward ROI with `custom_sell()`.
-
-Using custom_sell() signals in place of stoploss though *is not recommended*. It is a inferior method to using `custom_stoploss()` in this regard - which also allows you to keep the stoploss on exchange.
-
-!!! Note
-    Returning a `string` or `True` from this method is equal to setting sell signal on a candle at specified time. This method is not called when sell signal is set already, or if sell signals are disabled (`use_sell_signal=False` or `sell_profit_only=True` while profit is below `sell_profit_offset`). `string` max length is 64 characters. Exceeding this limit will cause the message to be truncated to 64 characters.
-
-An example of how we can use different indicators depending on the current profit and also sell trades that were open longer than one day:
-
-``` python
-class AwesomeStrategy(IStrategy):
-    def custom_sell(self, pair: str, trade: 'Trade', current_time: 'datetime', current_rate: float,
-                    current_profit: float, **kwargs):
-        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
-        last_candle = dataframe.iloc[-1].squeeze()
-
-        # Above 20% profit, sell when rsi < 80
-        if current_profit > 0.2:
-            if last_candle['rsi'] < 80:
-                return 'rsi_below_80'
-
-        # Between 2% and 10%, sell if EMA-long above EMA-short
-        if 0.02 < current_profit < 0.1:
-            if last_candle['emalong'] > last_candle['emashort']:
-                return 'ema_long_below_80'
-
-        # Sell any positions at a loss if they are held for more than one day.
-        if current_profit < 0.0 and (current_time - trade.open_date_utc).days >= 1:
-            return 'unclog'
-```
-
-See [Dataframe access](#dataframe-access) for more information about dataframe use in strategy callbacks.
-
 ## Buy Tag
 
 When your strategy has multiple buy signals, you can name the signal that triggered.
@@ -143,506 +106,41 @@ def custom_sell(self, pair: str, trade: Trade, current_time: datetime, current_r
 !!! Note
     `buy_tag` is limited to 100 characters, remaining data will be truncated.
 
+## Exit tag
 
-## Custom stoploss
-
-The stoploss price can only ever move upwards - if the stoploss value returned from `custom_stoploss` would result in a lower stoploss price than was previously set, it will be ignored. The traditional `stoploss` value serves as an absolute lower level and will be instated as the initial stoploss.
-
-The usage of the custom stoploss method must be enabled by setting `use_custom_stoploss=True` on the strategy object.
-The method must return a stoploss value (float / number) as a percentage of the current price.
-E.g. If the `current_rate` is 200 USD, then returning `0.02` will set the stoploss price 2% lower, at 196 USD.
-
-The absolute value of the return value is used (the sign is ignored), so returning `0.05` or `-0.05` have the same result, a stoploss 5% below the current price.
-
-To simulate a regular trailing stoploss of 4% (trailing 4% behind the maximum reached price) you would use the following very simple method:
+Similar to [Buy Tagging](#buy-tag), you can also specify a sell tag.
 
 ``` python
-# additional imports required
-from datetime import datetime
-from freqtrade.persistence import Trade
+def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+    dataframe.loc[
+        (
+            (dataframe['rsi'] > 70) &
+            (dataframe['volume'] > 0)
+        ),
+        ['sell', 'exit_tag']] = (1, 'exit_rsi')
 
-class AwesomeStrategy(IStrategy):
-
-    # ... populate_* methods
-
-    use_custom_stoploss = True
-
-    def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
-                        current_rate: float, current_profit: float, **kwargs) -> float:
-        """
-        Custom stoploss logic, returning the new distance relative to current_rate (as ratio).
-        e.g. returning -0.05 would create a stoploss 5% below current_rate.
-        The custom stoploss can never be below self.stoploss, which serves as a hard maximum loss.
-
-        For full documentation please go to https://www.freqtrade.io/en/latest/strategy-advanced/
-
-        When not implemented by a strategy, returns the initial stoploss value
-        Only called when use_custom_stoploss is set to True.
-
-        :param pair: Pair that's currently analyzed
-        :param trade: trade object.
-        :param current_time: datetime object, containing the current datetime
-        :param current_rate: Rate, calculated based on pricing settings in ask_strategy.
-        :param current_profit: Current profit (as ratio), calculated based on current_rate.
-        :param **kwargs: Ensure to keep this here so updates to this won't break your strategy.
-        :return float: New stoploss value, relative to the current rate
-        """
-        return -0.04
+    return dataframe
 ```
 
-Stoploss on exchange works similar to `trailing_stop`, and the stoploss on exchange is updated as configured in `stoploss_on_exchange_interval` ([More details about stoploss on exchange](stoploss.md#stop-loss-on-exchange-freqtrade)).
-
-!!! Note "Use of dates"
-    All time-based calculations should be done based on `current_time` - using `datetime.now()` or `datetime.utcnow()` is discouraged, as this will break backtesting support.
-
-!!! Tip "Trailing stoploss"
-    It's recommended to disable `trailing_stop` when using custom stoploss values. Both can work in tandem, but you might encounter the trailing stop to move the price higher while your custom function would not want this, causing conflicting behavior.
-
-### Custom stoploss examples
-
-The next section will show some examples on what's possible with the custom stoploss function.
-Of course, many more things are possible, and all examples can be combined at will.
-
-#### Time based trailing stop
-
-Use the initial stoploss for the first 60 minutes, after this change to 10% trailing stoploss, and after 2 hours (120 minutes) we use a 5% trailing stoploss.
-
-``` python
-from datetime import datetime, timedelta
-from freqtrade.persistence import Trade
-
-class AwesomeStrategy(IStrategy):
-
-    # ... populate_* methods
-
-    use_custom_stoploss = True
-
-    def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
-                        current_rate: float, current_profit: float, **kwargs) -> float:
-
-        # Make sure you have the longest interval first - these conditions are evaluated from top to bottom.
-        if current_time - timedelta(minutes=120) > trade.open_date_utc:
-            return -0.05
-        elif current_time - timedelta(minutes=60) > trade.open_date_utc:
-            return -0.10
-        return 1
-```
-
-#### Different stoploss per pair
-
-Use a different stoploss depending on the pair.
-In this example, we'll trail the highest price with 10% trailing stoploss for `ETH/BTC` and `XRP/BTC`, with 5% trailing stoploss for `LTC/BTC` and with 15% for all other pairs.
-
-``` python
-from datetime import datetime
-from freqtrade.persistence import Trade
-
-class AwesomeStrategy(IStrategy):
-
-    # ... populate_* methods
-
-    use_custom_stoploss = True
-
-    def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
-                        current_rate: float, current_profit: float, **kwargs) -> float:
-
-        if pair in ('ETH/BTC', 'XRP/BTC'):
-            return -0.10
-        elif pair in ('LTC/BTC'):
-            return -0.05
-        return -0.15
-```
-
-#### Trailing stoploss with positive offset
-
-Use the initial stoploss until the profit is above 4%, then use a trailing stoploss of 50% of the current profit with a minimum of 2.5% and a maximum of 5%.
-
-Please note that the stoploss can only increase, values lower than the current stoploss are ignored.
-
-``` python
-from datetime import datetime, timedelta
-from freqtrade.persistence import Trade
-
-class AwesomeStrategy(IStrategy):
-
-    # ... populate_* methods
-
-    use_custom_stoploss = True
-
-    def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
-                        current_rate: float, current_profit: float, **kwargs) -> float:
-
-        if current_profit < 0.04:
-            return -1 # return a value bigger than the initial stoploss to keep using the initial stoploss
-
-        # After reaching the desired offset, allow the stoploss to trail by half the profit
-        desired_stoploss = current_profit / 2
-
-        # Use a minimum of 2.5% and a maximum of 5%
-        return max(min(desired_stoploss, 0.05), 0.025)
-```
-
-#### Calculating stoploss relative to open price
-
-Stoploss values returned from `custom_stoploss()` always specify a percentage relative to `current_rate`. In order to set a stoploss relative to the *open* price, we need to use `current_profit` to calculate what percentage relative to the `current_rate` will give you the same result as if the percentage was specified from the open price.
-
-The helper function [`stoploss_from_open()`](strategy-customization.md#stoploss_from_open) can be used to convert from an open price relative stop, to a current price relative stop which can be returned from `custom_stoploss()`.
-
-### Calculating stoploss percentage from absolute price
-
-Stoploss values returned from `custom_stoploss()` always specify a percentage relative to `current_rate`. In order to set a stoploss at specified absolute price level, we need to use `stop_rate` to calculate what percentage relative to the `current_rate` will give you the same result as if the percentage was specified from the open price.
-
-The helper function [`stoploss_from_absolute()`](strategy-customization.md#stoploss_from_absolute) can be used to convert from an absolute price, to a current price relative stop which can be returned from `custom_stoploss()`.
-
-#### Stepped stoploss
-
-Instead of continuously trailing behind the current price, this example sets fixed stoploss price levels based on the current profit.
-
-* Use the regular stoploss until 20% profit is reached
-* Once profit is > 20% - set stoploss to 7% above open price.
-* Once profit is > 25% - set stoploss to 15% above open price.
-* Once profit is > 40% - set stoploss to 25% above open price.
-
-``` python
-from datetime import datetime
-from freqtrade.persistence import Trade
-from freqtrade.strategy import stoploss_from_open
-
-class AwesomeStrategy(IStrategy):
-
-    # ... populate_* methods
-
-    use_custom_stoploss = True
-
-    def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
-                        current_rate: float, current_profit: float, **kwargs) -> float:
-
-        # evaluate highest to lowest, so that highest possible stop is used
-        if current_profit > 0.40:
-            return stoploss_from_open(0.25, current_profit)
-        elif current_profit > 0.25:
-            return stoploss_from_open(0.15, current_profit)
-        elif current_profit > 0.20:
-            return stoploss_from_open(0.07, current_profit)
-
-        # return maximum stoploss value, keeping current stoploss price unchanged
-        return 1
-```
-
-#### Custom stoploss using an indicator from dataframe example
-
-Absolute stoploss value may be derived from indicators stored in dataframe. Example uses parabolic SAR below the price as stoploss.
-
-``` python
-class AwesomeStrategy(IStrategy):
-
-    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
-        # <...>
-        dataframe['sar'] = ta.SAR(dataframe)
-
-    use_custom_stoploss = True
-
-    def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
-                        current_rate: float, current_profit: float, **kwargs) -> float:
-
-        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
-        last_candle = dataframe.iloc[-1].squeeze()
-
-        # Use parabolic sar as absolute stoploss price
-        stoploss_price = last_candle['sar']
-
-        # Convert absolute price to percentage relative to current_rate
-        if stoploss_price < current_rate:
-            return (stoploss_price / current_rate) - 1
-
-        # return maximum stoploss value, keeping current stoploss price unchanged
-        return 1
-```
-
-See [Dataframe access](#dataframe-access) for more information about dataframe use in strategy callbacks.
-
----
-
-## Custom order price rules
-
-By default, freqtrade use the orderbook to automatically set an order price([Relevant documentation](configuration.md#prices-used-for-orders)), you also have the option to create custom order prices based on your strategy.
-
-You can use this feature by creating a `custom_entry_price()` function in your strategy file to customize entry prices and `custom_exit_price()` for exits.
+The provided exit-tag is then used as sell-reason - and shown as such in backtest results.
 
 !!! Note
-    If your custom pricing function return None or an invalid value, price will fall back to `proposed_rate`, which is based on the regular pricing configuration.
+    `sell_reason` is limited to 100 characters, remaining data will be truncated.
 
-### Custom order entry and exit price example
+## Strategy version
+
+You can implement custom strategy versioning by using the "version" method, and returning the version you would like this strategy to have.
 
 ``` python
-from datetime import datetime, timedelta, timezone
-from freqtrade.persistence import Trade
-
-class AwesomeStrategy(IStrategy):
-
-    # ... populate_* methods
-
-    def custom_entry_price(self, pair: str, current_time: datetime,
-                           proposed_rate, **kwargs) -> float:
-
-        dataframe, last_updated = self.dp.get_analyzed_dataframe(pair=pair,
-                                                                timeframe=self.timeframe)
-        new_entryprice = dataframe['bollinger_10_lowerband'].iat[-1]
-        
-        return new_entryprice
-
-    def custom_exit_price(self, pair: str, trade: Trade,
-                          current_time: datetime, proposed_rate: float,
-                          current_profit: float, **kwargs) -> float:
-
-        dataframe, last_updated = self.dp.get_analyzed_dataframe(pair=pair,
-                                                                timeframe=self.timeframe)
-        new_exitprice = dataframe['bollinger_10_upperband'].iat[-1]
-        
-        return new_exitprice
-
-```
-
-!!! Warning
-    Modifying entry and exit prices will only work for limit orders. Depending on the price chosen, this can result in a lot of unfilled orders. By default the maximum allowed distance between the current price and the custom price is 2%, this value can be changed in config with the `custom_price_max_distance_ratio` parameter.
-
-!!! Example
-    If the new_entryprice is 97, the proposed_rate is 100 and the `custom_price_max_distance_ratio` is set to 2%, The retained valid custom entry price will be 98.
-
-!!! Warning "No backtesting support"
-    Custom entry-prices are currently not supported during backtesting.
-
-## Custom order timeout rules
-
-Simple, time-based order-timeouts can be configured either via strategy or in the configuration in the `unfilledtimeout` section.
-
-However, freqtrade also offers a custom callback for both order types, which allows you to decide based on custom criteria if an order did time out or not.
-
-!!! Note
-    Unfilled order timeouts are not relevant during backtesting or hyperopt, and are only relevant during real (live) trading. Therefore these methods are only called in these circumstances.
-
-### Custom order timeout example
-
-A simple example, which applies different unfilled-timeouts depending on the price of the asset can be seen below.
-It applies a tight timeout for higher priced assets, while allowing more time to fill on cheap coins.
-
-The function must return either `True` (cancel order) or `False` (keep order alive).
-
-``` python
-from datetime import datetime, timedelta, timezone
-from freqtrade.persistence import Trade
-
-class AwesomeStrategy(IStrategy):
-
-    # ... populate_* methods
-
-    # Set unfilledtimeout to 25 hours, since our maximum timeout from below is 24 hours.
-    unfilledtimeout = {
-        'buy': 60 * 25,
-        'sell': 60 * 25
-    }
-
-    def check_buy_timeout(self, pair: str, trade: 'Trade', order: dict, **kwargs) -> bool:
-        if trade.open_rate > 100 and trade.open_date_utc < datetime.now(timezone.utc) - timedelta(minutes=5):
-            return True
-        elif trade.open_rate > 10 and trade.open_date_utc < datetime.now(timezone.utc) - timedelta(minutes=3):
-            return True
-        elif trade.open_rate < 1 and trade.open_date_utc < datetime.now(timezone.utc) - timedelta(hours=24):
-           return True
-        return False
-
-
-    def check_sell_timeout(self, pair: str, trade: 'Trade', order: dict, **kwargs) -> bool:
-        if trade.open_rate > 100 and trade.open_date_utc < datetime.now(timezone.utc) - timedelta(minutes=5):
-            return True
-        elif trade.open_rate > 10 and trade.open_date_utc < datetime.now(timezone.utc) - timedelta(minutes=3):
-            return True
-        elif trade.open_rate < 1 and trade.open_date_utc < datetime.now(timezone.utc) - timedelta(hours=24):
-           return True
-        return False
+def version(self) -> str:
+    """
+    Returns version of the strategy.
+    """
+    return "1.1"
 ```
 
 !!! Note
-    For the above example, `unfilledtimeout` must be set to something bigger than 24h, otherwise that type of timeout will apply first.
-
-### Custom order timeout example (using additional data)
-
-``` python
-from datetime import datetime
-from freqtrade.persistence import Trade
-
-class AwesomeStrategy(IStrategy):
-
-    # ... populate_* methods
-
-    # Set unfilledtimeout to 25 hours, since our maximum timeout from below is 24 hours.
-    unfilledtimeout = {
-        'buy': 60 * 25,
-        'sell': 60 * 25
-    }
-
-    def check_buy_timeout(self, pair: str, trade: Trade, order: dict, **kwargs) -> bool:
-        ob = self.dp.orderbook(pair, 1)
-        current_price = ob['bids'][0][0]
-        # Cancel buy order if price is more than 2% above the order.
-        if current_price > order['price'] * 1.02:
-            return True
-        return False
-
-
-    def check_sell_timeout(self, pair: str, trade: Trade, order: dict, **kwargs) -> bool:
-        ob = self.dp.orderbook(pair, 1)
-        current_price = ob['asks'][0][0]
-        # Cancel sell order if price is more than 2% below the order.
-        if current_price < order['price'] * 0.98:
-            return True
-        return False
-```
-
----
-
-## Bot loop start callback
-
-A simple callback which is called once at the start of every bot throttling iteration.
-This can be used to perform calculations which are pair independent (apply to all pairs), loading of external data, etc.
-
-``` python
-import requests
-
-class AwesomeStrategy(IStrategy):
-
-    # ... populate_* methods
-
-    def bot_loop_start(self, **kwargs) -> None:
-        """
-        Called at the start of the bot iteration (one loop).
-        Might be used to perform pair-independent tasks
-        (e.g. gather some remote resource for comparison)
-        :param **kwargs: Ensure to keep this here so updates to this won't break your strategy.
-        """
-        if self.config['runmode'].value in ('live', 'dry_run'):
-            # Assign this to the class by using self.*
-            # can then be used by populate_* methods
-            self.remote_data = requests.get('https://some_remote_source.example.com')
-
-```
-
-## Bot order confirmation
-
-### Trade entry (buy order) confirmation
-
-`confirm_trade_entry()` can be used to abort a trade entry at the latest second (maybe because the price is not what we expect).
-
-``` python
-class AwesomeStrategy(IStrategy):
-
-    # ... populate_* methods
-
-    def confirm_trade_entry(self, pair: str, order_type: str, amount: float, rate: float,
-                            time_in_force: str, current_time: datetime, **kwargs) -> bool:
-        """
-        Called right before placing a buy order.
-        Timing for this function is critical, so avoid doing heavy computations or
-        network requests in this method.
-
-        For full documentation please go to https://www.freqtrade.io/en/latest/strategy-advanced/
-
-        When not implemented by a strategy, returns True (always confirming).
-
-        :param pair: Pair that's about to be bought.
-        :param order_type: Order type (as configured in order_types). usually limit or market.
-        :param amount: Amount in target (quote) currency that's going to be traded.
-        :param rate: Rate that's going to be used when using limit orders
-        :param time_in_force: Time in force. Defaults to GTC (Good-til-cancelled).
-        :param current_time: datetime object, containing the current datetime
-        :param **kwargs: Ensure to keep this here so updates to this won't break your strategy.
-        :return bool: When True is returned, then the buy-order is placed on the exchange.
-            False aborts the process
-        """
-        return True
-
-```
-
-### Trade exit (sell order) confirmation
-
-`confirm_trade_exit()` can be used to abort a trade exit (sell) at the latest second (maybe because the price is not what we expect).
-
-``` python
-from freqtrade.persistence import Trade
-
-
-class AwesomeStrategy(IStrategy):
-
-    # ... populate_* methods
-
-    def confirm_trade_exit(self, pair: str, trade: Trade, order_type: str, amount: float,
-                           rate: float, time_in_force: str, sell_reason: str,
-                           current_time: datetime, **kwargs) -> bool:
-        """
-        Called right before placing a regular sell order.
-        Timing for this function is critical, so avoid doing heavy computations or
-        network requests in this method.
-
-        For full documentation please go to https://www.freqtrade.io/en/latest/strategy-advanced/
-
-        When not implemented by a strategy, returns True (always confirming).
-
-        :param pair: Pair that's about to be sold.
-        :param order_type: Order type (as configured in order_types). usually limit or market.
-        :param amount: Amount in quote currency.
-        :param rate: Rate that's going to be used when using limit orders
-        :param time_in_force: Time in force. Defaults to GTC (Good-til-cancelled).
-        :param sell_reason: Sell reason.
-            Can be any of ['roi', 'stop_loss', 'stoploss_on_exchange', 'trailing_stop_loss',
-                           'sell_signal', 'force_sell', 'emergency_sell']
-        :param current_time: datetime object, containing the current datetime
-        :param **kwargs: Ensure to keep this here so updates to this won't break your strategy.
-        :return bool: When True is returned, then the sell-order is placed on the exchange.
-            False aborts the process
-        """
-        if sell_reason == 'force_sell' and trade.calc_profit_ratio(rate) < 0:
-            # Reject force-sells with negative profit
-            # This is just a sample, please adjust to your needs
-            # (this does not necessarily make sense, assuming you know when you're force-selling)
-            return False
-        return True
-
-```
-
-### Stake size management
-
-It is possible to manage your risk by reducing or increasing stake amount when placing a new trade.
-
-```python
-class AwesomeStrategy(IStrategy):
-    def custom_stake_amount(self, pair: str, current_time: datetime, current_rate: float,
-                            proposed_stake: float, min_stake: float, max_stake: float,
-                            **kwargs) -> float:
-
-        dataframe, _ = self.dp.get_analyzed_dataframe(pair=pair, timeframe=self.timeframe)
-        current_candle = dataframe.iloc[-1].squeeze()
-
-        if current_candle['fastk_rsi_1h'] > current_candle['fastd_rsi_1h']:
-            if self.config['stake_amount'] == 'unlimited':
-                # Use entire available wallet during favorable conditions when in compounding mode.
-                return max_stake
-            else:
-                # Compound profits during favorable conditions instead of using a static stake.
-                return self.wallets.get_total_stake_amount() / self.config['max_open_trades']
-
-        # Use default stake amount.
-        return proposed_stake
-```
-
-Freqtrade will fall back to the `proposed_stake` value should your code raise an exception. The exception itself will be logged.
-
-!!! Tip
-    You do not _have_ to ensure that `min_stake <= returned_value <= max_stake`. Trades will succeed as the returned value will be clamped to supported range and this acton will be logged.
-
-!!! Tip
-    Returning `0` or `None` will prevent trades from being placed.
-
----
+    You should make sure to implement proper version control (like a git repository) alongside this, as freqtrade will not keep historic versions of your strategy, so it's up to the user to be able to eventually roll back to a prior version of the strategy.
 
 ## Derived strategies
 

docs/strategy-callbacks.md

@@ -0,0 +1,570 @@
+# Strategy Callbacks
+
+While the main strategy functions (`populate_indicators()`, `populate_buy_trend()`, `populate_sell_trend()`) should be used in a vectorized way, and are only called [once during backtesting](bot-basics.md#backtesting-hyperopt-execution-logic), callbacks are called "whenever needed".
+
+As such, you should avoid doing heavy calculations in callbacks to avoid delays during operations.
+Depending on the callback used, they may be called when entering / exiting a trade, or throughout the duration of a trade.
+
+Currently available callbacks:
+
+* [`bot_loop_start()`](#bot-loop-start)
+* [`custom_stake_amount()`](#custom-stake-size)
+* [`custom_sell()`](#custom-sell-signal)
+* [`custom_stoploss()`](#custom-stoploss)
+* [`custom_entry_price()` and `custom_exit_price()`](#custom-order-price-rules)
+* [`check_buy_timeout()` and `check_sell_timeout()](#custom-order-timeout-rules)
+* [`confirm_trade_entry()`](#trade-entry-buy-order-confirmation)
+* [`confirm_trade_exit()`](#trade-exit-sell-order-confirmation)
+
+!!! Tip "Callback calling sequence"
+    You can find the callback calling sequence in [bot-basics](bot-basics.md#bot-execution-logic)
+
+## Bot loop start
+
+A simple callback which is called once at the start of every bot throttling iteration (roughly every 5 seconds, unless configured differently).
+This can be used to perform calculations which are pair independent (apply to all pairs), loading of external data, etc.
+
+``` python
+import requests
+
+class AwesomeStrategy(IStrategy):
+
+    # ... populate_* methods
+
+    def bot_loop_start(self, **kwargs) -> None:
+        """
+        Called at the start of the bot iteration (one loop).
+        Might be used to perform pair-independent tasks
+        (e.g. gather some remote resource for comparison)
+        :param **kwargs: Ensure to keep this here so updates to this won't break your strategy.
+        """
+        if self.config['runmode'].value in ('live', 'dry_run'):
+            # Assign this to the class by using self.*
+            # can then be used by populate_* methods
+            self.remote_data = requests.get('https://some_remote_source.example.com')
+
+```
+
+## Custom Stake size
+
+Called before entering a trade, makes it possible to manage your position size when placing a new trade.
+
+```python
+class AwesomeStrategy(IStrategy):
+    def custom_stake_amount(self, pair: str, current_time: datetime, current_rate: float,
+                            proposed_stake: float, min_stake: float, max_stake: float,
+                            **kwargs) -> float:
+
+        dataframe, _ = self.dp.get_analyzed_dataframe(pair=pair, timeframe=self.timeframe)
+        current_candle = dataframe.iloc[-1].squeeze()
+
+        if current_candle['fastk_rsi_1h'] > current_candle['fastd_rsi_1h']:
+            if self.config['stake_amount'] == 'unlimited':
+                # Use entire available wallet during favorable conditions when in compounding mode.
+                return max_stake
+            else:
+                # Compound profits during favorable conditions instead of using a static stake.
+                return self.wallets.get_total_stake_amount() / self.config['max_open_trades']
+
+        # Use default stake amount.
+        return proposed_stake
+```
+
+Freqtrade will fall back to the `proposed_stake` value should your code raise an exception. The exception itself will be logged.
+
+!!! Tip
+    You do not _have_ to ensure that `min_stake <= returned_value <= max_stake`. Trades will succeed as the returned value will be clamped to supported range and this acton will be logged.
+
+!!! Tip
+    Returning `0` or `None` will prevent trades from being placed.
+
+## Custom sell signal
+
+Called for open trade every throttling iteration (roughly every 5 seconds) until a trade is closed.
+
+Allows to define custom sell signals, indicating that specified position should be sold. This is very useful when we need to customize sell conditions for each individual trade, or if you need trade data to make an exit decision.
+
+For example you could implement a 1:2 risk-reward ROI with `custom_sell()`.
+
+Using custom_sell() signals in place of stoploss though *is not recommended*. It is a inferior method to using `custom_stoploss()` in this regard - which also allows you to keep the stoploss on exchange.
+
+!!! Note
+    Returning a (none-empty) `string` or `True` from this method is equal to setting sell signal on a candle at specified time. This method is not called when sell signal is set already, or if sell signals are disabled (`use_sell_signal=False` or `sell_profit_only=True` while profit is below `sell_profit_offset`). `string` max length is 64 characters. Exceeding this limit will cause the message to be truncated to 64 characters.
+
+An example of how we can use different indicators depending on the current profit and also sell trades that were open longer than one day:
+
+``` python
+class AwesomeStrategy(IStrategy):
+    def custom_sell(self, pair: str, trade: 'Trade', current_time: 'datetime', current_rate: float,
+                    current_profit: float, **kwargs):
+        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
+        last_candle = dataframe.iloc[-1].squeeze()
+
+        # Above 20% profit, sell when rsi < 80
+        if current_profit > 0.2:
+            if last_candle['rsi'] < 80:
+                return 'rsi_below_80'
+
+        # Between 2% and 10%, sell if EMA-long above EMA-short
+        if 0.02 < current_profit < 0.1:
+            if last_candle['emalong'] > last_candle['emashort']:
+                return 'ema_long_below_80'
+
+        # Sell any positions at a loss if they are held for more than one day.
+        if current_profit < 0.0 and (current_time - trade.open_date_utc).days >= 1:
+            return 'unclog'
+```
+
+See [Dataframe access](strategy-advanced.md#dataframe-access) for more information about dataframe use in strategy callbacks.
+
+## Custom stoploss
+
+Called for open trade every throttling iteration (roughly every 5 seconds) until a trade is closed. 
+The usage of the custom stoploss method must be enabled by setting `use_custom_stoploss=True` on the strategy object.
+
+The stoploss price can only ever move upwards - if the stoploss value returned from `custom_stoploss` would result in a lower stoploss price than was previously set, it will be ignored. The traditional `stoploss` value serves as an absolute lower level and will be instated as the initial stoploss (before this method is called for the first time for a trade).
+
+The method must return a stoploss value (float / number) as a percentage of the current price.
+E.g. If the `current_rate` is 200 USD, then returning `0.02` will set the stoploss price 2% lower, at 196 USD.
+
+The absolute value of the return value is used (the sign is ignored), so returning `0.05` or `-0.05` have the same result, a stoploss 5% below the current price.
+
+To simulate a regular trailing stoploss of 4% (trailing 4% behind the maximum reached price) you would use the following very simple method:
+
+``` python
+# additional imports required
+from datetime import datetime
+from freqtrade.persistence import Trade
+
+class AwesomeStrategy(IStrategy):
+
+    # ... populate_* methods
+
+    use_custom_stoploss = True
+
+    def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
+                        current_rate: float, current_profit: float, **kwargs) -> float:
+        """
+        Custom stoploss logic, returning the new distance relative to current_rate (as ratio).
+        e.g. returning -0.05 would create a stoploss 5% below current_rate.
+        The custom stoploss can never be below self.stoploss, which serves as a hard maximum loss.
+
+        For full documentation please go to https://www.freqtrade.io/en/latest/strategy-advanced/
+
+        When not implemented by a strategy, returns the initial stoploss value
+        Only called when use_custom_stoploss is set to True.
+
+        :param pair: Pair that's currently analyzed
+        :param trade: trade object.
+        :param current_time: datetime object, containing the current datetime
+        :param current_rate: Rate, calculated based on pricing settings in ask_strategy.
+        :param current_profit: Current profit (as ratio), calculated based on current_rate.
+        :param **kwargs: Ensure to keep this here so updates to this won't break your strategy.
+        :return float: New stoploss value, relative to the current rate
+        """
+        return -0.04
+```
+
+Stoploss on exchange works similar to `trailing_stop`, and the stoploss on exchange is updated as configured in `stoploss_on_exchange_interval` ([More details about stoploss on exchange](stoploss.md#stop-loss-on-exchange-freqtrade)).
+
+!!! Note "Use of dates"
+    All time-based calculations should be done based on `current_time` - using `datetime.now()` or `datetime.utcnow()` is discouraged, as this will break backtesting support.
+
+!!! Tip "Trailing stoploss"
+    It's recommended to disable `trailing_stop` when using custom stoploss values. Both can work in tandem, but you might encounter the trailing stop to move the price higher while your custom function would not want this, causing conflicting behavior.
+
+### Custom stoploss examples
+
+The next section will show some examples on what's possible with the custom stoploss function.
+Of course, many more things are possible, and all examples can be combined at will.
+
+#### Time based trailing stop
+
+Use the initial stoploss for the first 60 minutes, after this change to 10% trailing stoploss, and after 2 hours (120 minutes) we use a 5% trailing stoploss.
+
+``` python
+from datetime import datetime, timedelta
+from freqtrade.persistence import Trade
+
+class AwesomeStrategy(IStrategy):
+
+    # ... populate_* methods
+
+    use_custom_stoploss = True
+
+    def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
+                        current_rate: float, current_profit: float, **kwargs) -> float:
+
+        # Make sure you have the longest interval first - these conditions are evaluated from top to bottom.
+        if current_time - timedelta(minutes=120) > trade.open_date_utc:
+            return -0.05
+        elif current_time - timedelta(minutes=60) > trade.open_date_utc:
+            return -0.10
+        return 1
+```
+
+#### Different stoploss per pair
+
+Use a different stoploss depending on the pair.
+In this example, we'll trail the highest price with 10% trailing stoploss for `ETH/BTC` and `XRP/BTC`, with 5% trailing stoploss for `LTC/BTC` and with 15% for all other pairs.
+
+``` python
+from datetime import datetime
+from freqtrade.persistence import Trade
+
+class AwesomeStrategy(IStrategy):
+
+    # ... populate_* methods
+
+    use_custom_stoploss = True
+
+    def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
+                        current_rate: float, current_profit: float, **kwargs) -> float:
+
+        if pair in ('ETH/BTC', 'XRP/BTC'):
+            return -0.10
+        elif pair in ('LTC/BTC'):
+            return -0.05
+        return -0.15
+```
+
+#### Trailing stoploss with positive offset
+
+Use the initial stoploss until the profit is above 4%, then use a trailing stoploss of 50% of the current profit with a minimum of 2.5% and a maximum of 5%.
+
+Please note that the stoploss can only increase, values lower than the current stoploss are ignored.
+
+``` python
+from datetime import datetime, timedelta
+from freqtrade.persistence import Trade
+
+class AwesomeStrategy(IStrategy):
+
+    # ... populate_* methods
+
+    use_custom_stoploss = True
+
+    def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
+                        current_rate: float, current_profit: float, **kwargs) -> float:
+
+        if current_profit < 0.04:
+            return -1 # return a value bigger than the initial stoploss to keep using the initial stoploss
+
+        # After reaching the desired offset, allow the stoploss to trail by half the profit
+        desired_stoploss = current_profit / 2
+
+        # Use a minimum of 2.5% and a maximum of 5%
+        return max(min(desired_stoploss, 0.05), 0.025)
+```
+
+#### Stepped stoploss
+
+Instead of continuously trailing behind the current price, this example sets fixed stoploss price levels based on the current profit.
+
+* Use the regular stoploss until 20% profit is reached
+* Once profit is > 20% - set stoploss to 7% above open price.
+* Once profit is > 25% - set stoploss to 15% above open price.
+* Once profit is > 40% - set stoploss to 25% above open price.
+
+``` python
+from datetime import datetime
+from freqtrade.persistence import Trade
+from freqtrade.strategy import stoploss_from_open
+
+class AwesomeStrategy(IStrategy):
+
+    # ... populate_* methods
+
+    use_custom_stoploss = True
+
+    def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
+                        current_rate: float, current_profit: float, **kwargs) -> float:
+
+        # evaluate highest to lowest, so that highest possible stop is used
+        if current_profit > 0.40:
+            return stoploss_from_open(0.25, current_profit)
+        elif current_profit > 0.25:
+            return stoploss_from_open(0.15, current_profit)
+        elif current_profit > 0.20:
+            return stoploss_from_open(0.07, current_profit)
+
+        # return maximum stoploss value, keeping current stoploss price unchanged
+        return 1
+```
+
+#### Custom stoploss using an indicator from dataframe example
+
+Absolute stoploss value may be derived from indicators stored in dataframe. Example uses parabolic SAR below the price as stoploss.
+
+``` python
+class AwesomeStrategy(IStrategy):
+
+    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        # <...>
+        dataframe['sar'] = ta.SAR(dataframe)
+
+    use_custom_stoploss = True
+
+    def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
+                        current_rate: float, current_profit: float, **kwargs) -> float:
+
+        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
+        last_candle = dataframe.iloc[-1].squeeze()
+
+        # Use parabolic sar as absolute stoploss price
+        stoploss_price = last_candle['sar']
+
+        # Convert absolute price to percentage relative to current_rate
+        if stoploss_price < current_rate:
+            return (stoploss_price / current_rate) - 1
+
+        # return maximum stoploss value, keeping current stoploss price unchanged
+        return 1
+```
+
+See [Dataframe access](strategy-advanced.md#dataframe-access) for more information about dataframe use in strategy callbacks.
+
+### Common helpers for stoploss calculations
+
+#### Stoploss relative to open price
+
+Stoploss values returned from `custom_stoploss()` always specify a percentage relative to `current_rate`. In order to set a stoploss relative to the *open* price, we need to use `current_profit` to calculate what percentage relative to the `current_rate` will give you the same result as if the percentage was specified from the open price.
+
+The helper function [`stoploss_from_open()`](strategy-customization.md#stoploss_from_open) can be used to convert from an open price relative stop, to a current price relative stop which can be returned from `custom_stoploss()`.
+
+#### Stoploss percentage from absolute price
+
+Stoploss values returned from `custom_stoploss()` always specify a percentage relative to `current_rate`. In order to set a stoploss at specified absolute price level, we need to use `stop_rate` to calculate what percentage relative to the `current_rate` will give you the same result as if the percentage was specified from the open price.
+
+The helper function [`stoploss_from_absolute()`](strategy-customization.md#stoploss_from_absolute) can be used to convert from an absolute price, to a current price relative stop which can be returned from `custom_stoploss()`.
+
+---
+
+## Custom order price rules
+
+By default, freqtrade use the orderbook to automatically set an order price([Relevant documentation](configuration.md#prices-used-for-orders)), you also have the option to create custom order prices based on your strategy.
+
+You can use this feature by creating a `custom_entry_price()` function in your strategy file to customize entry prices and `custom_exit_price()` for exits.
+
+Each of these methods are called right before placing an order on the exchange.
+
+!!! Note
+    If your custom pricing function return None or an invalid value, price will fall back to `proposed_rate`, which is based on the regular pricing configuration.
+
+### Custom order entry and exit price example
+
+``` python
+from datetime import datetime, timedelta, timezone
+from freqtrade.persistence import Trade
+
+class AwesomeStrategy(IStrategy):
+
+    # ... populate_* methods
+
+    def custom_entry_price(self, pair: str, current_time: datetime,
+                           proposed_rate, **kwargs) -> float:
+
+        dataframe, last_updated = self.dp.get_analyzed_dataframe(pair=pair,
+                                                                timeframe=self.timeframe)
+        new_entryprice = dataframe['bollinger_10_lowerband'].iat[-1]
+        
+        return new_entryprice
+
+    def custom_exit_price(self, pair: str, trade: Trade,
+                          current_time: datetime, proposed_rate: float,
+                          current_profit: float, **kwargs) -> float:
+
+        dataframe, last_updated = self.dp.get_analyzed_dataframe(pair=pair,
+                                                                timeframe=self.timeframe)
+        new_exitprice = dataframe['bollinger_10_upperband'].iat[-1]
+        
+        return new_exitprice
+
+```
+
+!!! Warning
+    Modifying entry and exit prices will only work for limit orders. Depending on the price chosen, this can result in a lot of unfilled orders. By default the maximum allowed distance between the current price and the custom price is 2%, this value can be changed in config with the `custom_price_max_distance_ratio` parameter.  
+    **Example**:  
+    If the new_entryprice is 97, the proposed_rate is 100 and the `custom_price_max_distance_ratio` is set to 2%, The retained valid custom entry price will be 98, which is 2% below the current (proposed) rate.
+
+!!! Warning "Backtesting"
+    While Custom prices are supported in backtesting (starting with 2021.12), prices will be moved to within the candle's high/low prices.
+    This behavior is currently being tested, and might be changed at a later point.
+    `custom_exit_price()` is only called for sells of type Sell_signal and Custom sell. All other sell-types will use regular backtesting prices.
+
+## Custom order timeout rules
+
+Simple, time-based order-timeouts can be configured either via strategy or in the configuration in the `unfilledtimeout` section.
+
+However, freqtrade also offers a custom callback for both order types, which allows you to decide based on custom criteria if an order did time out or not.
+
+!!! Note
+    Unfilled order timeouts are not relevant during backtesting or hyperopt, and are only relevant during real (live) trading. Therefore these methods are only called in these circumstances.
+
+### Custom order timeout example
+
+Called for every open order until that order is either filled or cancelled.
+`check_buy_timeout()` is called for trade entries, while `check_sell_timeout()` is called for trade exit orders.
+
+A simple example, which applies different unfilled-timeouts depending on the price of the asset can be seen below.
+It applies a tight timeout for higher priced assets, while allowing more time to fill on cheap coins.
+
+The function must return either `True` (cancel order) or `False` (keep order alive).
+
+``` python
+from datetime import datetime, timedelta, timezone
+from freqtrade.persistence import Trade
+
+class AwesomeStrategy(IStrategy):
+
+    # ... populate_* methods
+
+    # Set unfilledtimeout to 25 hours, since the maximum timeout from below is 24 hours.
+    unfilledtimeout = {
+        'buy': 60 * 25,
+        'sell': 60 * 25
+    }
+
+    def check_buy_timeout(self, pair: str, trade: 'Trade', order: dict, **kwargs) -> bool:
+        if trade.open_rate > 100 and trade.open_date_utc < datetime.now(timezone.utc) - timedelta(minutes=5):
+            return True
+        elif trade.open_rate > 10 and trade.open_date_utc < datetime.now(timezone.utc) - timedelta(minutes=3):
+            return True
+        elif trade.open_rate < 1 and trade.open_date_utc < datetime.now(timezone.utc) - timedelta(hours=24):
+           return True
+        return False
+
+
+    def check_sell_timeout(self, pair: str, trade: 'Trade', order: dict, **kwargs) -> bool:
+        if trade.open_rate > 100 and trade.open_date_utc < datetime.now(timezone.utc) - timedelta(minutes=5):
+            return True
+        elif trade.open_rate > 10 and trade.open_date_utc < datetime.now(timezone.utc) - timedelta(minutes=3):
+            return True
+        elif trade.open_rate < 1 and trade.open_date_utc < datetime.now(timezone.utc) - timedelta(hours=24):
+           return True
+        return False
+```
+
+!!! Note
+    For the above example, `unfilledtimeout` must be set to something bigger than 24h, otherwise that type of timeout will apply first.
+
+### Custom order timeout example (using additional data)
+
+``` python
+from datetime import datetime
+from freqtrade.persistence import Trade
+
+class AwesomeStrategy(IStrategy):
+
+    # ... populate_* methods
+
+    # Set unfilledtimeout to 25 hours, since the maximum timeout from below is 24 hours.
+    unfilledtimeout = {
+        'buy': 60 * 25,
+        'sell': 60 * 25
+    }
+
+    def check_buy_timeout(self, pair: str, trade: Trade, order: dict, **kwargs) -> bool:
+        ob = self.dp.orderbook(pair, 1)
+        current_price = ob['bids'][0][0]
+        # Cancel buy order if price is more than 2% above the order.
+        if current_price > order['price'] * 1.02:
+            return True
+        return False
+
+
+    def check_sell_timeout(self, pair: str, trade: Trade, order: dict, **kwargs) -> bool:
+        ob = self.dp.orderbook(pair, 1)
+        current_price = ob['asks'][0][0]
+        # Cancel sell order if price is more than 2% below the order.
+        if current_price < order['price'] * 0.98:
+            return True
+        return False
+```
+
+---
+
+## Bot order confirmation
+
+Confirm trade entry / exits.
+This are the last methods that will be called before an order is placed.
+
+### Trade entry (buy order) confirmation
+
+`confirm_trade_entry()` can be used to abort a trade entry at the latest second (maybe because the price is not what we expect).
+
+``` python
+class AwesomeStrategy(IStrategy):
+
+    # ... populate_* methods
+
+    def confirm_trade_entry(self, pair: str, order_type: str, amount: float, rate: float,
+                            time_in_force: str, current_time: datetime, **kwargs) -> bool:
+        """
+        Called right before placing a buy order.
+        Timing for this function is critical, so avoid doing heavy computations or
+        network requests in this method.
+
+        For full documentation please go to https://www.freqtrade.io/en/latest/strategy-advanced/
+
+        When not implemented by a strategy, returns True (always confirming).
+
+        :param pair: Pair that's about to be bought.
+        :param order_type: Order type (as configured in order_types). usually limit or market.
+        :param amount: Amount in target (quote) currency that's going to be traded.
+        :param rate: Rate that's going to be used when using limit orders
+        :param time_in_force: Time in force. Defaults to GTC (Good-til-cancelled).
+        :param current_time: datetime object, containing the current datetime
+        :param **kwargs: Ensure to keep this here so updates to this won't break your strategy.
+        :return bool: When True is returned, then the buy-order is placed on the exchange.
+            False aborts the process
+        """
+        return True
+
+```
+
+### Trade exit (sell order) confirmation
+
+`confirm_trade_exit()` can be used to abort a trade exit (sell) at the latest second (maybe because the price is not what we expect).
+
+``` python
+from freqtrade.persistence import Trade
+
+
+class AwesomeStrategy(IStrategy):
+
+    # ... populate_* methods
+
+    def confirm_trade_exit(self, pair: str, trade: Trade, order_type: str, amount: float,
+                           rate: float, time_in_force: str, sell_reason: str,
+                           current_time: datetime, **kwargs) -> bool:
+        """
+        Called right before placing a regular sell order.
+        Timing for this function is critical, so avoid doing heavy computations or
+        network requests in this method.
+
+        For full documentation please go to https://www.freqtrade.io/en/latest/strategy-advanced/
+
+        When not implemented by a strategy, returns True (always confirming).
+
+        :param pair: Pair that's about to be sold.
+        :param order_type: Order type (as configured in order_types). usually limit or market.
+        :param amount: Amount in quote currency.
+        :param rate: Rate that's going to be used when using limit orders
+        :param time_in_force: Time in force. Defaults to GTC (Good-til-cancelled).
+        :param sell_reason: Sell reason.
+            Can be any of ['roi', 'stop_loss', 'stoploss_on_exchange', 'trailing_stop_loss',
+                           'sell_signal', 'force_sell', 'emergency_sell']
+        :param current_time: datetime object, containing the current datetime
+        :param **kwargs: Ensure to keep this here so updates to this won't break your strategy.
+        :return bool: When True is returned, then the sell-order is placed on the exchange.
+            False aborts the process
+        """
+        if sell_reason == 'force_sell' and trade.calc_profit_ratio(rate) < 0:
+            # Reject force-sells with negative profit
+            # This is just a sample, please adjust to your needs
+            # (this does not necessarily make sense, assuming you know when you're force-selling)
+            return False
+        return True
+
+```

docs/strategy-customization.md

@@ -4,33 +4,23 @@ This page explains how to customize your strategies, add new indicators and set
 
 Please familiarize yourself with [Freqtrade basics](bot-basics.md) first, which provides overall info on how the bot operates.
 
-## Install a custom strategy file
-
-This is very simple. Copy paste your strategy file into the directory `user_data/strategies`.
-
-Let assume you have a class called `AwesomeStrategy` in the file `AwesomeStrategy.py`:
-
-1. Move your file into `user_data/strategies` (you should have `user_data/strategies/AwesomeStrategy.py`
-2. Start the bot with the param `--strategy AwesomeStrategy` (the parameter is the class name)
-
-```bash
-freqtrade trade --strategy AwesomeStrategy
-```
-
 ## Develop your own strategy
 
 The bot includes a default strategy file.
 Also, several other strategies are available in the [strategy repository](https://github.com/freqtrade/freqtrade-strategies).
 
 You will however most likely have your own idea for a strategy.
-This document intends to help you develop one for yourself.
+This document intends to help you convert your strategy idea into your own strategy.
 
-To get started, use `freqtrade new-strategy --strategy AwesomeStrategy`.
+To get started, use `freqtrade new-strategy --strategy AwesomeStrategy` (you can obviously use your own naming for your strategy).
 This will create a new strategy file from a template, which will be located under `user_data/strategies/AwesomeStrategy.py`.
 
 !!! Note
     This is just a template file, which will most likely not be profitable out of the box.
 
+??? Hint "Different template levels"
+    `freqtrade new-strategy` has an additional parameter, `--template`, which controls the amount of pre-build information you get in the created strategy. Use `--template minimal` to get an empty strategy without any indicator examples, or `--template advanced` to get a template with most callbacks defined.
+
 ### Anatomy of a strategy
 
 A strategy file contains all the information needed to build a good strategy:
@@ -67,6 +57,46 @@ file as reference.**
     needs to take care to avoid having the strategy utilize data from the future.
     Some common patterns for this are listed in the [Common Mistakes](#common-mistakes-when-developing-strategies) section of this document.
 
+### Dataframe
+
+Freqtrade uses [pandas](https://pandas.pydata.org/) to store/provide the candlestick (OHLCV) data.
+Pandas is a great library developed for processing large amounts of data.
+
+Each row in a dataframe corresponds to one candle on a chart, with the latest candle always being the last in the dataframe (sorted by date).
+
+``` output
+> dataframe.head()
+                       date      open      high       low     close     volume
+0 2021-11-09 23:25:00+00:00  67279.67  67321.84  67255.01  67300.97   44.62253
+1 2021-11-09 23:30:00+00:00  67300.97  67301.34  67183.03  67187.01   61.38076
+2 2021-11-09 23:35:00+00:00  67187.02  67187.02  67031.93  67123.81  113.42728
+3 2021-11-09 23:40:00+00:00  67123.80  67222.40  67080.33  67160.48   78.96008
+4 2021-11-09 23:45:00+00:00  67160.48  67160.48  66901.26  66943.37  111.39292
+```
+
+Pandas provides fast ways to calculate metrics. To benefit from this speed, it's advised to not use loops, but use vectorized methods instead.
+
+Vectorized operations perform calculations across the whole range of data and are therefore, compared to looping through each row, a lot faster when calculating indicators.
+
+As a dataframe is a table, simple python comparisons like the following will not work
+
+``` python
+    if dataframe['rsi'] > 30:
+        dataframe['buy'] = 1
+```
+
+The above section will fail with `The truth value of a Series is ambiguous. [...]`.
+
+This must instead be written in a pandas-compatible way, so the operation is performed across the whole dataframe.
+
+``` python
+    dataframe.loc[
+        (dataframe['rsi'] > 30)
+    , 'buy'] = 1
+```
+
+With this section, you have a new column in your dataframe, which has `1` assigned whenever RSI is above 30.
+
 ### Customize Indicators
 
 Buy and sell strategies need indicators. You can add more indicators by extending the list contained in the method `populate_indicators()` from your strategy file.
@@ -134,7 +164,7 @@ Additional technical libraries can be installed as necessary, or custom indicato
 
 ### Strategy startup period
 
-Most indicators have an instable startup period, in which they are either not available, or the calculation is incorrect. This can lead to inconsistencies, since Freqtrade does not know how long this instable period should be.
+Most indicators have an instable startup period, in which they are either not available (NaN), or the calculation is incorrect. This can lead to inconsistencies, since Freqtrade does not know how long this instable period should be.
 To account for this, the strategy can be assigned the `startup_candle_count` attribute.
 This should be set to the maximum number of candles that the strategy requires to calculate stable indicators.
 
@@ -146,8 +176,14 @@ In this example strategy, this should be set to 100 (`startup_candle_count = 100
 
 By letting the bot know how much history is needed, backtest trades can start at the specified timerange during backtesting and hyperopt.
 
+!!! Warning "Using x calls to get OHLCV"
+    If you receive a warning like `WARNING - Using 3 calls to get OHLCV. This can result in slower operations for the bot. Please check if you really need 1500 candles for your strategy` - you should consider if you really need this much historic data for your signals.
+    Having this will cause Freqtrade to make multiple calls for the same pair, which will obviously be slower than one network request.
+    As a consequence, Freqtrade will take longer to refresh candles - and should therefore be avoided if possible.
+    This is capped to 5 total calls to avoid overloading the exchange, or make freqtrade too slow.
+
 !!! Warning
-    `startup_candle_count` should be below `ohlcv_candle_limit` (which is 500 for most exchanges) - since only this amount of candles will be available during Dry-Run/Live Trade operations.
+    `startup_candle_count` should be below `ohlcv_candle_limit * 5` (which is 500 * 5 for most exchanges) - since only this amount of candles will be available during Dry-Run/Live Trade operations.
 
 #### Example
 
@@ -281,20 +317,14 @@ class AwesomeStrategy(IStrategy):
 
 Setting a stoploss is highly recommended to protect your capital from strong moves against you.
 
-Sample:
+Sample of setting a 10% stoploss:
 
 ``` python
 stoploss = -0.10
 ```
 
-This would signify a stoploss of -10%.
-
 For the full documentation on stoploss features, look at the dedicated [stoploss page](stoploss.md).
 
-If your exchange supports it, it's recommended to also set `"stoploss_on_exchange"` in the order_types dictionary, so your stoploss is on the exchange and cannot be missed due to network problems, high load or other reasons.
-
-For more information on order_types please look [here](configuration.md#understand-order_types).
-
 ### Timeframe (formerly ticker interval)
 
 This is the set of candles the bot should download and use for the analysis.
@@ -310,7 +340,20 @@ The metadata-dict (available for `populate_buy_trend`, `populate_sell_trend`, `p
 Currently this is `pair`, which can be accessed using `metadata['pair']` - and will return a pair in the format `XRP/BTC`.
 
 The Metadata-dict should not be modified and does not persist information across multiple calls.
-Instead, have a look at the section [Storing information](strategy-advanced.md#Storing-information)
+Instead, have a look at the [Storing information](strategy-advanced.md#Storing-information) section.
+
+## Strategy file loading
+
+By default, freqtrade will attempt to load strategies from all `.py` files within `user_data/strategies`.
+
+Assuming your strategy is called `AwesomeStrategy`, stored in the file `user_data/strategies/AwesomeStrategy.py`, then you can start freqtrade with `freqtrade trade --strategy AwesomeStrategy`.
+Note that we're using the class-name, not the file name.
+
+You can use `freqtrade list-strategies` to see a list of all strategies Freqtrade is able to load (all strategies in the correct folder).
+It will also include a "status" field, highlighting potential problems.
+
+??? Hint "Customize strategy directory"
+    You can use a different directory by using `--strategy-path user_data/otherPath`. This parameter is available to all commands that require a strategy.
 
 ## Informative Pairs
 
@@ -511,9 +554,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.
 
@@ -896,7 +939,8 @@ Sometimes it may be desired to lock a pair after certain events happen (e.g. mul
 Freqtrade has an easy method to do this from within the strategy, by calling `self.lock_pair(pair, until, [reason])`.
 `until` must be a datetime object in the future, after which trading will be re-enabled for that pair, while `reason` is an optional string detailing why the pair was locked.
 
-Locks can also be lifted manually, by calling `self.unlock_pair(pair)`.
+Locks can also be lifted manually, by calling `self.unlock_pair(pair)` or `self.unlock_reason(<reason>)` - providing reason the pair was locked with.
+`self.unlock_reason(<reason>)` will unlock all pairs currently locked with the provided reason.
 
 To verify if a pair is currently locked, use `self.is_pair_locked(pair)`.
 
@@ -966,9 +1010,13 @@ The following lists some common patterns which should be avoided to prevent frus
 - don't use `dataframe['volume'].mean()`. This uses the full DataFrame for backtesting, including data from the future. Use `dataframe['volume'].rolling(<window>).mean()` instead
 - don't use `.resample('1h')`. This uses the left border of the interval, so moves data from an hour to the start of the hour. Use `.resample('1h', label='right')` instead.
 
+### Colliding signals
+
+When buy and sell signals collide (both `'buy'` and `'sell'` are 1), freqtrade will do nothing and ignore the entry (buy) signal. This will avoid trades that buy, and sell immediately. Obviously, this can potentially lead to missed entries.
+
 ## 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.
 

docs/strategy_analysis_example.md

@@ -50,7 +50,9 @@ candles.head()
 ```python
 # Load strategy using values set above
 from freqtrade.resolvers import StrategyResolver
+from freqtrade.data.dataprovider import DataProvider
 strategy = StrategyResolver.load_strategy(config)
+strategy.dp = DataProvider(config, None, None)
 
 # Generate buy/sell signals using strategy
 df = strategy.analyze_ticker(candles, {'pair': pair})
@@ -228,7 +230,7 @@ graph = generate_candlestick_graph(pair=pair,
 # Show graph inline
 # graph.show()
 
-# Render graph in a separate window
+# Render graph in a seperate window
 graph.show(renderer="browser")
 
 ```

docs/telegram-usage.md

@@ -58,6 +58,8 @@ For the Freqtrade configuration, you can then use the the full value (including
 ```json
    "chat_id": "-1001332619709"
 ```
+!!! Warning "Using telegram groups"
+    When using telegram groups, you're giving every member of the telegram group access to your freqtrade bot and to all commands possible via telegram. Please make sure that you can trust everyone in the telegram group to avoid unpleasent surprises.
 
 ## Control telegram noise
 
@@ -175,6 +177,8 @@ official commands. You can ask at any moment for help with `/help`.
 | `/performance` | Show performance of each finished trade grouped by pair
 | `/balance` | Show account balance per currency
 | `/daily <n>` | Shows profit or loss per day, over the last n days (n defaults to 7)
+| `/weekly <n>` | Shows profit or loss per week, over the last n weeks (n defaults to 8)
+| `/monthly <n>` | Shows profit or loss per month, over the last n months (n defaults to 6)
 | `/stats` | Shows Wins / losses by Sell reason as well as Avg. holding durations for buys and sells
 | `/whitelist` | Show the current whitelist
 | `/blacklist [pair]` | Show the current blacklist, or adds a pair to the blacklist.
@@ -307,8 +311,7 @@ Return the balance of all crypto-currency your have on the exchange.
 
 ### /daily <n>
 
-Per default `/daily` will return the 7 last days.
-The example below if for `/daily 3`:
+Per default `/daily` will return the 7 last days. The example below if for `/daily 3`:
 
 > **Daily Profit over the last 3 days:**
 ```
@@ -319,6 +322,34 @@ Day         Profit BTC      Profit USD
 2018-01-01  0.00269130 BTC  34.986 USD
 ```
 
+### /weekly <n>
+
+Per default `/weekly` will return the 8 last weeks, including the current week. Each week starts
+from Monday. The example below if for `/weekly 3`:
+
+> **Weekly Profit over the last 3 weeks (starting from Monday):**
+```
+Monday         Profit BTC      Profit USD
+----------  --------------  ------------
+2018-01-03  0.00224175 BTC  29,142 USD
+2017-12-27  0.00033131 BTC   4,307 USD
+2017-12-20  0.00269130 BTC  34.986 USD
+```
+
+### /monthly <n>
+
+Per default `/monthly` will return the 6 last months, including the current month. The example below
+if for `/monthly 3`:
+
+> **Monthly Profit over the last 3 months:**
+```
+Month         Profit BTC      Profit USD
+----------  --------------  ------------
+2018-01     0.00224175 BTC  29,142 USD
+2017-12     0.00033131 BTC   4,307 USD
+2017-11     0.00269130 BTC  34.986 USD
+```
+
 ### /whitelist
 
 Shows the current whitelist

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.

docs/webhook-config.md

@@ -48,9 +48,9 @@ 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:
+You can set the POST body format to Form-Encoded (default), JSON-Encoded, or raw data. Use `"format": "form"`, `"format": "json"`, or `"format": "raw"` respectively. Example configuration for Mattermost Cloud integration:
 
 ```json
   "webhook": {
@@ -63,7 +63,36 @@ You can set the POST body format to Form-Encoded (default) or JSON-Encoded. Use
     },
 ```
 
-The result would be POST request with e.g. `{"text":"Status: running"}` body and `Content-Type: application/json` header which results `Status: running` message in the Mattermost channel.
+The result would be a POST request with e.g. `{"text":"Status: running"}` body and `Content-Type: application/json` header which results `Status: running` message in the Mattermost channel.
+
+When using the Form-Encoded or JSON-Encoded configuration you can configure any number of payload values, and both the key and value will be ouput in the POST request. However, when using the raw data format you can only configure one value and it **must** be named `"data"`. In this instance the data key will not be output in the POST request, only the value. For example:
+
+```json
+  "webhook": {
+        "enabled": true,
+        "url": "https://<YOURHOOKURL>",
+        "format": "raw",
+        "webhookstatus": {
+            "data": "Status: {status}"
+        }
+    },
+```
+
+The result would be a POST request with e.g. `Status: running` body and `Content-Type: text/plain` header.
+
+Optional parameters are available to enable automatic retries for webhook messages. The `webhook.retries` parameter can be set for the maximum number of retries the webhook request should attempt if it is unsuccessful (i.e. HTTP response status is not 200). By default this is set to `0` which is disabled. An additional `webhook.retry_delay` parameter can be set to specify the time in seconds between retry attempts. By default this is set to `0.1` (i.e. 100ms). Note that increasing the number of retries or retry delay may slow down the trader if there are connectivity issues with the webhook. Example configuration for retries:
+
+```json
+  "webhook": {
+        "enabled": true,
+        "url": "https://<YOURHOOKURL>",
+        "retries": 3,
+        "retry_delay": 0.2,
+        "webhookstatus": {
+            "status": "Status: {status}"
+        }
+    },
+```
 
 Different payloads can be configured for different events. Not all fields are necessary, but you should configure at least one of the dicts, otherwise the webhook will never be called.
 
@@ -75,11 +104,13 @@ Possible parameters are:
 * `trade_id`
 * `exchange`
 * `pair`
-* `limit`
+* ~~`limit` # Deprecated - should no longer be used.~~
+* `open_rate`
 * `amount`
 * `open_date`
 * `stake_amount`
 * `stake_currency`
+* `base_currency`
 * `fiat_currency`
 * `order_type`
 * `current_rate`
@@ -98,6 +129,7 @@ Possible parameters are:
 * `open_date`
 * `stake_amount`
 * `stake_currency`
+* `base_currency`
 * `fiat_currency`
 * `order_type`
 * `current_rate`
@@ -116,7 +148,10 @@ Possible parameters are:
 * `open_date`
 * `stake_amount`
 * `stake_currency`
+* `base_currency`
 * `fiat_currency`
+* `order_type`
+* `current_rate`
 * `buy_tag`
 
 ### Webhooksell
@@ -134,6 +169,7 @@ Possible parameters are:
 * `profit_amount`
 * `profit_ratio`
 * `stake_currency`
+* `base_currency`
 * `fiat_currency`
 * `sell_reason`
 * `order_type`
@@ -156,6 +192,7 @@ Possible parameters are:
 * `profit_amount`
 * `profit_ratio`
 * `stake_currency`
+* `base_currency`
 * `fiat_currency`
 * `sell_reason`
 * `order_type`
@@ -178,6 +215,7 @@ Possible parameters are:
 * `profit_amount`
 * `profit_ratio`
 * `stake_currency`
+* `base_currency`
 * `fiat_currency`
 * `sell_reason`
 * `order_type`

docs/windows_installation.md

@@ -23,9 +23,9 @@ git clone https://github.com/freqtrade/freqtrade.git
 
 Install ta-lib according to the [ta-lib documentation](https://github.com/mrjbq7/ta-lib#windows).
 
-As compiling from source on windows has heavy dependencies (requires a partial visual studio installation), there is also a repository of unofficial pre-compiled windows Wheels [here](https://www.lfd.uci.edu/~gohlke/pythonlibs/#ta-lib), which need to be downloaded and installed using `pip install TA_Lib-0.4.21-cp38-cp38-win_amd64.whl` (make sure to use the version matching your python version).
+As compiling from source on windows has heavy dependencies (requires a partial visual studio installation), there is also a repository of unofficial pre-compiled windows Wheels [here](https://www.lfd.uci.edu/~gohlke/pythonlibs/#ta-lib), which need to be downloaded and installed using `pip install TA_Lib‑0.4.22‑cp38‑cp38‑win_amd64.whl` (make sure to use the version matching your python version).
 
-Freqtrade provides these dependencies for the latest 2 Python versions (3.7 and 3.8) and for 64bit Windows.
+Freqtrade provides these dependencies for the latest 3 Python versions (3.7, 3.8 and 3.9) and for 64bit Windows.
 Other versions must be downloaded from the above link.
 
 ``` powershell

freqtrade/__init__.py

@@ -1,5 +1,5 @@
 """ Freqtrade bot """
-__version__ = '2021.10'
+__version__ = '2021.12'
 
 if __version__ == 'develop':
 

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

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])

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",

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.'

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

freqtrade/configuration/PeriodicCache.py

@@ -1,6 +1,6 @@
 from datetime import datetime, timezone
 
-from cachetools.ttl import TTLCache
+from cachetools import TTLCache
 
 
 class PeriodicCache(TTLCache):

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: {} ...')

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
 
 

freqtrade/constants.py

@@ -25,6 +25,7 @@ ORDERTIF_POSSIBILITIES = ['gtc', 'fok', 'ioc']
 HYPEROPT_LOSS_BUILTIN = ['ShortTradeDurHyperOptLoss', 'OnlyProfitHyperOptLoss',
                          'SharpeHyperOptLoss', 'SharpeHyperOptLossDaily',
                          'SortinoHyperOptLoss', 'SortinoHyperOptLossDaily',
+                         'CalmarHyperOptLoss',
                          'MaxDrawDownHyperOptLoss']
 AVAILABLE_PAIRLISTS = ['StaticPairList', 'VolumePairList',
                        'AgeFilter', 'OffsetFilter', 'PerformanceFilter',
@@ -49,11 +50,12 @@ USERPATH_STRATEGIES = 'strategies'
 USERPATH_NOTEBOOKS = 'notebooks'
 
 TELEGRAM_SETTING_OPTIONS = ['on', 'off', 'silent']
+WEBHOOK_FORMAT_OPTIONS = ['form', 'json', 'raw']
+
 ENV_VAR_PREFIX = 'FREQTRADE__'
 
 NON_OPEN_EXCHANGE_STATES = ('cancelled', 'canceled', 'closed', 'expired')
 
-
 # Define decimals per coin for outputs
 # Only used for outputs.
 DECIMAL_PER_COIN_FALLBACK = 3  # Should be low to avoid listing all possible FIAT's
@@ -67,7 +69,6 @@ DUST_PER_COIN = {
     'ETH': 0.01
 }
 
-
 # Source files with destination directories within user-directory
 USER_DATA_FILES = {
     'sample_strategy.py': USERPATH_STRATEGIES,
@@ -157,6 +158,7 @@ CONF_SCHEMA = {
             'properties': {
                 'buy': {'type': 'number', 'minimum': 1},
                 'sell': {'type': 'number', 'minimum': 1},
+                'exit_timeout_count': {'type': 'number', 'minimum': 0, 'default': 0},
                 'unit': {'type': 'string', 'enum': TIMEOUT_UNITS, 'default': 'minutes'}
             }
         },
@@ -198,7 +200,7 @@ CONF_SCHEMA = {
             'required': ['price_side']
         },
         'custom_price_max_distance_ratio': {
-           'type': 'number', 'minimum': 0.0
+            'type': 'number', 'minimum': 0.0
         },
         'order_types': {
             'type': 'object',
@@ -207,7 +209,10 @@ CONF_SCHEMA = {
                 'sell': {'type': 'string', 'enum': ORDERTYPE_POSSIBILITIES},
                 'forcesell': {'type': 'string', 'enum': ORDERTYPE_POSSIBILITIES},
                 'forcebuy': {'type': 'string', 'enum': ORDERTYPE_POSSIBILITIES},
-                'emergencysell': {'type': 'string', 'enum': ORDERTYPE_POSSIBILITIES},
+                'emergencysell': {
+                    'type': 'string',
+                    'enum': ORDERTYPE_POSSIBILITIES,
+                    'default': 'market'},
                 'stoploss': {'type': 'string', 'enum': ORDERTYPE_POSSIBILITIES},
                 'stoploss_on_exchange': {'type': 'boolean'},
                 'stoploss_on_exchange_interval': {'type': 'number'},
@@ -309,10 +314,16 @@ CONF_SCHEMA = {
             'type': 'object',
             'properties': {
                 'enabled': {'type': 'boolean'},
+                'url': {'type': 'string'},
+                'format': {'type': 'string', 'enum': WEBHOOK_FORMAT_OPTIONS, 'default': 'form'},
+                'retries': {'type': 'integer', 'minimum': 0},
+                'retry_delay': {'type': 'number', 'minimum': 0},
                 'webhookbuy': {'type': 'object'},
                 'webhookbuycancel': {'type': 'object'},
+                'webhookbuyfill': {'type': 'object'},
                 'webhooksell': {'type': 'object'},
                 'webhooksellcancel': {'type': 'object'},
+                'webhooksellfill': {'type': 'object'},
                 'webhookstatus': {'type': 'object'},
             },
         },
@@ -351,13 +362,13 @@ CONF_SCHEMA = {
         },
         'dataformat_ohlcv': {
             'type': 'string',
-                    'enum': AVAILABLE_DATAHANDLERS,
-                    'default': 'json'
+            'enum': AVAILABLE_DATAHANDLERS,
+            'default': 'json'
         },
         'dataformat_trades': {
             'type': 'string',
-                    'enum': AVAILABLE_DATAHANDLERS,
-                    'default': 'jsongz'
+            'enum': AVAILABLE_DATAHANDLERS,
+            'default': 'jsongz'
         }
     },
     'definitions': {
@@ -384,6 +395,7 @@ CONF_SCHEMA = {
                     },
                     'uniqueItems': True
                 },
+                'unknown_fee_rate': {'type': 'number'},
                 'outdated_offset': {'type': 'integer', 'minimum': 1},
                 'markets_refresh_interval': {'type': 'integer'},
                 'ccxt_config': {'type': 'object'},

freqtrade/data/converter.py

@@ -113,7 +113,7 @@ def ohlcv_fill_up_missing_data(dataframe: DataFrame, timeframe: str, pair: str)
     pct_missing = (len_after - len_before) / len_before if len_before > 0 else 0
     if len_before != len_after:
         message = (f"Missing data fillup for {pair}: before: {len_before} - after: {len_after}"
-                   f" - {round(pct_missing * 100, 2)}%")
+                   f" - {pct_missing:.2%}")
         if pct_missing > 0.01:
             logger.info(message)
         else:

freqtrade/data/history/hdf5datahandler.py

@@ -6,7 +6,6 @@ from typing import List, Optional
 import numpy as np
 import pandas as pd
 
-from freqtrade import misc
 from freqtrade.configuration import TimeRange
 from freqtrade.constants import (DEFAULT_DATAFRAME_COLUMNS, DEFAULT_TRADES_COLUMNS,
                                  ListPairsWithTimeframes, TradeList)
@@ -61,10 +60,10 @@ class HDF5DataHandler(IDataHandler):
 
         filename = self._pair_data_filename(self._datadir, pair, timeframe)
 
-        ds = pd.HDFStore(filename, mode='a', complevel=9, complib='blosc')
-        ds.put(key, _data.loc[:, self._columns], format='table', data_columns=['date'])
-
-        ds.close()
+        _data.loc[:, self._columns].to_hdf(
+            filename, key, mode='a', complevel=9, complib='blosc',
+            format='table', data_columns=['date']
+        )
 
     def _ohlcv_load(self, pair: str, timeframe: str,
                     timerange: Optional[TimeRange] = None) -> pd.DataFrame:
@@ -99,19 +98,6 @@ class HDF5DataHandler(IDataHandler):
                                           'low': 'float', 'close': 'float', 'volume': 'float'})
         return pairdata
 
-    def ohlcv_purge(self, pair: str, timeframe: str) -> bool:
-        """
-        Remove data for this pair
-        :param pair: Delete data for this pair.
-        :param timeframe: Timeframe (e.g. "5m")
-        :return: True when deleted, false if file did not exist.
-        """
-        filename = self._pair_data_filename(self._datadir, pair, timeframe)
-        if filename.exists():
-            filename.unlink()
-            return True
-        return False
-
     def ohlcv_append(self, pair: str, timeframe: str, data: pd.DataFrame) -> None:
         """
         Append data to existing data structures
@@ -142,11 +128,11 @@ class HDF5DataHandler(IDataHandler):
         """
         key = self._pair_trades_key(pair)
 
-        ds = pd.HDFStore(self._pair_trades_filename(self._datadir, pair),
-                         mode='a', complevel=9, complib='blosc')
-        ds.put(key, pd.DataFrame(data, columns=DEFAULT_TRADES_COLUMNS),
-               format='table', data_columns=['timestamp'])
-        ds.close()
+        pd.DataFrame(data, columns=DEFAULT_TRADES_COLUMNS).to_hdf(
+            self._pair_trades_filename(self._datadir, pair), key,
+            mode='a', complevel=9, complib='blosc',
+            format='table', data_columns=['timestamp']
+        )
 
     def trades_append(self, pair: str, data: TradeList):
         """
@@ -180,17 +166,9 @@ class HDF5DataHandler(IDataHandler):
         trades[['id', 'type']] = trades[['id', 'type']].replace({np.nan: None})
         return trades.values.tolist()
 
-    def trades_purge(self, pair: str) -> bool:
-        """
-        Remove data for this pair
-        :param pair: Delete data for this pair.
-        :return: True when deleted, false if file did not exist.
-        """
-        filename = self._pair_trades_filename(self._datadir, pair)
-        if filename.exists():
-            filename.unlink()
-            return True
-        return False
+    @classmethod
+    def _get_file_extension(cls):
+        return "h5"
 
     @classmethod
     def _pair_ohlcv_key(cls, pair: str, timeframe: str) -> str:
@@ -199,15 +177,3 @@ class HDF5DataHandler(IDataHandler):
     @classmethod
     def _pair_trades_key(cls, pair: str) -> str:
         return f"{pair}/trades"
-
-    @classmethod
-    def _pair_data_filename(cls, datadir: Path, pair: str, timeframe: str) -> Path:
-        pair_s = misc.pair_to_filename(pair)
-        filename = datadir.joinpath(f'{pair_s}-{timeframe}.h5')
-        return filename
-
-    @classmethod
-    def _pair_trades_filename(cls, datadir: Path, pair: str) -> Path:
-        pair_s = misc.pair_to_filename(pair)
-        filename = datadir.joinpath(f'{pair_s}-trades.h5')
-        return filename

freqtrade/data/history/idatahandler.py

@@ -12,6 +12,7 @@ from typing import List, Optional, Type
 
 from pandas import DataFrame
 
+from freqtrade import misc
 from freqtrade.configuration import TimeRange
 from freqtrade.constants import ListPairsWithTimeframes, TradeList
 from freqtrade.data.converter import clean_ohlcv_dataframe, trades_remove_duplicates, trim_dataframe
@@ -26,6 +27,13 @@ class IDataHandler(ABC):
     def __init__(self, datadir: Path) -> None:
         self._datadir = datadir
 
+    @classmethod
+    def _get_file_extension(cls) -> str:
+        """
+        Get file extension for this particular datahandler
+        """
+        raise NotImplementedError()
+
     @abstractclassmethod
     def ohlcv_get_available_data(cls, datadir: Path) -> ListPairsWithTimeframes:
         """
@@ -70,7 +78,6 @@ class IDataHandler(ABC):
         :return: DataFrame with ohlcv data, or empty DataFrame
         """
 
-    @abstractmethod
     def ohlcv_purge(self, pair: str, timeframe: str) -> bool:
         """
         Remove data for this pair
@@ -78,6 +85,11 @@ class IDataHandler(ABC):
         :param timeframe: Timeframe (e.g. "5m")
         :return: True when deleted, false if file did not exist.
         """
+        filename = self._pair_data_filename(self._datadir, pair, timeframe)
+        if filename.exists():
+            filename.unlink()
+            return True
+        return False
 
     @abstractmethod
     def ohlcv_append(self, pair: str, timeframe: str, data: DataFrame) -> None:
@@ -123,13 +135,17 @@ class IDataHandler(ABC):
         :return: List of trades
         """
 
-    @abstractmethod
     def trades_purge(self, pair: str) -> bool:
         """
         Remove data for this pair
         :param pair: Delete data for this pair.
         :return: True when deleted, false if file did not exist.
         """
+        filename = self._pair_trades_filename(self._datadir, pair)
+        if filename.exists():
+            filename.unlink()
+            return True
+        return False
 
     def trades_load(self, pair: str, timerange: Optional[TimeRange] = None) -> TradeList:
         """
@@ -141,6 +157,18 @@ class IDataHandler(ABC):
         """
         return trades_remove_duplicates(self._trades_load(pair, timerange=timerange))
 
+    @classmethod
+    def _pair_data_filename(cls, datadir: Path, pair: str, timeframe: str) -> Path:
+        pair_s = misc.pair_to_filename(pair)
+        filename = datadir.joinpath(f'{pair_s}-{timeframe}.{cls._get_file_extension()}')
+        return filename
+
+    @classmethod
+    def _pair_trades_filename(cls, datadir: Path, pair: str) -> Path:
+        pair_s = misc.pair_to_filename(pair)
+        filename = datadir.joinpath(f'{pair_s}-trades.{cls._get_file_extension()}')
+        return filename
+
     def ohlcv_load(self, pair, timeframe: str,
                    timerange: Optional[TimeRange] = None,
                    fill_missing: bool = True,

freqtrade/data/history/jsondatahandler.py

@@ -174,34 +174,10 @@ class JsonDataHandler(IDataHandler):
             pass
         return tradesdata
 
-    def trades_purge(self, pair: str) -> bool:
-        """
-        Remove data for this pair
-        :param pair: Delete data for this pair.
-        :return: True when deleted, false if file did not exist.
-        """
-        filename = self._pair_trades_filename(self._datadir, pair)
-        if filename.exists():
-            filename.unlink()
-            return True
-        return False
-
-    @classmethod
-    def _pair_data_filename(cls, datadir: Path, pair: str, timeframe: str) -> Path:
-        pair_s = misc.pair_to_filename(pair)
-        filename = datadir.joinpath(f'{pair_s}-{timeframe}.{cls._get_file_extension()}')
-        return filename
-
     @classmethod
     def _get_file_extension(cls):
         return "json.gz" if cls._use_zip else "json"
 
-    @classmethod
-    def _pair_trades_filename(cls, datadir: Path, pair: str) -> Path:
-        pair_s = misc.pair_to_filename(pair)
-        filename = datadir.joinpath(f'{pair_s}-trades.{cls._get_file_extension()}')
-        return filename
-
 
 class JsonGzDataHandler(JsonDataHandler):
 

freqtrade/enums/__init__.py

@@ -1,5 +1,6 @@
 # flake8: noqa: F401
 from freqtrade.enums.backteststate import BacktestState
+from freqtrade.enums.ordertypevalue import OrderTypeValues
 from freqtrade.enums.rpcmessagetype import RPCMessageType
 from freqtrade.enums.runmode import NON_UTIL_MODES, OPTIMIZE_MODES, TRADING_MODES, RunMode
 from freqtrade.enums.selltype import SellType

freqtrade/enums/ordertypevalue.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class OrderTypeValues(str, Enum):
+    limit = 'limit'
+    market = 'market'

freqtrade/enums/signaltype.py

@@ -14,3 +14,4 @@ class SignalTagType(Enum):
     Enum for signal columns
     """
     BUY_TAG = "buy_tag"
+    EXIT_TAG = "exit_tag"

freqtrade/exceptions.py

@@ -1,5 +1,3 @@
-
-
 class FreqtradeException(Exception):
     """
     Freqtrade base exception. Handled at the outermost level.

freqtrade/exchange/__init__.py

@@ -5,6 +5,7 @@ from freqtrade.exchange.exchange import Exchange
 # isort: on
 from freqtrade.exchange.bibox import Bibox
 from freqtrade.exchange.binance import Binance
+from freqtrade.exchange.bitpanda import Bitpanda
 from freqtrade.exchange.bittrex import Bittrex
 from freqtrade.exchange.bybit import Bybit
 from freqtrade.exchange.coinbasepro import Coinbasepro
@@ -19,3 +20,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

freqtrade/exchange/binance.py

@@ -1,6 +1,6 @@
 """ Binance exchange subclass """
 import logging
-from typing import Dict, List
+from typing import Dict, List, Tuple
 
 import arrow
 import ccxt
@@ -93,8 +93,9 @@ class Binance(Exchange):
             raise OperationalException(e) from e
 
     async def _async_get_historic_ohlcv(self, pair: str, timeframe: str,
-                                        since_ms: int, is_new_pair: bool
-                                        ) -> List:
+                                        since_ms: int, is_new_pair: bool = False,
+                                        raise_: bool = False
+                                        ) -> Tuple[str, str, List]:
         """
         Overwrite to introduce "fast new pair" functionality by detecting the pair's listing date
         Does not work for other exchanges, which don't return the earliest data when called with "0"
@@ -107,4 +108,5 @@ class Binance(Exchange):
                 logger.info(f"Candle-data for {pair} available starting with "
                             f"{arrow.get(since_ms // 1000).isoformat()}.")
         return await super()._async_get_historic_ohlcv(
-            pair=pair, timeframe=timeframe, since_ms=since_ms, is_new_pair=is_new_pair)
+            pair=pair, timeframe=timeframe, since_ms=since_ms, is_new_pair=is_new_pair,
+            raise_=raise_)

freqtrade/exchange/bitpanda.py

@@ -0,0 +1,37 @@
+""" Bitpanda exchange subclass """
+import logging
+from datetime import datetime, timezone
+from typing import Dict, List, Optional
+
+from freqtrade.exchange import Exchange
+
+
+logger = logging.getLogger(__name__)
+
+
+class Bitpanda(Exchange):
+    """
+    Bitpanda exchange class. Contains adjustments needed for Freqtrade to work
+    with this exchange.
+    """
+
+    def get_trades_for_order(self, order_id: str, pair: str, since: datetime,
+                             params: Optional[Dict] = None) -> List:
+        """
+        Fetch Orders using the "fetch_my_trades" endpoint and filter them by order-id.
+        The "since" argument passed in is coming from the database and is in UTC,
+        as timezone-native datetime object.
+        From the python documentation:
+            > Naive datetime instances are assumed to represent local time
+        Therefore, calling "since.timestamp()" will get the UTC timestamp, after applying the
+        transformation from local timezone to UTC.
+        This works for timezones UTC+ since then the result will contain trades from a few hours
+        instead of from the last 5 seconds, however fails for UTC- timezones,
+        since we're then asking for trades with a "since" argument in the future.
+
+        :param order_id order_id: Order-id as given when creating the order
+        :param pair: Pair the order is for
+        :param since: datetime object of the order creation time. Assumes object is in UTC.
+        """
+        params = {'to': int(datetime.now(timezone.utc).timestamp() * 1000)}
+        return super().get_trades_for_order(order_id, pair, since, params)

freqtrade/exchange/common.py

@@ -81,9 +81,16 @@ def retrier_async(f):
                 count -= 1
                 kwargs.update({'count': count})
                 if isinstance(ex, DDosProtection):
-                    backoff_delay = calculate_backoff(count + 1, API_RETRY_COUNT)
-                    logger.info(f"Applying DDosProtection backoff delay: {backoff_delay}")
-                    await asyncio.sleep(backoff_delay)
+                    if "kucoin" in str(ex) and "429000" in str(ex):
+                        # Temporary fix for 429000 error on kucoin
+                        # see https://github.com/freqtrade/freqtrade/issues/5700 for details.
+                        logger.warning(
+                            f"Kucoin 429 error, avoid triggering DDosProtection backoff delay. "
+                            f"{count} tries left before giving up")
+                    else:
+                        backoff_delay = calculate_backoff(count + 1, API_RETRY_COUNT)
+                        logger.info(f"Applying DDosProtection backoff delay: {backoff_delay}")
+                        await asyncio.sleep(backoff_delay)
                 return await wrapper(*args, **kwargs)
             else:
                 logger.warning('Giving up retrying: %s()', f.__name__)

freqtrade/exchange/exchange.py

@@ -7,7 +7,7 @@ import http
 import inspect
 import logging
 from copy import deepcopy
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from math import ceil
 from typing import Any, Dict, List, Optional, Tuple
 
@@ -155,8 +155,8 @@ class Exchange:
                 self.validate_pairs(config['exchange']['pair_whitelist'])
             self.validate_ordertypes(config.get('order_types', {}))
             self.validate_order_time_in_force(config.get('order_time_in_force', {}))
-            self.validate_required_startup_candles(config.get('startup_candle_count', 0),
-                                                   config.get('timeframe', ''))
+            self.required_candle_call_count = self.validate_required_startup_candles(
+                config.get('startup_candle_count', 0), config.get('timeframe', ''))
 
         # Converts the interval provided in minutes in config to seconds
         self.markets_refresh_interval: int = exchange_config.get(
@@ -471,16 +471,29 @@ class Exchange:
             raise OperationalException(
                 f'Time in force policies are not supported for {self.name} yet.')
 
-    def validate_required_startup_candles(self, startup_candles: int, timeframe: str) -> None:
+    def validate_required_startup_candles(self, startup_candles: int, timeframe: str) -> int:
         """
         Checks if required startup_candles is more than ohlcv_candle_limit().
         Requires a grace-period of 5 candles - so a startup-period up to 494 is allowed by default.
         """
         candle_limit = self.ohlcv_candle_limit(timeframe)
-        if startup_candles + 5 > candle_limit:
+        # Require one more candle - to account for the still open candle.
+        candle_count = startup_candles + 1
+        # Allow 5 calls to the exchange per pair
+        required_candle_call_count = int(
+            (candle_count / candle_limit) + (0 if candle_count % candle_limit == 0 else 1))
+
+        if required_candle_call_count > 5:
+            # Only allow 5 calls per pair to somewhat limit the impact
             raise OperationalException(
-                f"This strategy requires {startup_candles} candles to start. "
-                f"{self.name} only provides {candle_limit - 5} for {timeframe}.")
+                f"This strategy requires {startup_candles} candles to start, which is more than 5x "
+                f"the amount of candles {self.name} provides for {timeframe}.")
+
+        if required_candle_call_count > 1:
+            logger.warning(f"Using {required_candle_call_count} calls to get OHLCV. "
+                           f"This can result in slower operations for the bot. Please check "
+                           f"if you really need {startup_candles} candles for your strategy")
+        return required_candle_call_count
 
     def exchange_has(self, endpoint: str) -> bool:
         """
@@ -672,16 +685,20 @@ class Exchange:
         if not self.exchange_has('fetchL2OrderBook'):
             return True
         ob = self.fetch_l2_order_book(pair, 1)
-        if side == 'buy':
-            price = ob['asks'][0][0]
-            logger.debug(f"{pair} checking dry buy-order: price={price}, limit={limit}")
-            if limit >= price:
-                return True
-        else:
-            price = ob['bids'][0][0]
-            logger.debug(f"{pair} checking dry sell-order: price={price}, limit={limit}")
-            if limit <= price:
-                return True
+        try:
+            if side == 'buy':
+                price = ob['asks'][0][0]
+                logger.debug(f"{pair} checking dry buy-order: price={price}, limit={limit}")
+                if limit >= price:
+                    return True
+            else:
+                price = ob['bids'][0][0]
+                logger.debug(f"{pair} checking dry sell-order: price={price}, limit={limit}")
+                if limit <= price:
+                    return True
+        except IndexError:
+            # Ignore empty orderbooks when filling - can be filled with the next iteration.
+            pass
         return False
 
     def check_dry_limit_order_filled(self, order: Dict[str, Any]) -> Dict[str, Any]:
@@ -1074,7 +1091,8 @@ class Exchange:
     # Fee handling
 
     @retrier
-    def get_trades_for_order(self, order_id: str, pair: str, since: datetime) -> List:
+    def get_trades_for_order(self, order_id: str, pair: str, since: datetime,
+                             params: Optional[Dict] = None) -> List:
         """
         Fetch Orders using the "fetch_my_trades" endpoint and filter them by order-id.
         The "since" argument passed in is coming from the database and is in UTC,
@@ -1098,8 +1116,10 @@ class Exchange:
         try:
             # Allow 5s offset to catch slight time offsets (discovered in #1185)
             # since needs to be int in milliseconds
+            _params = params if params else {}
             my_trades = self._api.fetch_my_trades(
-                pair, int((since.replace(tzinfo=timezone.utc).timestamp() - 5) * 1000))
+                pair, int((since.replace(tzinfo=timezone.utc).timestamp() - 5) * 1000),
+                params=_params)
             matched_trades = [trade for trade in my_trades if trade['order'] == order_id]
 
             self._log_exchange_response('get_trades_for_order', matched_trades)
@@ -1177,9 +1197,11 @@ class Exchange:
                 tick = self.fetch_ticker(comb)
 
                 fee_to_quote_rate = safe_value_fallback2(tick, tick, 'last', 'ask')
-                return round((order['fee']['cost'] * fee_to_quote_rate) / order['cost'], 8)
             except ExchangeError:
-                return None
+                fee_to_quote_rate = self._config['exchange'].get('unknown_fee_rate', None)
+                if not fee_to_quote_rate:
+                    return None
+            return round((order['fee']['cost'] * fee_to_quote_rate) / order['cost'], 8)
 
     def extract_cost_curr_rate(self, order: Dict) -> Tuple[float, str, Optional[float]]:
         """
@@ -1205,9 +1227,11 @@ class Exchange:
         :param since_ms: Timestamp in milliseconds to get history from
         :return: List with candle (OHLCV) data
         """
-        return asyncio.get_event_loop().run_until_complete(
+        pair, timeframe, data = asyncio.get_event_loop().run_until_complete(
             self._async_get_historic_ohlcv(pair=pair, timeframe=timeframe,
                                            since_ms=since_ms, is_new_pair=is_new_pair))
+        logger.info(f"Downloaded data for {pair} with length {len(data)}.")
+        return data
 
     def get_historic_ohlcv_as_df(self, pair: str, timeframe: str,
                                  since_ms: int) -> DataFrame:
@@ -1223,8 +1247,9 @@ class Exchange:
                                   drop_incomplete=self._ohlcv_partial_candle)
 
     async def _async_get_historic_ohlcv(self, pair: str, timeframe: str,
-                                        since_ms: int, is_new_pair: bool
-                                        ) -> List:
+                                        since_ms: int, is_new_pair: bool = False,
+                                        raise_: bool = False
+                                        ) -> Tuple[str, str, List]:
         """
         Download historic ohlcv
         :param is_new_pair: used by binance subclass to allow "fast" new pair downloading
@@ -1247,16 +1272,18 @@ class Exchange:
             results = await asyncio.gather(*input_coro, return_exceptions=True)
             for res in results:
                 if isinstance(res, Exception):
-                    logger.warning("Async code raised an exception: %s", res.__class__.__name__)
+                    logger.warning(f"Async code raised an exception: {repr(res)}")
+                    if raise_:
+                        raise
                     continue
-                # Deconstruct tuple if it's not an exception
-                p, _, new_data = res
-                if p == pair:
-                    data.extend(new_data)
+                else:
+                    # Deconstruct tuple if it's not an exception
+                    p, _, new_data = res
+                    if p == pair:
+                        data.extend(new_data)
         # Sort data again after extending the result - above calls return in "async order"
         data = sorted(data, key=lambda x: x[0])
-        logger.info(f"Downloaded data for {pair} with length {len(data)}.")
-        return data
+        return pair, timeframe, data
 
     def refresh_latest_ohlcv(self, pair_list: ListPairsWithTimeframes, *,
                              since_ms: Optional[int] = None, cache: bool = True
@@ -1276,10 +1303,22 @@ class Exchange:
         cached_pairs = []
         # Gather coroutines to run
         for pair, timeframe in set(pair_list):
-            if (((pair, timeframe) not in self._klines)
+            if ((pair, timeframe) not in self._klines or not cache
                     or self._now_is_time_to_refresh(pair, timeframe)):
-                input_coroutines.append(self._async_get_candle_history(pair, timeframe,
-                                                                       since_ms=since_ms))
+                if not since_ms and self.required_candle_call_count > 1:
+                    # Multiple calls for one pair - to get more history
+                    one_call = timeframe_to_msecs(timeframe) * self.ohlcv_candle_limit(timeframe)
+                    move_to = one_call * self.required_candle_call_count
+                    now = timeframe_to_next_date(timeframe)
+                    since_ms = int((now - timedelta(seconds=move_to // 1000)).timestamp() * 1000)
+
+                if since_ms:
+                    input_coroutines.append(self._async_get_historic_ohlcv(
+                        pair, timeframe, since_ms=since_ms, raise_=True))
+                else:
+                    # One call ... "regular" refresh
+                    input_coroutines.append(self._async_get_candle_history(
+                        pair, timeframe, since_ms=since_ms))
             else:
                 logger.debug(
                     "Using cached candle (OHLCV) data for pair %s, timeframe %s ...",
@@ -1287,27 +1326,30 @@ class Exchange:
                 )
                 cached_pairs.append((pair, timeframe))
 
-        results = asyncio.get_event_loop().run_until_complete(
-            asyncio.gather(*input_coroutines, return_exceptions=True))
-
         results_df = {}
-        # handle caching
-        for res in results:
-            if isinstance(res, Exception):
-                logger.warning("Async code raised an exception: %s", res.__class__.__name__)
-                continue
-            # Deconstruct tuple (has 3 elements)
-            pair, timeframe, ticks = res
-            # keeping last candle time as last refreshed time of the pair
-            if ticks:
-                self._pairs_last_refresh_time[(pair, timeframe)] = ticks[-1][0] // 1000
-            # keeping parsed dataframe in cache
-            ohlcv_df = ohlcv_to_dataframe(
-                ticks, timeframe, pair=pair, fill_missing=True,
-                drop_incomplete=self._ohlcv_partial_candle)
-            results_df[(pair, timeframe)] = ohlcv_df
-            if cache:
-                self._klines[(pair, timeframe)] = ohlcv_df
+        # Chunk requests into batches of 100 to avoid overwelming ccxt Throttling
+        for input_coro in chunks(input_coroutines, 100):
+            results = asyncio.get_event_loop().run_until_complete(
+                asyncio.gather(*input_coro, return_exceptions=True))
+
+            # handle caching
+            for res in results:
+                if isinstance(res, Exception):
+                    logger.warning(f"Async code raised an exception: {repr(res)}")
+                    continue
+                # Deconstruct tuple (has 3 elements)
+                pair, timeframe, ticks = res
+                # keeping last candle time as last refreshed time of the pair
+                if ticks:
+                    self._pairs_last_refresh_time[(pair, timeframe)] = ticks[-1][0] // 1000
+                # keeping parsed dataframe in cache
+                ohlcv_df = ohlcv_to_dataframe(
+                    ticks, timeframe, pair=pair, fill_missing=True,
+                    drop_incomplete=self._ohlcv_partial_candle)
+                results_df[(pair, timeframe)] = ohlcv_df
+                if cache:
+                    self._klines[(pair, timeframe)] = ohlcv_df
+
         # Return cached klines
         for pair, timeframe in cached_pairs:
             results_df[(pair, timeframe)] = self.klines((pair, timeframe), copy=False)
@@ -1534,7 +1576,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]:

freqtrade/exchange/kucoin.py

@@ -1,4 +1,4 @@
-""" Kucoin exchange subclass """
+"""Kucoin exchange subclass."""
 import logging
 from typing import Dict
 
@@ -9,9 +9,9 @@ logger = logging.getLogger(__name__)
 
 
 class Kucoin(Exchange):
-    """
-    Kucoin exchange class. Contains adjustments needed for Freqtrade to work
-    with this exchange.
+    """Kucoin exchange class.
+
+    Contains adjustments needed for Freqtrade to work with this exchange.
 
     Please note that this exchange is not included in the list of exchanges
     officially supported by the Freqtrade development team. So some features

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,
+    }

freqtrade/freqtradebot.py

@@ -193,19 +193,20 @@ class FreqtradeBot(LoggingMixin):
 
     def check_for_open_trades(self):
         """
-        Notify the user when the bot is stopped
+        Notify the user when the bot is stopped (not reloaded)
         and there are still open trades active.
         """
         open_trades = Trade.get_trades([Trade.is_open.is_(True)]).all()
 
-        if len(open_trades) != 0:
+        if len(open_trades) != 0 and self.state != State.RELOAD_CONFIG:
             msg = {
                 'type': RPCMessageType.WARNING,
-                'status':  f"{len(open_trades)} open trades active.\n\n"
-                           f"Handle these trades manually on {self.exchange.name}, "
-                           f"or '/start' the bot again and use '/stopbuy' "
-                           f"to handle open trades gracefully. \n"
-                           f"{'Trades are simulated.' if self.config['dry_run'] else ''}",
+                'status':
+                    f"{len(open_trades)} open trades active.\n\n"
+                    f"Handle these trades manually on {self.exchange.name}, "
+                    f"or '/start' the bot again and use '/stopbuy' "
+                    f"to handle open trades gracefully. \n"
+                    f"{'Note: Trades are simulated (dry run).' if self.config['dry_run'] else ''}",
             }
             self.rpc.send_msg(msg)
 
@@ -277,7 +278,8 @@ class FreqtradeBot(LoggingMixin):
                 if order:
                     logger.info(f"Updating sell-fee on trade {trade} for order {order.order_id}.")
                     self.update_trade_state(trade, order.order_id,
-                                            stoploss_order=order.ft_order_side == 'stoploss')
+                                            stoploss_order=order.ft_order_side == 'stoploss',
+                                            send_msg=False)
 
         trades: List[Trade] = Trade.get_open_trades_without_assigned_fees()
         for trade in trades:
@@ -285,7 +287,7 @@ class FreqtradeBot(LoggingMixin):
                 order = trade.select_order('buy', False)
                 if order:
                     logger.info(f"Updating buy-fee on trade {trade} for order {order.order_id}.")
-                    self.update_trade_state(trade, order.order_id)
+                    self.update_trade_state(trade, order.order_id, send_msg=False)
 
     def handle_insufficient_funds(self, trade: Trade):
         """
@@ -307,7 +309,7 @@ class FreqtradeBot(LoggingMixin):
         order = trade.select_order('buy', False)
         if order:
             logger.info(f"Updating buy-fee on trade {trade} for order {order.order_id}.")
-            self.update_trade_state(trade, order.order_id)
+            self.update_trade_state(trade, order.order_id, send_msg=False)
 
     def refind_lost_order(self, trade):
         """
@@ -420,7 +422,7 @@ class FreqtradeBot(LoggingMixin):
             return False
 
         # running get_signal on historical data fetched
-        (buy, sell, buy_tag) = self.strategy.get_signal(
+        (buy, sell, buy_tag, _) = self.strategy.get_signal(
             pair,
             self.strategy.timeframe,
             analyzed_df
@@ -465,8 +467,8 @@ class FreqtradeBot(LoggingMixin):
             logger.info(f"Bids to asks delta for {pair} does not satisfy condition.")
             return False
 
-    def execute_entry(self, pair: str, stake_amount: float, price: Optional[float] = None,
-                      forcebuy: bool = False, buy_tag: Optional[str] = None) -> bool:
+    def execute_entry(self, pair: str, stake_amount: float, price: Optional[float] = None, *,
+                      ordertype: Optional[str] = None, buy_tag: Optional[str] = None) -> bool:
         """
         Executes a limit buy for the given pair
         :param pair: pair for which we want to create a LIMIT_BUY
@@ -500,7 +502,7 @@ class FreqtradeBot(LoggingMixin):
                 pair=pair, current_time=datetime.now(timezone.utc),
                 current_rate=enter_limit_requested, proposed_stake=stake_amount,
                 min_stake=min_stake_amount, max_stake=max_stake_amount)
-        stake_amount = self.wallets._validate_stake_amount(pair, stake_amount, min_stake_amount)
+        stake_amount = self.wallets.validate_stake_amount(pair, stake_amount, min_stake_amount)
 
         if not stake_amount:
             return False
@@ -509,10 +511,7 @@ class FreqtradeBot(LoggingMixin):
                     f"{stake_amount} ...")
 
         amount = stake_amount / enter_limit_requested
-        order_type = self.strategy.order_types['buy']
-        if forcebuy:
-            # Forcebuy can define a different ordertype
-            order_type = self.strategy.order_types.get('forcebuy', order_type)
+        order_type = ordertype or self.strategy.order_types['buy']
 
         if not strategy_safe_wrapper(self.strategy.confirm_trade_entry, default_retval=True)(
                 pair=pair, order_type=order_type, amount=amount, rate=enter_limit_requested,
@@ -580,10 +579,6 @@ class FreqtradeBot(LoggingMixin):
         )
         trade.orders.append(order_obj)
 
-        # Update fees if order is closed
-        if order_status == 'closed':
-            self.update_trade_state(trade, order_id, order)
-
         Trade.query.session.add(trade)
         Trade.commit()
 
@@ -592,19 +587,25 @@ class FreqtradeBot(LoggingMixin):
 
         self._notify_enter(trade, order_type)
 
+        # Update fees if order is closed
+        if order_status == 'closed':
+            self.update_trade_state(trade, order_id, order)
+
         return True
 
-    def _notify_enter(self, trade: Trade, order_type: str) -> None:
+    def _notify_enter(self, trade: Trade, order_type: Optional[str] = None,
+                      fill: bool = False) -> None:
         """
         Sends rpc notification when a buy occurred.
         """
         msg = {
             'trade_id': trade.id,
-            'type': RPCMessageType.BUY,
+            'type': RPCMessageType.BUY_FILL if fill else RPCMessageType.BUY,
             'buy_tag': trade.buy_tag,
             'exchange': self.exchange.name.capitalize(),
             'pair': trade.pair,
-            'limit': trade.open_rate,
+            'limit': trade.open_rate,  # Deprecated (?)
+            'open_rate': trade.open_rate,
             'order_type': order_type,
             'stake_amount': trade.stake_amount,
             'stake_currency': self.config['stake_currency'],
@@ -643,22 +644,6 @@ class FreqtradeBot(LoggingMixin):
         # Send the message
         self.rpc.send_msg(msg)
 
-    def _notify_enter_fill(self, trade: Trade) -> None:
-        msg = {
-            'trade_id': trade.id,
-            'type': RPCMessageType.BUY_FILL,
-            'buy_tag': trade.buy_tag,
-            'exchange': self.exchange.name.capitalize(),
-            'pair': trade.pair,
-            'open_rate': trade.open_rate,
-            'stake_amount': trade.stake_amount,
-            'stake_currency': self.config['stake_currency'],
-            'fiat_currency': self.config.get('fiat_display_currency', None),
-            'amount': trade.amount,
-            'open_date': trade.open_date,
-        }
-        self.rpc.send_msg(msg)
-
 #
 # SELL / exit positions / close trades logic and methods
 #
@@ -681,7 +666,7 @@ class FreqtradeBot(LoggingMixin):
                     trades_closed += 1
 
             except DependencyException as exception:
-                logger.warning('Unable to sell trade %s: %s', trade.pair, exception)
+                logger.warning(f'Unable to sell trade {trade.pair}: {exception}')
 
         # Updating wallets if any trade occurred
         if trades_closed:
@@ -700,21 +685,22 @@ class FreqtradeBot(LoggingMixin):
         logger.debug('Handling %s ...', trade)
 
         (buy, sell) = (False, False)
+        exit_tag = None
 
         if (self.config.get('use_sell_signal', True) or
                 self.config.get('ignore_roi_if_buy_signal', False)):
             analyzed_df, _ = self.dataprovider.get_analyzed_dataframe(trade.pair,
                                                                       self.strategy.timeframe)
 
-            (buy, sell, _) = self.strategy.get_signal(
+            (buy, sell, _, exit_tag) = self.strategy.get_signal(
                 trade.pair,
                 self.strategy.timeframe,
                 analyzed_df
             )
 
         logger.debug('checking sell')
-        exit_rate = self.exchange.get_rate(trade.pair, refresh=True, side="sell")
-        if self._check_and_execute_exit(trade, exit_rate, buy, sell):
+        sell_rate = self.exchange.get_rate(trade.pair, refresh=True, side="sell")
+        if self._check_and_execute_exit(trade, sell_rate, buy, sell, exit_tag):
             return True
 
         logger.debug('Found no sell signal for %s.', trade)
@@ -852,18 +838,21 @@ class FreqtradeBot(LoggingMixin):
                                    f"for pair {trade.pair}.")
 
     def _check_and_execute_exit(self, trade: Trade, exit_rate: float,
-                                buy: bool, sell: bool) -> bool:
+                                buy: bool, sell: bool, exit_tag: Optional[str]) -> bool:
         """
         Check and execute exit
         """
+
         should_sell = self.strategy.should_sell(
             trade, exit_rate, datetime.now(timezone.utc), buy, sell,
             force_stoploss=self.edge.stoploss(trade.pair) if self.edge else 0
         )
 
         if should_sell.sell_flag:
-            logger.info(f'Executing Sell for {trade.pair}. Reason: {should_sell.sell_type}')
-            self.execute_trade_exit(trade, exit_rate, should_sell)
+            logger.info(
+                f'Executing Sell for {trade.pair}. Reason: {should_sell.sell_type}. '
+                f'Tag: {exit_tag if exit_tag is not None else "None"}')
+            self.execute_trade_exit(trade, exit_rate, should_sell, exit_tag=exit_tag)
             return True
         return False
 
@@ -916,6 +905,17 @@ class FreqtradeBot(LoggingMixin):
                                                                  trade=trade,
                                                                  order=order))):
                 self.handle_cancel_exit(trade, order, constants.CANCEL_REASON['TIMEOUT'])
+                canceled_count = trade.get_exit_order_count()
+                max_timeouts = self.config.get('unfilledtimeout', {}).get('exit_timeout_count', 0)
+                if max_timeouts > 0 and canceled_count >= max_timeouts:
+                    logger.warning(f'Emergencyselling trade {trade}, as the sell order '
+                                   f'timed out {max_timeouts} times.')
+                    try:
+                        self.execute_trade_exit(
+                            trade, order.get('price'),
+                            sell_reason=SellCheckTuple(sell_type=SellType.EMERGENCY_SELL))
+                    except DependencyException as exception:
+                        logger.warning(f'Unable to emergency sell trade {trade.pair}: {exception}')
 
     def cancel_all_open_orders(self) -> None:
         """
@@ -1064,7 +1064,15 @@ class FreqtradeBot(LoggingMixin):
             raise DependencyException(
                 f"Not enough amount to sell. Trade-amount: {amount}, Wallet: {wallet_amount}")
 
-    def execute_trade_exit(self, trade: Trade, limit: float, sell_reason: SellCheckTuple) -> bool:
+    def execute_trade_exit(
+            self,
+            trade: Trade,
+            limit: float,
+            sell_reason: SellCheckTuple,
+            *,
+            exit_tag: Optional[str] = None,
+            ordertype: Optional[str] = None,
+            ) -> bool:
         """
         Executes a trade exit for the given trade and limit
         :param trade: Trade instance
@@ -1102,14 +1110,10 @@ class FreqtradeBot(LoggingMixin):
             except InvalidOrderException:
                 logger.exception(f"Could not cancel stoploss order {trade.stoploss_order_id}")
 
-        order_type = self.strategy.order_types[sell_type]
+        order_type = ordertype or self.strategy.order_types[sell_type]
         if sell_reason.sell_type == SellType.EMERGENCY_SELL:
             # Emergency sells (default to market!)
             order_type = self.strategy.order_types.get("emergencysell", "market")
-        if sell_reason.sell_type == SellType.FORCE_SELL:
-            # Force sells (default to the sell_type defined in the strategy,
-            # but we allow this value to be changed)
-            order_type = self.strategy.order_types.get("forcesell", order_type)
 
         amount = self._safe_exit_amount(trade.pair, trade.amount)
         time_in_force = self.strategy.order_time_in_force['sell']
@@ -1140,17 +1144,17 @@ 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
-        # 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)
-        Trade.commit()
+        trade.sell_reason = exit_tag or sell_reason.sell_reason
 
         # Lock pair for one candle to prevent immediate re-buys
         self.strategy.lock_pair(trade.pair, datetime.now(timezone.utc),
                                 reason='Auto lock')
 
         self._notify_exit(trade, order_type)
+        # 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)
+        Trade.commit()
 
         return True
 
@@ -1181,6 +1185,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(),
@@ -1224,6 +1229,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),
@@ -1245,13 +1251,14 @@ class FreqtradeBot(LoggingMixin):
 #
 
     def update_trade_state(self, trade: Trade, order_id: str, action_order: Dict[str, Any] = None,
-                           stoploss_order: bool = False) -> bool:
+                           stoploss_order: bool = False, send_msg: bool = True) -> bool:
         """
         Checks trades with open orders and updates the amount if necessary
         Handles closing both buy and sell orders.
         :param trade: Trade object of the trade we're analyzing
         :param order_id: Order-id of the order we're analyzing
         :param action_order: Already acquired order object
+        :param send_msg: Send notification - should always be True except in "recovery" methods
         :return: True if order has been cancelled without being filled partially, False otherwise
         """
         if not order_id:
@@ -1270,6 +1277,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_timedout.
+            return True
+
         # Try update amount (binance-fix)
         try:
             new_amount = self.get_real_amount(trade, order)
@@ -1281,22 +1293,18 @@ 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()
 
         # Updating wallets when order is closed
         if not trade.is_open:
-            if not stoploss_order and not trade.open_order_id:
+            if send_msg and not stoploss_order and not trade.open_order_id:
                 self._notify_exit(trade, '', True)
             self.handle_protections(trade.pair)
             self.wallets.update()
-        elif not trade.open_order_id:
+        elif send_msg and not trade.open_order_id:
             # Buy fill
-            self._notify_enter_fill(trade)
+            self._notify_enter(trade, fill=True)
 
         return False
 
@@ -1361,14 +1369,17 @@ class FreqtradeBot(LoggingMixin):
                     return self.apply_fee_conditional(trade, trade_base_currency,
                                                       amount=order_amount, fee_abs=fee_cost)
                 return order_amount
-        return self.fee_detection_from_trades(trade, order, order_amount)
+        return self.fee_detection_from_trades(trade, order, order_amount, order.get('trades', []))
 
-    def fee_detection_from_trades(self, trade: Trade, order: Dict, order_amount: float) -> float:
+    def fee_detection_from_trades(self, trade: Trade, order: Dict, order_amount: float,
+                                  trades: List) -> float:
         """
-        fee-detection fallback to Trades. Parses result of fetch_my_trades to get correct fee.
+        fee-detection fallback to Trades.
+        Either uses provided trades list or the result of fetch_my_trades to get correct fee.
         """
-        trades = self.exchange.get_trades_for_order(self.exchange.get_order_id_conditional(order),
-                                                    trade.pair, trade.open_date)
+        if not trades:
+            trades = self.exchange.get_trades_for_order(
+                self.exchange.get_order_id_conditional(order), trade.pair, trade.open_date)
 
         if len(trades) == 0:
             logger.info("Applying fee on amount for %s failed: myTrade-Dict empty found", trade)

freqtrade/optimize/backtesting.py

@@ -44,6 +44,7 @@ SELL_IDX = 4
 LOW_IDX = 5
 HIGH_IDX = 6
 BUY_TAG_IDX = 7
+EXIT_TAG_IDX = 8
 
 
 class Backtesting:
@@ -66,7 +67,7 @@ class Backtesting:
         self.all_results: Dict[str, Dict] = {}
 
         self.exchange = ExchangeResolver.load_exchange(self.config['exchange']['name'], self.config)
-        self.dataprovider = DataProvider(self.config, None)
+        self.dataprovider = DataProvider(self.config, self.exchange)
 
         if self.config.get('strategy_list', None):
             for strat in list(self.config['strategy_list']):
@@ -88,7 +89,8 @@ class Backtesting:
         self.init_backtest_detail()
         self.pairlists = PairListManager(self.exchange, self.config)
         if 'VolumePairList' in self.pairlists.name_list:
-            raise OperationalException("VolumePairList not allowed for backtesting.")
+            raise OperationalException("VolumePairList not allowed for backtesting. "
+                                       "Please use StaticPairlist instead.")
         if 'PerformanceFilter' in self.pairlists.name_list:
             raise OperationalException("PerformanceFilter not allowed for backtesting.")
 
@@ -247,7 +249,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', 'buy', 'open', 'close', 'sell', 'low', 'high', 'buy_tag']
+        headers = ['date', 'buy', 'open', 'close', 'sell', 'low', 'high', 'buy_tag', 'exit_tag']
         data: Dict = {}
         self.progress.init_step(BacktestState.CONVERT, len(processed))
 
@@ -259,6 +261,7 @@ class Backtesting:
                 pair_data.loc[:, 'buy'] = 0  # cleanup if buy_signal is exist
                 pair_data.loc[:, 'sell'] = 0  # cleanup if sell_signal is exist
                 pair_data.loc[:, 'buy_tag'] = None  # cleanup if buy_tag is exist
+                pair_data.loc[:, 'exit_tag'] = None  # cleanup if exit_tag is exist
 
             df_analyzed = self.strategy.advise_sell(
                 self.strategy.advise_buy(pair_data, {'pair': pair}), {'pair': pair}).copy()
@@ -270,6 +273,7 @@ class Backtesting:
             df_analyzed.loc[:, 'buy'] = df_analyzed.loc[:, 'buy'].shift(1)
             df_analyzed.loc[:, 'sell'] = df_analyzed.loc[:, 'sell'].shift(1)
             df_analyzed.loc[:, 'buy_tag'] = df_analyzed.loc[:, 'buy_tag'].shift(1)
+            df_analyzed.loc[:, 'exit_tag'] = df_analyzed.loc[:, 'exit_tag'].shift(1)
 
             # Update dataprovider cache
             self.dataprovider._set_cached_df(pair, self.timeframe, df_analyzed)
@@ -312,7 +316,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
@@ -336,10 +342,7 @@ class Backtesting:
                     # use Open rate if open_rate > calculated sell rate
                     return sell_row[OPEN_IDX]
 
-                # Use the maximum between close_rate and low as we
-                # cannot sell outside of a candle.
-                # Applies when a new ROI setting comes in place and the whole candle is above that.
-                return min(max(close_rate, sell_row[LOW_IDX]), sell_row[HIGH_IDX])
+                return close_rate
 
             else:
                 # This should not be reached...
@@ -357,9 +360,20 @@ class Backtesting:
 
         if sell.sell_flag:
             trade.close_date = sell_candle_time
-            trade.sell_reason = sell.sell_reason
+
             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)
+            # call the custom exit price,with default value as previous closerate
+            current_profit = trade.calc_profit_ratio(closerate)
+            if sell.sell_type in (SellType.SELL_SIGNAL, SellType.CUSTOM_SELL):
+                # Custom exit pricing only for sell-signals
+                closerate = strategy_safe_wrapper(self.strategy.custom_exit_price,
+                                                  default_retval=closerate)(
+                    pair=trade.pair, trade=trade,
+                    current_time=sell_row[DATE_IDX],
+                    proposed_rate=closerate, current_profit=current_profit)
+            # Use the maximum between close_rate and low as we cannot sell outside of a candle.
+            closerate = min(max(closerate, sell_row[LOW_IDX]), sell_row[HIGH_IDX])
 
             # Confirm trade exit:
             time_in_force = self.strategy.order_time_in_force['sell']
@@ -371,6 +385,17 @@ class Backtesting:
                     current_time=sell_candle_time):
                 return None
 
+            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.close(closerate, show_msg=False)
             return trade
 
@@ -385,7 +410,7 @@ class Backtesting:
             detail_data = detail_data.loc[
                 (detail_data['date'] >= sell_candle_time) &
                 (detail_data['date'] < sell_candle_end)
-             ].copy()
+            ].copy()
             if len(detail_data) == 0:
                 # Fall back to "regular" data if no detail data was found for this candle
                 return self._get_sell_trade_entry_for_candle(trade, sell_row)
@@ -407,15 +432,23 @@ class Backtesting:
             stake_amount = self.wallets.get_trade_stake_amount(pair, None)
         except DependencyException:
             return None
+        # let's call the custom entry price, using the open price as default price
+        propose_rate = strategy_safe_wrapper(self.strategy.custom_entry_price,
+                                             default_retval=row[OPEN_IDX])(
+            pair=pair, current_time=row[DATE_IDX].to_pydatetime(),
+            proposed_rate=row[OPEN_IDX])  # default value is the open rate
 
-        min_stake_amount = self.exchange.get_min_pair_stake_amount(pair, row[OPEN_IDX], -0.05) or 0
+        # Move rate to within the candle's low/high rate
+        propose_rate = min(max(propose_rate, row[LOW_IDX]), row[HIGH_IDX])
+
+        min_stake_amount = self.exchange.get_min_pair_stake_amount(pair, propose_rate, -0.05) or 0
         max_stake_amount = self.wallets.get_available_stake_amount()
 
         stake_amount = strategy_safe_wrapper(self.strategy.custom_stake_amount,
                                              default_retval=stake_amount)(
-            pair=pair, current_time=row[DATE_IDX].to_pydatetime(), current_rate=row[OPEN_IDX],
+            pair=pair, current_time=row[DATE_IDX].to_pydatetime(), current_rate=propose_rate,
             proposed_stake=stake_amount, min_stake=min_stake_amount, max_stake=max_stake_amount)
-        stake_amount = self.wallets._validate_stake_amount(pair, stake_amount, min_stake_amount)
+        stake_amount = self.wallets.validate_stake_amount(pair, stake_amount, min_stake_amount)
 
         if not stake_amount:
             return None
@@ -424,7 +457,7 @@ class Backtesting:
         time_in_force = self.strategy.order_time_in_force['sell']
         # Confirm trade entry:
         if not strategy_safe_wrapper(self.strategy.confirm_trade_entry, default_retval=True)(
-                pair=pair, order_type=order_type, amount=stake_amount, rate=row[OPEN_IDX],
+                pair=pair, order_type=order_type, amount=stake_amount, rate=propose_rate,
                 time_in_force=time_in_force, current_time=row[DATE_IDX].to_pydatetime()):
             return None
 
@@ -433,10 +466,10 @@ class Backtesting:
             has_buy_tag = len(row) >= BUY_TAG_IDX + 1
             trade = LocalTrade(
                 pair=pair,
-                open_rate=row[OPEN_IDX],
+                open_rate=propose_rate,
                 open_date=row[DATE_IDX].to_pydatetime(),
                 stake_amount=stake_amount,
-                amount=round(stake_amount / row[OPEN_IDX], 8),
+                amount=round(stake_amount / propose_rate, 8),
                 fee_open=self.fee,
                 fee_close=self.fee,
                 is_open=True,

freqtrade/optimize/hyperopt_loss_calmar.py

@@ -0,0 +1,64 @@
+"""
+CalmarHyperOptLoss
+
+This module defines the alternative HyperOptLoss class which can be used for
+Hyperoptimization.
+"""
+from datetime import datetime
+from math import sqrt as msqrt
+from typing import Any, Dict
+
+from pandas import DataFrame
+
+from freqtrade.data.btanalysis import calculate_max_drawdown
+from freqtrade.optimize.hyperopt import IHyperOptLoss
+
+
+class CalmarHyperOptLoss(IHyperOptLoss):
+    """
+    Defines the loss function for hyperopt.
+
+    This implementation uses the Calmar Ratio calculation.
+    """
+
+    @staticmethod
+    def hyperopt_loss_function(
+        results: DataFrame,
+        trade_count: int,
+        min_date: datetime,
+        max_date: datetime,
+        config: Dict,
+        processed: Dict[str, DataFrame],
+        backtest_stats: Dict[str, Any],
+        *args,
+        **kwargs
+    ) -> float:
+        """
+        Objective function, returns smaller number for more optimal results.
+
+        Uses Calmar Ratio calculation.
+        """
+        total_profit = backtest_stats["profit_total"]
+        days_period = (max_date - min_date).days
+
+        # adding slippage of 0.1% per trade
+        total_profit = total_profit - 0.0005
+        expected_returns_mean = total_profit.sum() / days_period * 100
+
+        # calculate max drawdown
+        try:
+            _, _, _, high_val, low_val = calculate_max_drawdown(
+                results, value_col="profit_abs"
+            )
+            max_drawdown = (high_val - low_val) / high_val
+        except ValueError:
+            max_drawdown = 0
+
+        if max_drawdown != 0:
+            calmar_ratio = expected_returns_mean / max_drawdown * msqrt(365)
+        else:
+            # Define high (negative) calmar ratio to be clear that this is NOT optimal.
+            calmar_ratio = -20.0
+
+        # print(expected_returns_mean, max_drawdown, calmar_ratio)
+        return -calmar_ratio

freqtrade/optimize/hyperopt_tools.py

@@ -284,10 +284,10 @@ class HyperoptTools():
         return (f"{results_metrics['total_trades']:6d} trades. "
                 f"{results_metrics['wins']}/{results_metrics['draws']}"
                 f"/{results_metrics['losses']} Wins/Draws/Losses. "
-                f"Avg profit {results_metrics['profit_mean'] * 100: 6.2f}%. "
-                f"Median profit {results_metrics['profit_median'] * 100: 6.2f}%. "
-                f"Total profit {results_metrics['profit_total_abs']: 11.8f} {stake_currency} "
-                f"({results_metrics['profit_total'] * 100: 7.2f}%). "
+                f"Avg profit {results_metrics['profit_mean']:7.2%}. "
+                f"Median profit {results_metrics['profit_median']:7.2%}. "
+                f"Total profit {results_metrics['profit_total_abs']:11.8f} {stake_currency} "
+                f"({results_metrics['profit_total']:8.2%}). "
                 f"Avg duration {results_metrics['holding_avg']} min."
                 )
 

freqtrade/optimize/optimize_reports.py

@@ -46,11 +46,11 @@ def _get_line_floatfmt(stake_currency: str) -> List[str]:
             '.2f', 'd', 's', 's']
 
 
-def _get_line_header(first_column: str, stake_currency: str) -> List[str]:
+def _get_line_header(first_column: str, stake_currency: str, direction: str = 'Buys') -> List[str]:
     """
     Generate header lines (goes in line with _generate_result_line())
     """
-    return [first_column, 'Buys', 'Avg Profit %', 'Cum Profit %',
+    return [first_column, direction, 'Avg Profit %', 'Cum Profit %',
             f'Tot Profit {stake_currency}', 'Tot Profit %', 'Avg Duration',
             'Win  Draw  Loss  Win%']
 
@@ -127,6 +127,38 @@ 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_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_sell_reason_stats(max_open_trades: int, results: DataFrame) -> List[Dict]:
     """
     Generate small table outlining Backtest results
@@ -347,6 +379,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 +406,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 +579,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("TAG", stake_currency, 'Sells')
+    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:
     """
@@ -615,22 +683,22 @@ def text_table_add_metrics(strat_results: Dict) -> str:
                                                strat_results['stake_currency'])),
             ('Absolute profit ', round_coin_value(strat_results['profit_total_abs'],
                                                   strat_results['stake_currency'])),
-            ('Total profit %', f"{round(strat_results['profit_total'] * 100, 2)}%"),
+            ('Total profit %', f"{strat_results['profit_total']:.2%}"),
             ('Trades per day', strat_results['trades_per_day']),
             ('Avg. daily profit %',
-             f"{round(strat_results['profit_total'] / strat_results['backtest_days'] * 100, 2)}%"),
+             f"{(strat_results['profit_total'] / strat_results['backtest_days']):.2%}"),
             ('Avg. stake amount', round_coin_value(strat_results['avg_stake_amount'],
                                                    strat_results['stake_currency'])),
             ('Total trade volume', round_coin_value(strat_results['total_volume'],
                                                     strat_results['stake_currency'])),
             ('', ''),  # Empty line to improve readability
             ('Best Pair', f"{strat_results['best_pair']['key']} "
-                          f"{round(strat_results['best_pair']['profit_sum_pct'], 2)}%"),
+                          f"{strat_results['best_pair']['profit_sum']:.2%}"),
             ('Worst Pair', f"{strat_results['worst_pair']['key']} "
-                           f"{round(strat_results['worst_pair']['profit_sum_pct'], 2)}%"),
-            ('Best trade', f"{best_trade['pair']} {round(best_trade['profit_ratio'] * 100, 2)}%"),
+                           f"{strat_results['worst_pair']['profit_sum']:.2%}"),
+            ('Best trade', f"{best_trade['pair']} {best_trade['profit_ratio']:.2%}"),
             ('Worst trade', f"{worst_trade['pair']} "
-                            f"{round(worst_trade['profit_ratio'] * 100, 2)}%"),
+                            f"{worst_trade['profit_ratio']:.2%}"),
 
             ('Best day', round_coin_value(strat_results['backtest_best_day_abs'],
                                           strat_results['stake_currency'])),
@@ -648,7 +716,7 @@ def text_table_add_metrics(strat_results: Dict) -> str:
             ('Max balance', round_coin_value(strat_results['csum_max'],
                                              strat_results['stake_currency'])),
 
-            ('Drawdown', f"{round(strat_results['max_drawdown'] * 100, 2)}%"),
+            ('Drawdown', f"{strat_results['max_drawdown']:.2%}"),
             ('Drawdown', round_coin_value(strat_results['max_drawdown_abs'],
                                           strat_results['stake_currency'])),
             ('Drawdown high', round_coin_value(strat_results['max_drawdown_high'],
@@ -657,7 +725,7 @@ def text_table_add_metrics(strat_results: Dict) -> str:
                                               strat_results['stake_currency'])),
             ('Drawdown Start', strat_results['drawdown_start']),
             ('Drawdown End', strat_results['drawdown_end']),
-            ('Market change', f"{round(strat_results['market_change'] * 100, 2)}%"),
+            ('Market change', f"{strat_results['market_change']:.2%}"),
         ]
 
         return tabulate(metrics, headers=["Metric", "Value"], tablefmt="orgtbl")
@@ -687,6 +755,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 +792,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 +814,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"]}",  // {result["profit_mean"]:.2%}')
+            print("]")

freqtrade/persistence/models.py

@@ -195,6 +195,8 @@ class Order(_DECL_BASE):
     @staticmethod
     def get_open_orders() -> List['Order']:
         """
+        Retrieve open orders from the database
+        :return: List of open orders
         """
         return Order.query.filter(Order.ft_is_open.is_(True)).all()
 
@@ -491,6 +493,13 @@ class LocalTrade():
     def update_order(self, order: Dict) -> None:
         Order.update_orders(self.orders, order)
 
+    def get_exit_order_count(self) -> int:
+        """
+        Get amount of failed exiting orders
+        assumes full exits.
+        """
+        return len([o for o in self.orders if o.ft_order_side == 'sell'])
+
     def _calc_open_trade_value(self) -> float:
         """
         Calculate the open_rate including open_fee.
@@ -775,7 +784,7 @@ class Trade(_DECL_BASE, LocalTrade):
             return Trade.query
 
     @staticmethod
-    def get_open_order_trades():
+    def get_open_order_trades() -> List['Trade']:
         """
         Returns all open trades
         NOTE: Not supported in Backtesting.
@@ -853,13 +862,132 @@ 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_pct': round(profit * 100, 2),
+                                        '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_pct': round(profit + return_list[i]["profit"] * 100, 2),
+                                'profit_abs': profit_abs + return_list[i]["profit_abs"],
+                                'count': 1 + return_list[i]["count"]}
+                        i += 1
+
+        return return_list
+
     @staticmethod
     def get_best_pair(start_date: datetime = datetime.fromtimestamp(0)):
         """
@@ -896,7 +1024,7 @@ class PairLock(_DECL_BASE):
         lock_time = self.lock_time.strftime(DATETIME_PRINT_FORMAT)
         lock_end_time = self.lock_end_time.strftime(DATETIME_PRINT_FORMAT)
         return (f'PairLock(id={self.id}, pair={self.pair}, lock_time={lock_time}, '
-                f'lock_end_time={lock_end_time})')
+                f'lock_end_time={lock_end_time}, reason={self.reason}, active={self.active})')
 
     @staticmethod
     def query_pair_locks(pair: Optional[str], now: datetime) -> Query:
@@ -905,7 +1033,6 @@ class PairLock(_DECL_BASE):
         :param pair: Pair to check for. Returns all current locks if pair is empty
         :param now: Datetime object (generated via datetime.now(timezone.utc)).
         """
-
         filters = [PairLock.lock_end_time > now,
                    # Only active locks
                    PairLock.active.is_(True), ]

freqtrade/persistence/pairlock_middleware.py

@@ -103,6 +103,36 @@ class PairLocks():
         if PairLocks.use_db:
             PairLock.query.session.commit()
 
+    @staticmethod
+    def unlock_reason(reason: str, now: Optional[datetime] = None) -> None:
+        """
+        Release all locks for this reason.
+        :param reason: Which reason to unlock
+        :param now: Datetime object (generated via datetime.now(timezone.utc)).
+            defaults to datetime.now(timezone.utc)
+        """
+        if not now:
+            now = datetime.now(timezone.utc)
+
+        if PairLocks.use_db:
+            # used in live modes
+            logger.info(f"Releasing all locks with reason '{reason}':")
+            filters = [PairLock.lock_end_time > now,
+                       PairLock.active.is_(True),
+                       PairLock.reason == reason
+                       ]
+            locks = PairLock.query.filter(*filters)
+            for lock in locks:
+                logger.info(f"Releasing lock for {lock.pair} with reason '{reason}'.")
+                lock.active = False
+            PairLock.query.session.commit()
+        else:
+            # used in backtesting mode; don't show log messages for speed
+            locks = PairLocks.get_pair_locks(None)
+            for lock in locks:
+                if lock.reason == reason:
+                    lock.active = False
+
     @staticmethod
     def is_global_lock(now: Optional[datetime] = None) -> bool:
         """
@@ -128,7 +158,9 @@ class PairLocks():
 
     @staticmethod
     def get_all_locks() -> List[PairLock]:
-
+        """
+        Return all locks, also locks with expired end date
+        """
         if PairLocks.use_db:
             return PairLock.query.all()
         else:

freqtrade/plot/plotting.py

@@ -169,8 +169,8 @@ def add_max_drawdown(fig, row, trades: pd.DataFrame, df_comb: pd.DataFrame,
                 df_comb.loc[timeframe_to_prev_date(timeframe, lowdate), 'cum_profit'],
             ],
             mode='markers',
-            name=f"Max drawdown {max_drawdown * 100:.2f}%",
-            text=f"Max drawdown {max_drawdown * 100:.2f}%",
+            name=f"Max drawdown {max_drawdown:.2%}",
+            text=f"Max drawdown {max_drawdown:.2%}",
             marker=dict(
                 symbol='square-open',
                 size=9,
@@ -192,7 +192,7 @@ def plot_trades(fig, trades: pd.DataFrame) -> make_subplots:
     # Trades can be empty
     if trades is not None and len(trades) > 0:
         # Create description for sell summarizing the trade
-        trades['desc'] = trades.apply(lambda row: f"{round(row['profit_ratio'] * 100, 1)}%, "
+        trades['desc'] = trades.apply(lambda row: f"{row['profit_ratio']:.2%}, "
                                                   f"{row['sell_reason']}, "
                                                   f"{row['trade_duration']} min",
                                       axis=1)

freqtrade/plugins/pairlist/PerformanceFilter.py

@@ -68,14 +68,14 @@ class PerformanceFilter(IPairList):
         #  - then pair name alphametically
         sorted_df = list_df.merge(performance, on='pair', how='left')\
             .fillna(0).sort_values(by=['count', 'pair'], ascending=True)\
-            .sort_values(by=['profit'], ascending=False)
+            .sort_values(by=['profit_ratio'], ascending=False)
         if self._min_profit is not None:
-            removed = sorted_df[sorted_df['profit'] < self._min_profit]
+            removed = sorted_df[sorted_df['profit_ratio'] < self._min_profit]
             for _, row in removed.iterrows():
                 self.log_once(
-                    f"Removing pair {row['pair']} since {row['profit']} is "
+                    f"Removing pair {row['pair']} since {row['profit_ratio']} is "
                     f"below {self._min_profit}", logger.info)
-            sorted_df = sorted_df[sorted_df['profit'] >= self._min_profit]
+            sorted_df = sorted_df[sorted_df['profit_ratio'] >= self._min_profit]
 
         pairlist = sorted_df['pair'].tolist()
 

freqtrade/plugins/pairlist/PriceFilter.py

@@ -50,7 +50,7 @@ class PriceFilter(IPairList):
         """
         active_price_filters = []
         if self._low_price_ratio != 0:
-            active_price_filters.append(f"below {self._low_price_ratio * 100}%")
+            active_price_filters.append(f"below {self._low_price_ratio:.1%}")
         if self._min_price != 0:
             active_price_filters.append(f"below {self._min_price:.8f}")
         if self._max_price != 0:
@@ -82,7 +82,7 @@ class PriceFilter(IPairList):
             changeperc = compare / ticker['last']
             if changeperc > self._low_price_ratio:
                 self.log_once(f"Removed {pair} from whitelist, "
-                              f"because 1 unit is {changeperc * 100:.3f}%", logger.info)
+                              f"because 1 unit is {changeperc:.3%}", logger.info)
                 return False
 
         # Perform low_amount check

freqtrade/plugins/pairlist/ShuffleFilter.py

@@ -5,6 +5,7 @@ import logging
 import random
 from typing import Any, Dict, List
 
+from freqtrade.enums import RunMode
 from freqtrade.plugins.pairlist.IPairList import IPairList
 
 
@@ -18,7 +19,15 @@ class ShuffleFilter(IPairList):
                  pairlist_pos: int) -> None:
         super().__init__(exchange, pairlistmanager, config, pairlistconfig, pairlist_pos)
 
-        self._seed = pairlistconfig.get('seed')
+        # Apply seed in backtesting mode to get comparable results,
+        # but not in live modes to get a non-repeating order of pairs during live modes.
+        if config.get('runmode') in (RunMode.LIVE, RunMode.DRY_RUN):
+            self._seed = None
+            logger.info("Live mode detected, not applying seed.")
+        else:
+            self._seed = pairlistconfig.get('seed')
+            logger.info(f"Backtesting mode detected, applying seed value: {self._seed}")
+
         self._random = random.Random(self._seed)
 
     @property

freqtrade/plugins/pairlist/SpreadFilter.py

@@ -34,7 +34,7 @@ class SpreadFilter(IPairList):
         Short whitelist method description - used for startup-messages
         """
         return (f"{self.name} - Filtering pairs with ask/bid diff above "
-                f"{self._max_spread_ratio * 100}%.")
+                f"{self._max_spread_ratio:.2%}.")
 
     def _validate_pair(self, pair: str, ticker: Dict[str, Any]) -> bool:
         """
@@ -47,7 +47,7 @@ class SpreadFilter(IPairList):
             spread = 1 - ticker['bid'] / ticker['ask']
             if spread > self._max_spread_ratio:
                 self.log_once(f"Removed {pair} from whitelist, because spread "
-                              f"{spread * 100:.3f}% > {self._max_spread_ratio * 100}%",
+                              f"{spread * 100:.3%} > {self._max_spread_ratio:.3%}",
                               logger.info)
                 return False
             else:

freqtrade/plugins/pairlist/VolatilityFilter.py

@@ -8,7 +8,7 @@ from typing import Any, Dict, List, Optional
 
 import arrow
 import numpy as np
-from cachetools.ttl import TTLCache
+from cachetools import TTLCache
 from pandas import DataFrame
 
 from freqtrade.exceptions import OperationalException

freqtrade/plugins/pairlist/VolumePairList.py

@@ -8,7 +8,7 @@ from functools import partial
 from typing import Any, Dict, List
 
 import arrow
-from cachetools.ttl import TTLCache
+from cachetools import TTLCache
 
 from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import timeframe_to_minutes

freqtrade/plugins/pairlist/rangestabilityfilter.py

@@ -6,7 +6,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 import arrow
-from cachetools.ttl import TTLCache
+from cachetools import TTLCache
 from pandas import DataFrame
 
 from freqtrade.exceptions import OperationalException

freqtrade/plugins/pairlistmanager.py

@@ -2,13 +2,14 @@
 PairList manager class
 """
 import logging
-from copy import deepcopy
+from functools import partial
 from typing import Dict, List
 
 from cachetools import TTLCache, cached
 
 from freqtrade.constants import ListPairsWithTimeframes
 from freqtrade.exceptions import OperationalException
+from freqtrade.mixins import LoggingMixin
 from freqtrade.plugins.pairlist.IPairList import IPairList
 from freqtrade.plugins.pairlist.pairlist_helpers import expand_pairlist
 from freqtrade.resolvers import PairListResolver
@@ -17,7 +18,7 @@ from freqtrade.resolvers import PairListResolver
 logger = logging.getLogger(__name__)
 
 
-class PairListManager():
+class PairListManager(LoggingMixin):
 
     def __init__(self, exchange, config: dict) -> None:
         self._exchange = exchange
@@ -41,6 +42,9 @@ class PairListManager():
         if not self._pairlist_handlers:
             raise OperationalException("No Pairlist Handlers defined")
 
+        refresh_period = config.get('pairlist_refresh_period', 3600)
+        LoggingMixin.__init__(self, logger, refresh_period)
+
     @property
     def whitelist(self) -> List[str]:
         """The current whitelist"""
@@ -108,9 +112,10 @@ class PairListManager():
         except ValueError as err:
             logger.error(f"Pair blacklist contains an invalid Wildcard: {err}")
             return []
-        for pair in deepcopy(pairlist):
+        log_once = partial(self.log_once, logmethod=logmethod)
+        for pair in pairlist.copy():
             if pair in blacklist:
-                logmethod(f"Pair {pair} in your blacklist. Removing it from whitelist...")
+                log_once(f"Pair {pair} in your blacklist. Removing it from whitelist...")
                 pairlist.remove(pair)
         return pairlist
 

freqtrade/rpc/api_server/api_backtest.py

@@ -33,6 +33,9 @@ async def api_start_backtest(bt_settings: BacktestRequest, background_tasks: Bac
         if settings[setting] is not None:
             btconfig[setting] = settings[setting]
 
+    # Force dry-run for backtesting
+    btconfig['dry_run'] = True
+
     # Start backtesting
     # Initialize backtesting object
     def run_backtest():

freqtrade/rpc/api_server/api_schemas.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, List, Optional, Union
 from pydantic import BaseModel
 
 from freqtrade.constants import DATETIME_PRINT_FORMAT
+from freqtrade.enums import OrderTypeValues
 
 
 class Ping(BaseModel):
@@ -63,6 +64,8 @@ class Count(BaseModel):
 class PerformanceEntry(BaseModel):
     pair: str
     profit: float
+    profit_ratio: float
+    profit_pct: float
     profit_abs: float
     count: int
 
@@ -93,6 +96,7 @@ class Profit(BaseModel):
     avg_duration: str
     best_pair: str
     best_rate: float
+    best_pair_profit_ratio: float
     winning_trades: int
     losing_trades: int
 
@@ -121,7 +125,28 @@ class Daily(BaseModel):
     stake_currency: str
 
 
+class UnfilledTimeout(BaseModel):
+    buy: Optional[int]
+    sell: Optional[int]
+    unit: Optional[str]
+    exit_timeout_count: Optional[int]
+
+
+class OrderTypes(BaseModel):
+    buy: OrderTypeValues
+    sell: OrderTypeValues
+    emergencysell: Optional[OrderTypeValues]
+    forcesell: Optional[OrderTypeValues]
+    forcebuy: Optional[OrderTypeValues]
+    stoploss: OrderTypeValues
+    stoploss_on_exchange: bool
+    stoploss_on_exchange_interval: Optional[int]
+
+
 class ShowConfig(BaseModel):
+    version: str
+    strategy_version: Optional[str]
+    api_version: float
     dry_run: bool
     stake_currency: str
     stake_amount: Union[float, str]
@@ -134,6 +159,8 @@ class ShowConfig(BaseModel):
     trailing_stop_positive: Optional[float]
     trailing_stop_positive_offset: Optional[float]
     trailing_only_offset_is_reached: Optional[bool]
+    unfilledtimeout: UnfilledTimeout
+    order_types: Optional[OrderTypes]
     use_custom_stoploss: Optional[bool]
     timeframe: Optional[str]
     timeframe_ms: int
@@ -249,10 +276,12 @@ class Logs(BaseModel):
 class ForceBuyPayload(BaseModel):
     pair: str
     price: Optional[float]
+    ordertype: Optional[OrderTypeValues]
 
 
 class ForceSellPayload(BaseModel):
     tradeid: str
+    ordertype: Optional[OrderTypeValues]
 
 
 class BlacklistPayload(BaseModel):

freqtrade/rpc/api_server/api_v1.py

@@ -3,7 +3,7 @@ from copy import deepcopy
 from pathlib import Path
 from typing import List, Optional
 
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, Query
 from fastapi.exceptions import HTTPException
 
 from freqtrade import __version__
@@ -26,6 +26,13 @@ from freqtrade.rpc.rpc import RPCException
 
 logger = logging.getLogger(__name__)
 
+# API version
+# Pre-1.1, no version was provided
+# Version increments should happen in "small" steps (1.1, 1.12, ...) unless big changes happen.
+# 1.11: forcebuy and forcesell accept ordertype
+# 1.12: add blacklist delete endpoint
+API_VERSION = 1.12
+
 # Public API, requires no auth.
 router_public = APIRouter()
 # Private API, protected by authentication
@@ -115,14 +122,19 @@ def edge(rpc: RPC = Depends(get_rpc)):
 @router.get('/show_config', response_model=ShowConfig, tags=['info'])
 def show_config(rpc: Optional[RPC] = Depends(get_rpc_optional), config=Depends(get_config)):
     state = ''
+    strategy_version = None
     if rpc:
         state = rpc._freqtrade.state
-    return RPC._rpc_show_config(config, state)
+        strategy_version = rpc._freqtrade.strategy.version()
+    resp = RPC._rpc_show_config(config, state, strategy_version)
+    resp['api_version'] = API_VERSION
+    return resp
 
 
 @router.post('/forcebuy', response_model=ForceBuyResponse, tags=['trading'])
 def forcebuy(payload: ForceBuyPayload, rpc: RPC = Depends(get_rpc)):
-    trade = rpc._rpc_forcebuy(payload.pair, payload.price)
+    ordertype = payload.ordertype.value if payload.ordertype else None
+    trade = rpc._rpc_forcebuy(payload.pair, payload.price, ordertype)
 
     if trade:
         return ForceBuyResponse.parse_obj(trade.to_json())
@@ -132,7 +144,8 @@ def forcebuy(payload: ForceBuyPayload, rpc: RPC = Depends(get_rpc)):
 
 @router.post('/forcesell', response_model=ResultMsg, tags=['trading'])
 def forcesell(payload: ForceSellPayload, rpc: RPC = Depends(get_rpc)):
-    return rpc._rpc_forcesell(payload.tradeid)
+    ordertype = payload.ordertype.value if payload.ordertype else None
+    return rpc._rpc_forcesell(payload.tradeid, ordertype)
 
 
 @router.get('/blacklist', response_model=BlacklistResponse, tags=['info', 'pairlist'])
@@ -145,6 +158,13 @@ def blacklist_post(payload: BlacklistPayload, rpc: RPC = Depends(get_rpc)):
     return rpc._rpc_blacklist(payload.blacklist)
 
 
+@router.delete('/blacklist', response_model=BlacklistResponse, tags=['info', 'pairlist'])
+def blacklist_delete(pairs_to_delete: List[str] = Query([]), rpc: RPC = Depends(get_rpc)):
+    """Provide a list of pairs to delete from the blacklist"""
+
+    return rpc._rpc_blacklist_delete(pairs_to_delete)
+
+
 @router.get('/whitelist', response_model=WhitelistResponse, tags=['info', 'pairlist'])
 def whitelist(rpc: RPC = Depends(get_rpc)):
     return rpc._rpc_whitelist()

freqtrade/rpc/fiat_convert.py

@@ -7,7 +7,7 @@ import datetime
 import logging
 from typing import Dict, List
 
-from cachetools.ttl import TTLCache
+from cachetools import TTLCache
 from pycoingecko import CoinGeckoAPI
 from requests.exceptions import RequestException
 

freqtrade/rpc/rpc.py

@@ -9,9 +9,11 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 
 import arrow
 import psutil
+from dateutil.relativedelta import relativedelta
 from numpy import NAN, inf, int64, mean
 from pandas import DataFrame
 
+from freqtrade import __version__
 from freqtrade.configuration.timerange import TimeRange
 from freqtrade.constants import CANCEL_REASON, DATETIME_PRINT_FORMAT
 from freqtrade.data.history import load_data
@@ -96,16 +98,19 @@ class RPC:
             self._fiat_converter = CryptoToFiatConverter()
 
     @staticmethod
-    def _rpc_show_config(config, botstate: Union[State, str]) -> Dict[str, Any]:
+    def _rpc_show_config(config, botstate: Union[State, str],
+                         strategy_version: Optional[str] = None) -> Dict[str, Any]:
         """
         Return a dict of config options.
         Explicitly does NOT return the full config to avoid leakage of sensitive
         information via rpc.
         """
         val = {
+            'version': __version__,
+            'strategy_version': strategy_version,
             'dry_run': config['dry_run'],
             'stake_currency': config['stake_currency'],
-            'stake_currency_decimals':  decimals_per_coin(config['stake_currency']),
+            'stake_currency_decimals': decimals_per_coin(config['stake_currency']),
             'stake_amount': config['stake_amount'],
             'available_capital': config.get('available_capital'),
             'max_open_trades': (config['max_open_trades']
@@ -116,7 +121,9 @@ class RPC:
             'trailing_stop_positive': config.get('trailing_stop_positive'),
             'trailing_stop_positive_offset': config.get('trailing_stop_positive_offset'),
             'trailing_only_offset_is_reached': config.get('trailing_only_offset_is_reached'),
+            'unfilledtimeout': config.get('unfilledtimeout'),
             'use_custom_stoploss': config.get('use_custom_stoploss'),
+            'order_types': config.get('order_types'),
             'bot_name': config.get('bot_name', 'freqtrade'),
             'timeframe': config.get('timeframe'),
             'timeframe_ms': timeframe_to_msecs(config['timeframe']
@@ -219,9 +226,8 @@ class RPC:
                         trade.pair, refresh=False, side="sell")
                 except (PricingError, ExchangeError):
                     current_rate = NAN
-                trade_percent = (100 * trade.calc_profit_ratio(current_rate))
                 trade_profit = trade.calc_profit(current_rate)
-                profit_str = f'{trade_percent:.2f}%'
+                profit_str = f'{trade.calc_profit_ratio(current_rate):.2%}'
                 if self._fiat_converter:
                     fiat_profit = self._fiat_converter.convert_amount(
                         trade_profit,
@@ -250,7 +256,7 @@ class RPC:
     def _rpc_daily_profit(
             self, timescale: int,
             stake_currency: str, fiat_display_currency: str) -> Dict[str, Any]:
-        today = datetime.utcnow().date()
+        today = datetime.now(timezone.utc).date()
         profit_days: Dict[date, Dict] = {}
 
         if not (isinstance(timescale, int) and timescale > 0):
@@ -289,6 +295,91 @@ class RPC:
             'data': data
         }
 
+    def _rpc_weekly_profit(
+            self, timescale: int,
+            stake_currency: str, fiat_display_currency: str) -> Dict[str, Any]:
+        today = datetime.now(timezone.utc).date()
+        first_iso_day_of_week = today - timedelta(days=today.weekday())  # Monday
+        profit_weeks: Dict[date, Dict] = {}
+
+        if not (isinstance(timescale, int) and timescale > 0):
+            raise RPCException('timescale must be an integer greater than 0')
+
+        for week in range(0, timescale):
+            profitweek = first_iso_day_of_week - timedelta(weeks=week)
+            trades = Trade.get_trades(trade_filter=[
+                Trade.is_open.is_(False),
+                Trade.close_date >= profitweek,
+                Trade.close_date < (profitweek + timedelta(weeks=1))
+            ]).order_by(Trade.close_date).all()
+            curweekprofit = sum(
+                trade.close_profit_abs for trade in trades if trade.close_profit_abs is not None)
+            profit_weeks[profitweek] = {
+                'amount': curweekprofit,
+                'trades': len(trades)
+            }
+
+        data = [
+            {
+                'date': key,
+                'abs_profit': value["amount"],
+                'fiat_value': self._fiat_converter.convert_amount(
+                    value['amount'],
+                    stake_currency,
+                    fiat_display_currency
+                ) if self._fiat_converter else 0,
+                'trade_count': value["trades"],
+            }
+            for key, value in profit_weeks.items()
+        ]
+        return {
+            'stake_currency': stake_currency,
+            'fiat_display_currency': fiat_display_currency,
+            'data': data
+        }
+
+    def _rpc_monthly_profit(
+            self, timescale: int,
+            stake_currency: str, fiat_display_currency: str) -> Dict[str, Any]:
+        first_day_of_month = datetime.now(timezone.utc).date().replace(day=1)
+        profit_months: Dict[date, Dict] = {}
+
+        if not (isinstance(timescale, int) and timescale > 0):
+            raise RPCException('timescale must be an integer greater than 0')
+
+        for month in range(0, timescale):
+            profitmonth = first_day_of_month - relativedelta(months=month)
+            trades = Trade.get_trades(trade_filter=[
+                Trade.is_open.is_(False),
+                Trade.close_date >= profitmonth,
+                Trade.close_date < (profitmonth + relativedelta(months=1))
+            ]).order_by(Trade.close_date).all()
+            curmonthprofit = sum(
+                trade.close_profit_abs for trade in trades if trade.close_profit_abs is not None)
+            profit_months[profitmonth] = {
+                'amount': curmonthprofit,
+                'trades': len(trades)
+            }
+
+        data = [
+            {
+                'date': f"{key.year}-{key.month:02d}",
+                'abs_profit': value["amount"],
+                'fiat_value': self._fiat_converter.convert_amount(
+                    value['amount'],
+                    stake_currency,
+                    fiat_display_currency
+                ) if self._fiat_converter else 0,
+                'trade_count': value["trades"],
+            }
+            for key, value in profit_months.items()
+        ]
+        return {
+            'stake_currency': stake_currency,
+            'fiat_display_currency': fiat_display_currency,
+            'data': data
+        }
+
     def _rpc_trade_history(self, limit: int, offset: int = 0, order_by_id: bool = False) -> Dict:
         """ Returns the X last trades """
         order_by = Trade.id if order_by_id else Trade.close_date.desc()
@@ -444,7 +535,8 @@ class RPC:
             'latest_trade_timestamp': int(last_date.timestamp() * 1000) if last_date else 0,
             'avg_duration': str(timedelta(seconds=sum(durations) / num)).split('.')[0],
             'best_pair': best_pair[0] if best_pair else '',
-            'best_rate': round(best_pair[1] * 100, 2) if best_pair else 0,
+            'best_rate': round(best_pair[1] * 100, 2) if best_pair else 0,  # Deprecated
+            'best_pair_profit_ratio': best_pair[1] if best_pair else 0,
             'winning_trades': winning_trades,
             'losing_trades': losing_trades,
         }
@@ -550,7 +642,7 @@ class RPC:
 
         return {'status': 'No more buy will occur from now. Run /reload_config to reset.'}
 
-    def _rpc_forcesell(self, trade_id: str) -> Dict[str, str]:
+    def _rpc_forcesell(self, trade_id: str, ordertype: Optional[str] = None) -> Dict[str, str]:
         """
         Handler for forcesell <id>.
         Sells the given trade at current price
@@ -574,7 +666,11 @@ class RPC:
                 current_rate = self._freqtrade.exchange.get_rate(
                     trade.pair, refresh=False, side="sell")
                 sell_reason = SellCheckTuple(sell_type=SellType.FORCE_SELL)
-                self._freqtrade.execute_trade_exit(trade, current_rate, sell_reason)
+                order_type = ordertype or self._freqtrade.strategy.order_types.get(
+                    "forcesell", self._freqtrade.strategy.order_types["sell"])
+
+                self._freqtrade.execute_trade_exit(
+                    trade, current_rate, sell_reason, ordertype=order_type)
         # ---- EOF def _exec_forcesell ----
 
         if self._freqtrade.state != State.RUNNING:
@@ -602,7 +698,8 @@ class RPC:
             self._freqtrade.wallets.update()
             return {'result': f'Created sell order for trade {trade_id}.'}
 
-    def _rpc_forcebuy(self, pair: str, price: Optional[float]) -> Optional[Trade]:
+    def _rpc_forcebuy(self, pair: str, price: Optional[float],
+                      order_type: Optional[str] = None) -> Optional[Trade]:
         """
         Handler for forcebuy <asset> <price>
         Buys a pair trade at the given or current price
@@ -630,7 +727,10 @@ class RPC:
         stakeamount = self._freqtrade.wallets.get_trade_stake_amount(pair)
 
         # execute buy
-        if self._freqtrade.execute_entry(pair, stakeamount, price, forcebuy=True):
+        if not order_type:
+            order_type = self._freqtrade.strategy.order_types.get(
+                'forcebuy', self._freqtrade.strategy.order_types['buy'])
+        if self._freqtrade.execute_entry(pair, stakeamount, price, ordertype=order_type):
             Trade.commit()
             trade = Trade.get_trades([Trade.is_open.is_(True), Trade.pair == pair]).first()
             return trade
@@ -682,10 +782,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:
@@ -734,6 +860,20 @@ class RPC:
                }
         return res
 
+    def _rpc_blacklist_delete(self, delete: List[str]) -> Dict:
+        """ Removes pairs from currently active blacklist """
+        errors = {}
+        for pair in delete:
+            if pair in self._freqtrade.pairlists.blacklist:
+                self._freqtrade.pairlists.blacklist.remove(pair)
+            else:
+                errors[pair] = {
+                    'error_msg': f"Pair {pair} is not in the current blacklist."
+                    }
+        resp = self._rpc_blacklist()
+        resp['errors'] = errors
+        return resp
+
     def _rpc_blacklist(self, add: List[str] = None) -> Dict:
         """ Returns the currently active blacklist"""
         errors = {}
@@ -793,15 +933,15 @@ class RPC:
         if has_content:
 
             dataframe.loc[:, '__date_ts'] = dataframe.loc[:, 'date'].view(int64) // 1000 // 1000
-            # Move open to separate column when signal for easy plotting
+            # Move signal close to separate column when signal for easy plotting
             if 'buy' in dataframe.columns:
                 buy_mask = (dataframe['buy'] == 1)
                 buy_signals = int(buy_mask.sum())
-                dataframe.loc[buy_mask, '_buy_signal_open'] = dataframe.loc[buy_mask, 'open']
+                dataframe.loc[buy_mask, '_buy_signal_close'] = dataframe.loc[buy_mask, 'close']
             if 'sell' in dataframe.columns:
                 sell_mask = (dataframe['sell'] == 1)
                 sell_signals = int(sell_mask.sum())
-                dataframe.loc[sell_mask, '_sell_signal_open'] = dataframe.loc[sell_mask, 'open']
+                dataframe.loc[sell_mask, '_sell_signal_close'] = dataframe.loc[sell_mask, 'close']
             dataframe = dataframe.replace([inf, -inf], NAN)
             dataframe = dataframe.replace({NAN: None})
 

freqtrade/rpc/rpc_manager.py

@@ -60,6 +60,10 @@ class RPCManager:
         }
         """
         logger.info('Sending rpc message: %s', msg)
+        if 'pair' in msg:
+            msg.update({
+                'base_currency': self._rpc._freqtrade.exchange.get_pair_base_currency(msg['pair'])
+                })
         for mod in self.registered_modules:
             logger.debug('Forwarding message to rpc.%s', mod.name)
             try:

freqtrade/rpc/telegram.py

@@ -107,12 +107,13 @@ 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$',
-                                 r'/forcebuy$', r'/help$', r'/version$']
+                                 r'/logs$', r'/whitelist$', r'/blacklist$', r'/bl_delete$',
+                                 r'/weekly$', r'/weekly \d+$', r'/monthly$', r'/monthly \d+$',
+                                 r'/forcebuy$', r'/edge$', r'/help$', r'/version$']
         # Create keys for generation
         valid_keys_print = [k.replace('$', '') for k in valid_keys]
 
@@ -154,8 +155,13 @@ 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('weekly', self._weekly),
+            CommandHandler('monthly', self._monthly),
             CommandHandler('count', self._count),
             CommandHandler('locks', self._locks),
             CommandHandler(['unlock', 'delete_locks'], self._delete_locks),
@@ -164,6 +170,7 @@ class Telegram(RPCHandler):
             CommandHandler('stopbuy', self._stopbuy),
             CommandHandler('whitelist', self._whitelist),
             CommandHandler('blacklist', self._blacklist),
+            CommandHandler(['blacklist_delete', 'bl_delete'], self._blacklist_delete),
             CommandHandler('logs', self._logs),
             CommandHandler('edge', self._edge),
             CommandHandler('help', self._help),
@@ -172,9 +179,15 @@ class Telegram(RPCHandler):
         callbacks = [
             CallbackQueryHandler(self._status_table, pattern='update_status_table'),
             CallbackQueryHandler(self._daily, pattern='update_daily'),
+            CallbackQueryHandler(self._weekly, pattern='update_weekly'),
+            CallbackQueryHandler(self._monthly, pattern='update_monthly'),
             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),
         ]
@@ -208,26 +221,28 @@ class Telegram(RPCHandler):
                 msg['stake_amount'], msg['stake_currency'], msg['fiat_currency'])
         else:
             msg['stake_amount_fiat'] = 0
+        is_fill = msg['type'] == RPCMessageType.BUY_FILL
+        emoji = '\N{CHECK MARK}' if is_fill else '\N{LARGE BLUE CIRCLE}'
 
-        content = []
-        content.append(
-            f"\N{LARGE BLUE CIRCLE} *{msg['exchange']}:* Buying {msg['pair']}"
+        message = (
+            f"{emoji} *{msg['exchange']}:* {'Bought' if is_fill else 'Buying'} {msg['pair']}"
             f" (#{msg['trade_id']})\n"
-        )
-        if msg.get('buy_tag', None):
-            content.append(f"*Buy Tag:* `{msg['buy_tag']}`\n")
-        content.append(f"*Amount:* `{msg['amount']:.8f}`\n")
-        content.append(f"*Open Rate:* `{msg['limit']:.8f}`\n")
-        content.append(f"*Current Rate:* `{msg['current_rate']:.8f}`\n")
-        content.append(
-            f"*Total:* `({round_coin_value(msg['stake_amount'], msg['stake_currency'])}"
-        )
-        if msg.get('fiat_currency', None):
-            content.append(
-                f", {round_coin_value(msg['stake_amount_fiat'], msg['fiat_currency'])}"
             )
+        message += f"*Buy Tag:* `{msg['buy_tag']}`\n" if msg.get('buy_tag', None) else ""
+        message += f"*Amount:* `{msg['amount']:.8f}`\n"
+
+        if msg['type'] == RPCMessageType.BUY_FILL:
+            message += f"*Open Rate:* `{msg['open_rate']:.8f}`\n"
+
+        elif msg['type'] == RPCMessageType.BUY:
+            message += f"*Open Rate:* `{msg['limit']:.8f}`\n"\
+                       f"*Current Rate:* `{msg['current_rate']:.8f}`\n"
+
+        message += f"*Total:* `({round_coin_value(msg['stake_amount'], msg['stake_currency'])}"
+
+        if msg.get('fiat_currency', None):
+            message += f", {round_coin_value(msg['stake_amount_fiat'], msg['fiat_currency'])}"
 
-        message = ''.join(content)
         message += ")`"
         return message
 
@@ -238,6 +253,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.
@@ -246,53 +262,57 @@ class Telegram(RPCHandler):
                 and self._rpc._fiat_converter):
             msg['profit_fiat'] = self._rpc._fiat_converter.convert_amount(
                 msg['profit_amount'], msg['stake_currency'], msg['fiat_currency'])
-            msg['profit_extra'] = (' ({gain}: {profit_amount:.8f} {stake_currency}'
-                                   ' / {profit_fiat:.3f} {fiat_currency})').format(**msg)
+            msg['profit_extra'] = (
+                f" ({msg['gain']}: {msg['profit_amount']:.8f} {msg['stake_currency']}"
+                f" / {msg['profit_fiat']:.3f} {msg['fiat_currency']})")
         else:
             msg['profit_extra'] = ''
+        is_fill = msg['type'] == RPCMessageType.SELL_FILL
+        message = (
+            f"{msg['emoji']} *{msg['exchange']}:* "
+            f"{'Sold' if is_fill else 'Selling'} {msg['pair']} (#{msg['trade_id']})\n"
+            f"*{'Profit' if is_fill else 'Unrealized Profit'}:* "
+            f"`{msg['profit_ratio']:.2%}{msg['profit_extra']}`\n"
+            f"*Buy Tag:* `{msg['buy_tag']}`\n"
+            f"*Sell Reason:* `{msg['sell_reason']}`\n"
+            f"*Duration:* `{msg['duration']} ({msg['duration_min']:.1f} min)`\n"
+            f"*Amount:* `{msg['amount']:.8f}`\n"
+            f"*Open Rate:* `{msg['open_rate']:.8f}`\n")
 
-        message = ("{emoji} *{exchange}:* Selling {pair} (#{trade_id})\n"
-                   "*Profit:* `{profit_percent:.2f}%{profit_extra}`\n"
-                   "*Sell Reason:* `{sell_reason}`\n"
-                   "*Duration:* `{duration} ({duration_min:.1f} min)`\n"
-                   "*Amount:* `{amount:.8f}`\n"
-                   "*Open Rate:* `{open_rate:.8f}`\n"
-                   "*Current Rate:* `{current_rate:.8f}`\n"
-                   "*Close Rate:* `{limit:.8f}`").format(**msg)
+        if msg['type'] == RPCMessageType.SELL:
+            message += (f"*Current Rate:* `{msg['current_rate']:.8f}`\n"
+                        f"*Close Rate:* `{msg['limit']:.8f}`")
+
+        elif msg['type'] == RPCMessageType.SELL_FILL:
+            message += f"*Close Rate:* `{msg['close_rate']:.8f}`"
 
         return message
 
     def compose_message(self, msg: Dict[str, Any], msg_type: RPCMessageType) -> str:
-
-        if msg_type == RPCMessageType.BUY:
+        if msg_type in [RPCMessageType.BUY, RPCMessageType.BUY_FILL]:
             message = self._format_buy_msg(msg)
 
+        elif msg_type in [RPCMessageType.SELL, RPCMessageType.SELL_FILL]:
+            message = self._format_sell_msg(msg)
+
         elif msg_type in (RPCMessageType.BUY_CANCEL, RPCMessageType.SELL_CANCEL):
             msg['message_side'] = 'buy' if msg_type == RPCMessageType.BUY_CANCEL else 'sell'
             message = ("\N{WARNING SIGN} *{exchange}:* "
                        "Cancelling open {message_side} Order for {pair} (#{trade_id}). "
                        "Reason: {reason}.".format(**msg))
 
-        elif msg_type == RPCMessageType.BUY_FILL:
-            message = ("\N{LARGE CIRCLE} *{exchange}:* "
-                       "Buy order for {pair} (#{trade_id}) filled "
-                       "for {open_rate}.".format(**msg))
-        elif msg_type == RPCMessageType.SELL_FILL:
-            message = ("\N{LARGE CIRCLE} *{exchange}:* "
-                       "Sell order for {pair} (#{trade_id}) filled "
-                       "for {close_rate}.".format(**msg))
-        elif msg_type == RPCMessageType.SELL:
-            message = self._format_sell_msg(msg)
         elif msg_type == RPCMessageType.PROTECTION_TRIGGER:
             message = (
                 "*Protection* triggered due to {reason}. "
                 "`{pair}` will be locked until `{lock_end_time}`."
             ).format(**msg)
+
         elif msg_type == RPCMessageType.PROTECTION_TRIGGER_GLOBAL:
             message = (
                 "*Protection* triggered due to {reason}. "
                 "*All pairs* will be locked until `{lock_end_time}`."
             ).format(**msg)
+
         elif msg_type == RPCMessageType.STATUS:
             message = '*Status:* `{status}`'.format(**msg)
 
@@ -344,7 +364,7 @@ class Telegram(RPCHandler):
         elif float(msg['profit_percent']) >= 0.0:
             return "\N{EIGHT SPOKED ASTERISK}"
         elif msg['sell_reason'] == "stop_loss":
-            return"\N{WARNING SIGN}"
+            return "\N{WARNING SIGN}"
         else:
             return "\N{CROSS MARK}"
 
@@ -384,19 +404,19 @@ class Telegram(RPCHandler):
                     "*Close Rate:* `{close_rate}`" if r['close_rate'] else "",
                     "*Current Rate:* `{current_rate:.8f}`",
                     ("*Current Profit:* " if r['is_open'] else "*Close Profit: *")
-                    + "`{profit_pct:.2f}%`",
+                    + "`{profit_ratio:.2%}`",
                 ]
                 if (r['stop_loss_abs'] != r['initial_stop_loss_abs']
-                        and r['initial_stop_loss_pct'] is not None):
+                        and r['initial_stop_loss_ratio'] is not None):
                     # Adding initial stoploss only if it is different from stoploss
                     lines.append("*Initial Stoploss:* `{initial_stop_loss_abs:.8f}` "
-                                 "`({initial_stop_loss_pct:.2f}%)`")
+                                 "`({initial_stop_loss_ratio:.2%})`")
 
                 # Adding stoploss and stoploss percentage only if it is not None
                 lines.append("*Stoploss:* `{stop_loss_abs:.8f}` " +
-                             ("`({stop_loss_pct:.2f}%)`" if r['stop_loss_pct'] else ""))
+                             ("`({stop_loss_ratio:.2%})`" if r['stop_loss_ratio'] else ""))
                 lines.append("*Stoploss distance:* `{stoploss_current_dist:.8f}` "
-                             "`({stoploss_current_dist_pct:.2f}%)`")
+                             "`({stoploss_current_dist_ratio:.2%})`")
                 if r['open_order']:
                     if r['sell_order_status']:
                         lines.append("*Open Order:* `{open_order}` - `{sell_order_status}`")
@@ -492,6 +512,86 @@ class Telegram(RPCHandler):
         except RPCException as e:
             self._send_msg(str(e))
 
+    @authorized_only
+    def _weekly(self, update: Update, context: CallbackContext) -> None:
+        """
+        Handler for /weekly <n>
+        Returns a weekly profit (in BTC) over the last n weeks.
+        :param bot: telegram bot
+        :param update: message update
+        :return: None
+        """
+        stake_cur = self._config['stake_currency']
+        fiat_disp_cur = self._config.get('fiat_display_currency', '')
+        try:
+            timescale = int(context.args[0]) if context.args else 8
+        except (TypeError, ValueError, IndexError):
+            timescale = 8
+        try:
+            stats = self._rpc._rpc_weekly_profit(
+                timescale,
+                stake_cur,
+                fiat_disp_cur
+            )
+            stats_tab = tabulate(
+                [[week['date'],
+                  f"{round_coin_value(week['abs_profit'], stats['stake_currency'])}",
+                  f"{week['fiat_value']:.3f} {stats['fiat_display_currency']}",
+                  f"{week['trade_count']} trades"] for week in stats['data']],
+                headers=[
+                    'Monday',
+                    f'Profit {stake_cur}',
+                    f'Profit {fiat_disp_cur}',
+                    'Trades',
+                ],
+                tablefmt='simple')
+            message = f'<b>Weekly Profit over the last {timescale} weeks ' \
+                      f'(starting from Monday)</b>:\n<pre>{stats_tab}</pre> '
+            self._send_msg(message, parse_mode=ParseMode.HTML, reload_able=True,
+                           callback_path="update_weekly", query=update.callback_query)
+        except RPCException as e:
+            self._send_msg(str(e))
+
+    @authorized_only
+    def _monthly(self, update: Update, context: CallbackContext) -> None:
+        """
+        Handler for /monthly <n>
+        Returns a monthly profit (in BTC) over the last n months.
+        :param bot: telegram bot
+        :param update: message update
+        :return: None
+        """
+        stake_cur = self._config['stake_currency']
+        fiat_disp_cur = self._config.get('fiat_display_currency', '')
+        try:
+            timescale = int(context.args[0]) if context.args else 6
+        except (TypeError, ValueError, IndexError):
+            timescale = 6
+        try:
+            stats = self._rpc._rpc_monthly_profit(
+                timescale,
+                stake_cur,
+                fiat_disp_cur
+            )
+            stats_tab = tabulate(
+                [[month['date'],
+                  f"{round_coin_value(month['abs_profit'], stats['stake_currency'])}",
+                  f"{month['fiat_value']:.3f} {stats['fiat_display_currency']}",
+                  f"{month['trade_count']} trades"] for month in stats['data']],
+                headers=[
+                    'Month',
+                    f'Profit {stake_cur}',
+                    f'Profit {fiat_disp_cur}',
+                    'Trades',
+                ],
+                tablefmt='simple')
+            message = f'<b>Monthly Profit over the last {timescale} months' \
+                      f'</b>:\n<pre>{stats_tab}</pre> '
+            self._send_msg(message, parse_mode=ParseMode.HTML, reload_able=True,
+                           callback_path="update_monthly", query=update.callback_query)
+        except RPCException as e:
+            self._send_msg(str(e))
+
     @authorized_only
     def _profit(self, update: Update, context: CallbackContext) -> None:
         """
@@ -519,11 +619,11 @@ class Telegram(RPCHandler):
             fiat_disp_cur,
             start_date)
         profit_closed_coin = stats['profit_closed_coin']
-        profit_closed_percent_mean = stats['profit_closed_percent_mean']
+        profit_closed_ratio_mean = stats['profit_closed_ratio_mean']
         profit_closed_percent = stats['profit_closed_percent']
         profit_closed_fiat = stats['profit_closed_fiat']
         profit_all_coin = stats['profit_all_coin']
-        profit_all_percent_mean = stats['profit_all_percent_mean']
+        profit_all_ratio_mean = stats['profit_all_ratio_mean']
         profit_all_percent = stats['profit_all_percent']
         profit_all_fiat = stats['profit_all_fiat']
         trade_count = stats['trade_count']
@@ -531,7 +631,7 @@ class Telegram(RPCHandler):
         latest_trade_date = stats['latest_trade_date']
         avg_duration = stats['avg_duration']
         best_pair = stats['best_pair']
-        best_rate = stats['best_rate']
+        best_pair_profit_ratio = stats['best_pair_profit_ratio']
         if stats['trade_count'] == 0:
             markdown_msg = 'No trades yet.'
         else:
@@ -539,7 +639,7 @@ class Telegram(RPCHandler):
             if stats['closed_trade_count'] > 0:
                 markdown_msg = ("*ROI:* Closed trades\n"
                                 f"∙ `{round_coin_value(profit_closed_coin, stake_cur)} "
-                                f"({profit_closed_percent_mean:.2f}%) "
+                                f"({profit_closed_ratio_mean:.2%}) "
                                 f"({profit_closed_percent} \N{GREEK CAPITAL LETTER SIGMA}%)`\n"
                                 f"∙ `{round_coin_value(profit_closed_fiat, fiat_disp_cur)}`\n")
             else:
@@ -548,7 +648,7 @@ class Telegram(RPCHandler):
             markdown_msg += (
                 f"*ROI:* All trades\n"
                 f"∙ `{round_coin_value(profit_all_coin, stake_cur)} "
-                f"({profit_all_percent_mean:.2f}%) "
+                f"({profit_all_ratio_mean:.2%}) "
                 f"({profit_all_percent} \N{GREEK CAPITAL LETTER SIGMA}%)`\n"
                 f"∙ `{round_coin_value(profit_all_fiat, fiat_disp_cur)}`\n"
                 f"*Total Trade Count:* `{trade_count}`\n"
@@ -559,7 +659,7 @@ class Telegram(RPCHandler):
             )
             if stats['closed_trade_count'] > 0:
                 markdown_msg += (f"\n*Avg. Duration:* `{avg_duration}`\n"
-                                 f"*Best Performing:* `{best_pair}: {best_rate:.2f}%`")
+                                 f"*Best Performing:* `{best_pair}: {best_pair_profit_ratio:.2%}`")
         self._send_msg(markdown_msg, reload_able=True, callback_path="update_profit",
                        query=update.callback_query)
 
@@ -588,10 +688,16 @@ class Telegram(RPCHandler):
                 count['losses']
             ] for reason, count in stats['sell_reasons'].items()
         ]
-        sell_reasons_msg = tabulate(
-            sell_reasons_tabulate,
-            headers=['Sell Reason', 'Sells', 'Wins', 'Losses']
-        )
+        sell_reasons_msg = 'No trades yet.'
+        for reason in chunks(sell_reasons_tabulate, 25):
+            sell_reasons_msg = tabulate(
+                reason,
+                headers=['Sell Reason', 'Sells', 'Wins', 'Losses']
+            )
+            if len(sell_reasons_tabulate) > 25:
+                self._send_msg(sell_reasons_msg, ParseMode.MARKDOWN)
+                sell_reasons_msg = ''
+
         durations = stats['durations']
         duration_msg = tabulate(
             [
@@ -662,10 +768,10 @@ class Telegram(RPCHandler):
             output += ("\n*Estimated Value*:\n"
                        f"\t`{result['stake']}: "
                        f"{round_coin_value(result['total'], result['stake'], False)}`"
-                       f" `({result['starting_capital_pct']}%)`\n"
+                       f" `({result['starting_capital_ratio']:.2%})`\n"
                        f"\t`{result['symbol']}: "
                        f"{round_coin_value(result['value'], result['symbol'], False)}`"
-                       f" `({result['starting_capital_fiat_pct']}%)`\n")
+                       f" `({result['starting_capital_fiat_ratio']:.2%})`\n")
             self._send_msg(output, reload_able=True, callback_path="update_balance",
                            query=update.callback_query)
         except RPCException as e:
@@ -800,7 +906,7 @@ class Telegram(RPCHandler):
             trades_tab = tabulate(
                 [[arrow.get(trade['close_date']).humanize(),
                   trade['pair'] + " (#" + str(trade['trade_id']) + ")",
-                  f"{(100 * trade['close_profit']):.2f}% ({trade['close_profit_abs']})"]
+                  f"{(trade['close_profit']):.2%} ({trade['close_profit_abs']})"]
                  for trade in trades['trades']],
                 headers=[
                     'Close Date',
@@ -852,7 +958,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_ratio']:.2%}) "
                     f"({trade['count']})</code>\n")
 
                 if len(output + stat_line) >= MAX_TELEGRAM_MESSAGE_LENGTH:
@@ -867,6 +973,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_ratio']:.2%}) "
+                    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_ratio']:.2%}) "
+                    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']:.2%}) "
+                    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:
         """
@@ -952,22 +1163,28 @@ class Telegram(RPCHandler):
         Handler for /blacklist
         Shows the currently active blacklist
         """
-        try:
+        self.send_blacklist_msg(self._rpc._rpc_blacklist(context.args))
 
-            blacklist = self._rpc._rpc_blacklist(context.args)
-            errmsgs = []
-            for pair, error in blacklist['errors'].items():
-                errmsgs.append(f"Error adding `{pair}` to blacklist: `{error['error_msg']}`")
-            if errmsgs:
-                self._send_msg('\n'.join(errmsgs))
+    def send_blacklist_msg(self, blacklist: Dict):
+        errmsgs = []
+        for pair, error in blacklist['errors'].items():
+            errmsgs.append(f"Error adding `{pair}` to blacklist: `{error['error_msg']}`")
+        if errmsgs:
+            self._send_msg('\n'.join(errmsgs))
 
-            message = f"Blacklist contains {blacklist['length']} pairs\n"
-            message += f"`{', '.join(blacklist['blacklist'])}`"
+        message = f"Blacklist contains {blacklist['length']} pairs\n"
+        message += f"`{', '.join(blacklist['blacklist'])}`"
 
-            logger.debug(message)
-            self._send_msg(message)
-        except RPCException as e:
-            self._send_msg(str(e))
+        logger.debug(message)
+        self._send_msg(message)
+
+    @authorized_only
+    def _blacklist_delete(self, update: Update, context: CallbackContext) -> None:
+        """
+        Handler for /bl_delete
+        Deletes pair(s) from current blacklist
+        """
+        self.send_blacklist_msg(self._rpc._rpc_blacklist_delete(context.args or []))
 
     @authorized_only
     def _logs(self, update: Update, context: CallbackContext) -> None:
@@ -1035,41 +1252,58 @@ class Telegram(RPCHandler):
         forcebuy_text = ("*/forcebuy <pair> [<rate>]:* `Instantly buys the given pair. "
                          "Optionally takes a rate at which to buy "
                          "(only applies to limit orders).` \n")
-        message = ("*/start:* `Starts the trader`\n"
-                   "*/stop:* `Stops the trader`\n"
-                   "*/status <trade_id>|[table]:* `Lists all open trades`\n"
-                   "         *<trade_id> :* `Lists one or more specific trades.`\n"
-                   "                        `Separate multiple <trade_id> with a blank space.`\n"
-                   "         *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"
-                   "*/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"
-                   "*/forcesell <trade_id>|all:* `Instantly sells the given trade or all trades, "
-                   "regardless of profit`\n"
-                   f"{forcebuy_text if self._config.get('forcebuy_enable', False) else ''}"
-                   "*/delete <trade_id>:* `Instantly delete the given trade in the database`\n"
-                   "*/performance:* `Show performance of each finished trade grouped by pair`\n"
-                   "*/daily <n>:* `Shows profit or loss per day, over the last n days`\n"
-                   "*/stats:* `Shows Wins / losses by Sell reason as well as "
-                   "Avg. holding durationsfor buys and sells.`\n"
-                   "*/count:* `Show number of active trades compared to allowed number of trades`\n"
-                   "*/locks:* `Show currently locked pairs`\n"
-                   "*/unlock <pair|id>:* `Unlock this Pair (or this lock id if it's numeric)`\n"
-                   "*/balance:* `Show account balance per currency`\n"
-                   "*/stopbuy:* `Stops buying, but handles open trades gracefully` \n"
-                   "*/reload_config:* `Reload configuration file` \n"
-                   "*/show_config:* `Show running configuration` \n"
-                   "*/logs [limit]:* `Show latest logs - defaults to 10` \n"
-                   "*/whitelist:* `Show current whitelist` \n"
-                   "*/blacklist [pair]:* `Show current blacklist, or adds one or more pairs "
-                   "to the blacklist.` \n"
-                   "*/edge:* `Shows validated pairs by Edge if it is enabled` \n"
-                   "*/help:* `This help message`\n"
-                   "*/version:* `Show version`")
+        message = (
+            "_BotControl_\n"
+            "------------\n"
+            "*/start:* `Starts the trader`\n"
+            "*/stop:* Stops the trader\n"
+            "*/stopbuy:* `Stops buying, but handles open trades gracefully` \n"
+            "*/forcesell <trade_id>|all:* `Instantly sells the given trade or all trades, "
+            "regardless of profit`\n"
+            f"{forcebuy_text if self._config.get('forcebuy_enable', False) else ''}"
+            "*/delete <trade_id>:* `Instantly delete the given trade in the database`\n"
+            "*/whitelist:* `Show current whitelist` \n"
+            "*/blacklist [pair]:* `Show current blacklist, or adds one or more pairs "
+            "to the blacklist.` \n"
+            "*/blacklist_delete [pairs]| /bl_delete [pairs]:* "
+            "`Delete pair / pattern from blacklist. Will reset on reload_conf.` \n"
+            "*/reload_config:* `Reload configuration file` \n"
+            "*/unlock <pair|id>:* `Unlock this Pair (or this lock id if it's numeric)`\n"
 
-        self._send_msg(message)
+            "_Current state_\n"
+            "------------\n"
+            "*/show_config:* `Show running configuration` \n"
+            "*/locks:* `Show currently locked pairs`\n"
+            "*/balance:* `Show account balance per currency`\n"
+            "*/logs [limit]:* `Show latest logs - defaults to 10` \n"
+            "*/count:* `Show number of active trades compared to allowed number of trades`\n"
+            "*/edge:* `Shows validated pairs by Edge if it is enabled` \n"
+
+            "_Statistics_\n"
+            "------------\n"
+            "*/status <trade_id>|[table]:* `Lists all open trades`\n"
+            "         *<trade_id> :* `Lists one or more specific trades.`\n"
+            "                        `Separate multiple <trade_id> with a blank space.`\n"
+            "         *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"
+            "*/performance:* `Show performance of each finished trade grouped by pair`\n"
+            "*/daily <n>:* `Shows profit or loss per day, over the last n days`\n"
+            "*/weekly <n>:* `Shows statistics per week, over the last n weeks`\n"
+            "*/monthly <n>:* `Shows statistics per month, over the last n months`\n"
+            "*/stats:* `Shows Wins / losses by Sell reason as well as "
+            "Avg. holding durationsfor buys and sells.`\n"
+            "*/help:* `This help message`\n"
+            "*/version:* `Show version`"
+            )
+
+        self._send_msg(message, parse_mode=ParseMode.MARKDOWN)
 
     @authorized_only
     def _version(self, update: Update, context: CallbackContext) -> None:
@@ -1080,7 +1314,12 @@ class Telegram(RPCHandler):
         :param update: message update
         :return: None
         """
-        self._send_msg('*Version:* `{}`'.format(__version__))
+        strategy_version = self._rpc._freqtrade.strategy.version()
+        version_string = f'*Version:* `{__version__}`'
+        if strategy_version is not None:
+            version_string += f', *Strategy version: * `{strategy_version}`'
+
+        self._send_msg(version_string)
 
     @authorized_only
     def _show_config(self, update: Update, context: CallbackContext) -> None:

freqtrade/rpc/webhook.py

@@ -2,6 +2,7 @@
 This module manages webhook communication
 """
 import logging
+import time
 from typing import Any, Dict
 
 from requests import RequestException, post
@@ -28,12 +29,9 @@ class Webhook(RPCHandler):
         super().__init__(rpc, config)
 
         self._url = self._config['webhook']['url']
-
         self._format = self._config['webhook'].get('format', 'form')
-
-        if self._format != 'form' and self._format != 'json':
-            raise NotImplementedError('Unknown webhook format `{}`, possible values are '
-                                      '`form` (default) and `json`'.format(self._format))
+        self._retries = self._config['webhook'].get('retries', 0)
+        self._retry_delay = self._config['webhook'].get('retry_delay', 0.1)
 
     def cleanup(self) -> None:
         """
@@ -77,13 +75,30 @@ class Webhook(RPCHandler):
     def _send_msg(self, payload: dict) -> None:
         """do the actual call to the webhook"""
 
-        try:
-            if self._format == 'form':
-                post(self._url, data=payload)
-            elif self._format == 'json':
-                post(self._url, json=payload)
-            else:
-                raise NotImplementedError('Unknown format: {}'.format(self._format))
+        success = False
+        attempts = 0
+        while not success and attempts <= self._retries:
+            if attempts:
+                if self._retry_delay:
+                    time.sleep(self._retry_delay)
+                logger.info("Retrying webhook...")
 
-        except RequestException as exc:
-            logger.warning("Could not call webhook url. Exception: %s", exc)
+            attempts += 1
+
+            try:
+                if self._format == 'form':
+                    response = post(self._url, data=payload)
+                elif self._format == 'json':
+                    response = post(self._url, json=payload)
+                elif self._format == 'raw':
+                    response = post(self._url, data=payload['data'],
+                                    headers={'Content-Type': 'text/plain'})
+                else:
+                    raise NotImplementedError('Unknown format: {}'.format(self._format))
+
+                # Throw a RequestException if the post was not successful
+                response.raise_for_status()
+                success = True
+
+            except RequestException as exc:
+                logger.warning("Could not call webhook url. Exception: %s", exc)

freqtrade/strategy/hyper.py

@@ -292,7 +292,7 @@ class BooleanParameter(CategoricalParameter):
                          load=load, **kwargs)
 
 
-class HyperStrategyMixin(object):
+class HyperStrategyMixin:
     """
     A helper base class which allows HyperOptAuto class to reuse implementations of buy/sell
      strategy logic.

freqtrade/strategy/informative_decorator.py

@@ -80,12 +80,11 @@ def _create_and_merge_informative_pair(strategy, dataframe: DataFrame, metadata:
         # Not specifying an asset will define informative dataframe for current pair.
         asset = metadata['pair']
 
-    if '/' in asset:
-        base, quote = asset.split('/')
-    else:
-        # When futures are supported this may need reevaluation.
-        # base, quote = asset, ''
-        raise OperationalException('Not implemented.')
+    market = strategy.dp.market(asset)
+    if market is None:
+        raise OperationalException(f'Market {asset} is not available.')
+    base = market['base']
+    quote = market['quote']
 
     # Default format. This optimizes for the common case: informative pairs using same stake
     # currency. When quote currency matches stake currency, column name will omit base currency.

freqtrade/strategy/interface.py

@@ -30,7 +30,7 @@ logger = logging.getLogger(__name__)
 CUSTOM_SELL_MAX_LENGTH = 64
 
 
-class SellCheckTuple(object):
+class SellCheckTuple:
     """
     NamedTuple for Sell type + reason
     """
@@ -394,6 +394,12 @@ class IStrategy(ABC, HyperStrategyMixin):
         """
         return []
 
+    def version(self) -> Optional[str]:
+        """
+        Returns version of the strategy.
+        """
+        return None
+
 ###
 # END - Intended to be overridden by strategy
 ###
@@ -443,6 +449,15 @@ class IStrategy(ABC, HyperStrategyMixin):
         """
         PairLocks.unlock_pair(pair, datetime.now(timezone.utc))
 
+    def unlock_reason(self, reason: str) -> None:
+        """
+        Unlocks all pairs previously locked using lock_pair with specified reason.
+        Not used by freqtrade itself, but intended to be used if users lock pairs
+        manually from within the strategy, to allow an easy way to unlock pairs.
+        :param reason: Unlock pairs to allow trading again
+        """
+        PairLocks.unlock_reason(reason, datetime.now(timezone.utc))
+
     def is_pair_locked(self, pair: str, candle_date: datetime = None) -> bool:
         """
         Checks if a pair is currently locked
@@ -500,6 +515,7 @@ class IStrategy(ABC, HyperStrategyMixin):
             dataframe['buy'] = 0
             dataframe['sell'] = 0
             dataframe['buy_tag'] = None
+            dataframe['exit_tag'] = None
 
         # Other Defs in strategy that want to be called every loop here
         # twitter_sell = self.watch_twitter_feed(dataframe, metadata)
@@ -577,7 +593,7 @@ class IStrategy(ABC, HyperStrategyMixin):
         pair: str,
         timeframe: str,
         dataframe: DataFrame
-    ) -> Tuple[bool, bool, Optional[str]]:
+    ) -> Tuple[bool, bool, Optional[str], Optional[str]]:
         """
         Calculates current signal based based on the buy / sell columns of the dataframe.
         Used by Bot to get the signal to buy or sell
@@ -588,7 +604,7 @@ class IStrategy(ABC, HyperStrategyMixin):
         """
         if not isinstance(dataframe, DataFrame) or dataframe.empty:
             logger.warning(f'Empty candle (OHLCV) data for pair {pair}')
-            return False, False, None
+            return False, False, None, None
 
         latest_date = dataframe['date'].max()
         latest = dataframe.loc[dataframe['date'] == latest_date].iloc[-1]
@@ -603,7 +619,7 @@ class IStrategy(ABC, HyperStrategyMixin):
                 'Outdated history for pair %s. Last tick is %s minutes old',
                 pair, int((arrow.utcnow() - latest_date).total_seconds() // 60)
             )
-            return False, False, None
+            return False, False, None, None
 
         buy = latest[SignalType.BUY.value] == 1
 
@@ -612,6 +628,7 @@ class IStrategy(ABC, HyperStrategyMixin):
             sell = latest[SignalType.SELL.value] == 1
 
         buy_tag = latest.get(SignalTagType.BUY_TAG.value, None)
+        exit_tag = latest.get(SignalTagType.EXIT_TAG.value, None)
 
         logger.debug('trigger: %s (pair=%s) buy=%s sell=%s',
                      latest['date'], pair, str(buy), str(sell))
@@ -620,8 +637,8 @@ class IStrategy(ABC, HyperStrategyMixin):
                                       current_time=datetime.now(timezone.utc),
                                       timeframe_seconds=timeframe_seconds,
                                       buy=buy):
-            return False, sell, buy_tag
-        return buy, sell, buy_tag
+            return False, sell, buy_tag, exit_tag
+        return buy, sell, buy_tag, exit_tag
 
     def ignore_expired_candle(self, latest_date: datetime, current_time: datetime,
                               timeframe_seconds: int, buy: bool):
@@ -754,7 +771,7 @@ class IStrategy(ABC, HyperStrategyMixin):
                 if self.trailing_stop_positive is not None and high_profit > sl_offset:
                     stop_loss_value = self.trailing_stop_positive
                     logger.debug(f"{trade.pair} - Using positive stoploss: {stop_loss_value} "
-                                 f"offset: {sl_offset:.4g} profit: {current_profit:.4f}%")
+                                 f"offset: {sl_offset:.4g} profit: {current_profit:.2%}")
 
                 trade.adjust_stop_loss(high or current_rate, stop_loss_value)
 

freqtrade/strategy/strategy_wrapper.py

@@ -1,4 +1,5 @@
 import logging
+from copy import deepcopy
 
 from freqtrade.exceptions import StrategyError
 
@@ -14,6 +15,9 @@ def strategy_safe_wrapper(f, message: str = "", default_retval=None, supress_err
     """
     def wrapper(*args, **kwargs):
         try:
+            if 'trade' in kwargs:
+                # Protect accidental modifications from within the strategy
+                kwargs['trade'] = deepcopy(kwargs['trade'])
             return f(*args, **kwargs)
         except ValueError as error:
             logger.warning(

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": {

freqtrade/templates/base_strategy.py.j2

@@ -12,6 +12,7 @@ from freqtrade.strategy import (BooleanParameter, CategoricalParameter, DecimalP
 # --------------------------------
 # Add your lib to import here
 import talib.abstract as ta
+import pandas_ta as pta
 import freqtrade.vendor.qtpylib.indicators as qtpylib
 
 
@@ -36,6 +37,9 @@ class {{ strategy }}(IStrategy):
     # Check the documentation or the Sample strategy to get the latest version.
     INTERFACE_VERSION = 2
 
+    # Optimal timeframe for the strategy.
+    timeframe = '5m'
+
     # Minimal ROI designed for the strategy.
     # This attribute will be overridden if the config file contains "minimal_roi".
     minimal_roi = {
@@ -54,9 +58,6 @@ class {{ strategy }}(IStrategy):
     # trailing_stop_positive = 0.01
     # trailing_stop_positive_offset = 0.0  # Disabled / not configured
 
-    # Optimal timeframe for the strategy.
-    timeframe = '5m'
-
     # Run "populate_indicators()" only for new candle.
     process_only_new_candles = False
 
@@ -68,6 +69,10 @@ class {{ strategy }}(IStrategy):
     # Number of candles the strategy requires before producing valid signals
     startup_candle_count: int = 30
 
+    # Strategy parameters
+    buy_rsi = IntParameter(10, 40, default=30, space="buy")
+    sell_rsi = IntParameter(60, 90, default=70, space="sell")
+
     # Optional order type mapping.
     order_types = {
         'buy': 'limit',
@@ -82,6 +87,7 @@ class {{ strategy }}(IStrategy):
         'sell': 'gtc'
     }
     {{ plot_config | indent(4) }}
+
     def informative_pairs(self):
         """
         Define additional, informative pair/interval combinations to be cached from the exchange.

freqtrade/templates/strategy_analysis_example.ipynb

@@ -79,7 +79,9 @@
    "source": [
     "# Load strategy using values set above\n",
     "from freqtrade.resolvers import StrategyResolver\n",
+    "from freqtrade.data.dataprovider import DataProvider\n",
     "strategy = StrategyResolver.load_strategy(config)\n",
+    "strategy.dp = DataProvider(config, None, None)\n",
     "\n",
     "# Generate buy/sell signals using strategy\n",
     "df = strategy.analyze_ticker(candles, {'pair': pair})\n",

freqtrade/templates/subtemplates/buy_trend_full.j2

@@ -1,3 +1,3 @@
-(qtpylib.crossed_above(dataframe['rsi'], 30)) &  # Signal: RSI crosses above 30
+(qtpylib.crossed_above(dataframe['rsi'], self.buy_rsi.value)) &  # Signal: RSI crosses above buy_rsi
 (dataframe['tema'] <= dataframe['bb_middleband']) &  # Guard: tema below BB middle
 (dataframe['tema'] > dataframe['tema'].shift(1)) &  # Guard: tema is raising

freqtrade/templates/subtemplates/buy_trend_minimal.j2

@@ -1 +1 @@
-(qtpylib.crossed_above(dataframe['rsi'], 30)) &  # Signal: RSI crosses above 30
+(qtpylib.crossed_above(dataframe['rsi'], self.buy_rsi.value)) &  # Signal: RSI crosses above buy_rsi