471 changed files with 15689 additions and 80938 deletions
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@ -11,14 +11,12 @@
    "mounts": [
        "source=freqtrade-bashhistory,target=/home/ftuser/commandhistory,type=volume"
    ],
-    "workspaceMount": "source=${localWorkspaceFolder},target=/workspaces/freqtrade,type=bind,consistency=cached",
    // Uncomment to connect as a non-root user if you've added one. See https://aka.ms/vscode-remote/containers/non-root.
    "remoteUser": "ftuser",

-    "onCreateCommand": "pip install --user -e .",
    "postCreateCommand": "freqtrade create-userdir --userdir user_data/",

-    "workspaceFolder": "/workspaces/freqtrade",
+    "workspaceFolder": "/freqtrade/",

    "settings": {
        "terminal.integrated.shell.linux": "/bin/bash",
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -20,7 +20,7 @@ Please do not use bug reports to request new features.
  * Operating system: ____
  * Python Version: _____ (`python -V`)
  * CCXT version: _____ (`pip freeze | grep ccxt`)
-  * Freqtrade Version: ____ (`freqtrade -V` or `docker compose run --rm freqtrade -V` for Freqtrade running in docker)
+  * Freqtrade Version: ____ (`freqtrade -V` or `docker-compose run --rm freqtrade -V` for Freqtrade running in docker)
  
 Note: All issues other than enhancement requests will be closed without further comment if the above template is deleted or not filled out.

--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@ -18,9 +18,10 @@ Have you search for this feature before requesting it? It's highly likely that a
  * Operating system: ____
  * Python Version: _____ (`python -V`)
  * CCXT version: _____ (`pip freeze | grep ccxt`)
-  * Freqtrade Version: ____ (`freqtrade -V` or `docker compose run --rm freqtrade -V` for Freqtrade running in docker)
+  * Freqtrade Version: ____ (`freqtrade -V` or `docker-compose run --rm freqtrade -V` for Freqtrade running in docker)


 ## Describe the enhancement

 *Explain the enhancement you would like*
+
--- a/.github/ISSUE_TEMPLATE/question.md
+++ b/.github/ISSUE_TEMPLATE/question.md
@ -18,7 +18,7 @@ Please do not use the question template to report bugs or to request new feature
  * Operating system: ____
  * Python Version: _____ (`python -V`)
  * CCXT version: _____ (`pip freeze | grep ccxt`)
-  * Freqtrade Version: ____ (`freqtrade -V` or `docker compose run --rm freqtrade -V` for Freqtrade running in docker)
+  * Freqtrade Version: ____ (`freqtrade -V` or `docker-compose run --rm freqtrade -V` for Freqtrade running in docker)
  
 ## Your question

--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@ -1,9 +1,9 @@
-<!-- Thank you for sending your pull request. But first, have you included
+Thank you for sending your pull request. But first, have you included
 unit tests, and is your code PEP8 conformant? [More details](https://github.com/freqtrade/freqtrade/blob/develop/CONTRIBUTING.md)
-->
+
 ## Summary

-<!-- Explain in one sentence the goal of this PR -->
+Explain in one sentence the goal of this PR

 Solve the issue: #___

@ -14,4 +14,4 @@ Solve the issue: #___

 ## What's new?

-<!-- Explain in details what this PR solve or improve. You can include visuals. -->
+*Explain in details what this PR solve or improve. You can include visuals.* 
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -13,37 +13,32 @@ on:
  schedule:
    - cron:  '0 5 * * 4'

-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-permissions:
-  repository-projects: read
 jobs:
  build_linux:

    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
-        os: [ ubuntu-20.04, ubuntu-22.04 ]
-        python-version: ["3.8", "3.9", "3.10", "3.11"]
+        os: [ ubuntu-18.04, ubuntu-20.04 ]
+        python-version: ["3.8", "3.9", "3.10"]

    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v2

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

    - name: Cache_dependencies
-      uses: actions/cache@v3
+      uses: actions/cache@v2
      id: cache
      with:
        path: ~/dependencies/
        key: ${{ runner.os }}-dependencies

    - name: pip cache (linux)
-      uses: actions/cache@v3
+      uses: actions/cache@v2
      if: runner.os == 'Linux'
      with:
        path: ~/.cache/pip
@ -67,9 +62,15 @@ jobs:
    - name: Tests
      run: |
        pytest --random-order --cov=freqtrade --cov-config=.coveragerc
+      if: matrix.python-version != '3.9'
+
+    - name: Tests incl. ccxt compatibility tests
+      run: |
+        pytest --random-order --cov=freqtrade --cov-config=.coveragerc --longrun
+      if: matrix.python-version == '3.9'

    - name: Coveralls
-      if: (runner.os == 'Linux' && matrix.python-version == '3.10' && matrix.os == 'ubuntu-22.04')
+      if: (runner.os == 'Linux' && matrix.python-version == '3.8')
      env:
        # Coveralls token. Not used as secret due to github not providing secrets to forked repositories
        COVERALLS_REPO_TOKEN: 6D1m0xupS3FgutfuGao8keFf9Hc0FpIXu
@ -77,31 +78,29 @@ jobs:
        # Allow failure for coveralls
        coveralls || true

-    - name: Backtesting (multi)
+    - name: Backtesting
      run: |
        cp config_examples/config_bittrex.example.json config.json
        freqtrade create-userdir --userdir user_data
-        freqtrade new-strategy -s AwesomeStrategy
-        freqtrade new-strategy -s AwesomeStrategyMin --template minimal
-        freqtrade backtesting --datadir tests/testdata --strategy-list AwesomeStrategy AwesomeStrategyMin -i 5m
+        freqtrade backtesting --datadir tests/testdata --strategy SampleStrategy

    - name: Hyperopt
      run: |
        cp config_examples/config_bittrex.example.json config.json
        freqtrade create-userdir --userdir user_data
-        freqtrade hyperopt --datadir tests/testdata -e 6 --strategy SampleStrategy --hyperopt-loss SharpeHyperOptLossDaily --print-all
+        freqtrade hyperopt --datadir tests/testdata -e 5 --strategy SampleStrategy --hyperopt-loss SharpeHyperOptLossDaily --print-all
+
+    - name: Flake8
+      run: |
+        flake8

    - name: Sort imports (isort)
      run: |
        isort --check .

-    - name: Run Ruff
-      run: |
-        ruff check --format=github .
-
    - name: Mypy
      run: |
-        mypy freqtrade scripts tests
+        mypy freqtrade scripts

    - name: Discord notification
      uses: rjstone/discord-webhook-notify@v1
@ -116,25 +115,25 @@ jobs:
    strategy:
      matrix:
        os: [ macos-latest ]
-        python-version: ["3.8", "3.9", "3.10", "3.11"]
+        python-version: ["3.8", "3.9", "3.10"]

    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v2

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

    - name: Cache_dependencies
-      uses: actions/cache@v3
+      uses: actions/cache@v2
      id: cache
      with:
        path: ~/dependencies/
        key: ${{ runner.os }}-dependencies

    - name: pip cache (macOS)
-      uses: actions/cache@v3
+      uses: actions/cache@v2
      if: runner.os == 'macOS'
      with:
        path: ~/Library/Caches/pip
@ -149,19 +148,6 @@ jobs:
      if: runner.os == 'macOS'
      run: |
        brew update
-        # homebrew fails to update python due to unlinking failures
-        # https://github.com/actions/runner-images/issues/6817
-        rm /usr/local/bin/2to3 || true
-        rm /usr/local/bin/2to3-3.11 || true
-        rm /usr/local/bin/idle3 || true
-        rm /usr/local/bin/idle3.11 || true
-        rm /usr/local/bin/pydoc3 || true
-        rm /usr/local/bin/pydoc3.11 || true
-        rm /usr/local/bin/python3 || true
-        rm /usr/local/bin/python3.11 || true
-        rm /usr/local/bin/python3-config || true
-        rm /usr/local/bin/python3.11-config || true
-
        brew install hdf5 c-blosc
        python -m pip install --upgrade pip wheel
        export LD_LIBRARY_PATH=${HOME}/dependencies/lib:$LD_LIBRARY_PATH
@ -172,14 +158,22 @@ jobs:

    - name: Tests
      run: |
-        pytest --random-order
+        pytest --random-order --cov=freqtrade --cov-config=.coveragerc
+
+    - name: Coveralls
+      if: (runner.os == 'Linux' && matrix.python-version == '3.8')
+      env:
+        # Coveralls token. Not used as secret due to github not providing secrets to forked repositories
+        COVERALLS_REPO_TOKEN: 6D1m0xupS3FgutfuGao8keFf9Hc0FpIXu
+      run: |
+        # Allow failure for coveralls
+        coveralls -v  || true

    - name: Backtesting
      run: |
        cp config_examples/config_bittrex.example.json config.json
        freqtrade create-userdir --userdir user_data
-        freqtrade new-strategy -s AwesomeStrategyAdv --template advanced
-        freqtrade backtesting --datadir tests/testdata --strategy AwesomeStrategyAdv
+        freqtrade backtesting --datadir tests/testdata --strategy SampleStrategy

    - name: Hyperopt
      run: |
@ -187,14 +181,14 @@ jobs:
        freqtrade create-userdir --userdir user_data
        freqtrade hyperopt --datadir tests/testdata -e 5 --strategy SampleStrategy --hyperopt-loss SharpeHyperOptLossDaily --print-all

+    - name: Flake8
+      run: |
+        flake8
+
    - name: Sort imports (isort)
      run: |
        isort --check .

-    - name: Run Ruff
-      run: |
-        ruff check --format=github .
-
    - name: Mypy
      run: |
        mypy freqtrade scripts
@ -213,18 +207,18 @@ jobs:
    strategy:
      matrix:
        os: [ windows-latest ]
-        python-version: ["3.8", "3.9", "3.10", "3.11"]
+        python-version: ["3.8", "3.9", "3.10"]

    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v2

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

    - name: Pip cache (Windows)
-      uses: actions/cache@v3
+      uses: actions/cache@preview
      with:
        path: ~\AppData\Local\pip\Cache
        key: ${{ matrix.os }}-${{ matrix.python-version }}-pip
@ -235,7 +229,7 @@ jobs:

    - name: Tests
      run: |
-        pytest --random-order
+        pytest --random-order --cov=freqtrade --cov-config=.coveragerc

    - name: Backtesting
      run: |
@ -249,13 +243,13 @@ jobs:
        freqtrade create-userdir --userdir user_data
        freqtrade hyperopt --datadir tests/testdata -e 5 --strategy SampleStrategy --hyperopt-loss SharpeHyperOptLossDaily --print-all

-    - name: Run Ruff
+    - name: Flake8
      run: |
-        ruff check --format=github .
+        flake8

    - name: Mypy
      run: |
-        mypy freqtrade scripts tests
+        mypy freqtrade scripts

    - name: Discord notification
      uses: rjstone/discord-webhook-notify@v1
@ -265,44 +259,19 @@ jobs:
          details: Test Failed
          webhookUrl: ${{ secrets.DISCORD_WEBHOOK }}

-  mypy_version_check:
-    runs-on: ubuntu-22.04
-    steps:
-    - uses: actions/checkout@v3
-
-    - name: Set up Python
-      uses: actions/setup-python@v4
-      with:
-        python-version: "3.10"
-
-    - name: pre-commit dependencies
-      run: |
-        pip install pyaml
-        python build_helpers/pre_commit_update.py
-
-  pre-commit:
-    runs-on: ubuntu-22.04
-    steps:
-    - uses: actions/checkout@v3
-
-    - uses: actions/setup-python@v4
-      with:
-        python-version: "3.10"
-    - uses: pre-commit/action@v3.0.0
-
  docs_check:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-20.04
    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v2

    - name: Documentation syntax
      run: |
        ./tests/test_docs.sh

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

    - name: Documentation build
      run: |
@ -318,70 +287,19 @@ jobs:
          details: Freqtrade doc test failed!
          webhookUrl: ${{ secrets.DISCORD_WEBHOOK }}

-
-  build_linux_online:
-    # Run pytest with "live" checks
-    runs-on: ubuntu-22.04
+  cleanup-prior-runs:
+    runs-on: ubuntu-20.04
    steps:
-    - uses: actions/checkout@v3
-
-    - name: Set up Python
-      uses: actions/setup-python@v4
-      with:
-        python-version: "3.9"
-
-    - name: Cache_dependencies
-      uses: actions/cache@v3
-      id: cache
-      with:
-        path: ~/dependencies/
-        key: ${{ runner.os }}-dependencies
-
-    - name: pip cache (linux)
-      uses: actions/cache@v3
-      if: runner.os == 'Linux'
-      with:
-        path: ~/.cache/pip
-        key: test-${{ matrix.os }}-${{ matrix.python-version }}-pip
-
-    - name: TA binary *nix
-      if: steps.cache.outputs.cache-hit != 'true'
-      run: |
-        cd build_helpers && ./install_ta-lib.sh ${HOME}/dependencies/; cd ..
-
-    - name: Installation - *nix
-      if: runner.os == 'Linux'
-      run: |
-        python -m pip install --upgrade pip wheel
-        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 .
-
-    - name: Tests incl. ccxt compatibility tests
+    - name: Cleanup previous runs on this branch
+      uses: rokroskar/workflow-run-cleanup-action@v0.3.3
+      if: "!startsWith(github.ref, 'refs/tags/') && github.ref != 'refs/heads/stable' && github.repository == 'freqtrade/freqtrade'"
      env:
-        CI_WEB_PROXY: http://152.67.78.211:13128
-      run: |
-        pytest --random-order --cov=freqtrade --cov-config=.coveragerc --longrun
-
+        GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"

  # Notify only once - when CI completes (and after deploy) in case it's successfull
  notify-complete:
-    needs: [
-      build_linux,
-      build_macos,
-      build_windows,
-      docs_check,
-      mypy_version_check,
-      pre-commit,
-      build_linux_online
-    ]
-    runs-on: ubuntu-22.04
-    # Discord notification can't handle schedule events
-    if: (github.event_name != 'schedule')
-    permissions:
-      repository-projects: read
+    needs: [ build_linux, build_macos, build_windows, docs_check ]
+    runs-on: ubuntu-20.04
    steps:

    - name: Check user permission
@ -401,18 +319,18 @@ jobs:
          webhookUrl: ${{ secrets.DISCORD_WEBHOOK }}

  deploy:
-    needs: [ build_linux, build_macos, build_windows, docs_check, mypy_version_check, pre-commit ]
-    runs-on: ubuntu-22.04
+    needs: [ build_linux, build_macos, build_windows, docs_check ]
+    runs-on: ubuntu-20.04

    if: (github.event_name == 'push' || github.event_name == 'schedule' || github.event_name == 'release') && github.repository == 'freqtrade/freqtrade'

    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v2

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

    - name: Extract branch name
      shell: bash
@ -425,7 +343,7 @@ jobs:
        python setup.py sdist bdist_wheel

    - name: Publish to PyPI (Test)
-      uses: pypa/gh-action-pypi-publish@v1.8.5
+      uses: pypa/gh-action-pypi-publish@master
      if: (github.event_name == 'release')
      with:
        user: __token__
@ -433,7 +351,7 @@ jobs:
        repository_url: https://test.pypi.org/legacy/

    - name: Publish to PyPI
-      uses: pypa/gh-action-pypi-publish@v1.8.5
+      uses: pypa/gh-action-pypi-publish@master
      if: (github.event_name == 'release')
      with:
        user: __token__
@ -466,20 +384,28 @@ jobs:

    - name: Build and test and push docker images
      env:
+        IMAGE_NAME: freqtradeorg/freqtrade
        BRANCH_NAME: ${{ steps.extract_branch.outputs.branch }}
      run: |
        build_helpers/publish_docker_multi.sh

+    - 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:
+          severity: info
+          details: Deploy Succeeded!
+          webhookUrl: ${{ secrets.DISCORD_WEBHOOK }}
+
+
  deploy_arm:
-    permissions:
-      packages: write
    needs: [ deploy ]
    # Only run on 64bit machines
    runs-on: [self-hosted, linux, ARM64]
    if: (github.event_name == 'push' || github.event_name == 'schedule' || github.event_name == 'release') && github.repository == 'freqtrade/freqtrade'

    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v2

    - name: Extract branch name
      shell: bash
@ -495,16 +421,7 @@ jobs:

    - name: Build and test and push docker images
      env:
+        IMAGE_NAME: freqtradeorg/freqtrade
        BRANCH_NAME: ${{ steps.extract_branch.outputs.branch }}
-        GHCR_USERNAME: ${{ github.actor }}
-        GHCR_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      run: |
        build_helpers/publish_docker_arm64.sh
-
-    - name: Discord notification
-      uses: rjstone/discord-webhook-notify@v1
-      if: always() && ( github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork == false) && (github.event_name != 'schedule')
-      with:
-          severity: info
-          details: Deploy Succeeded!
-          webhookUrl: ${{ secrets.DISCORD_WEBHOOK }}
--- a/.github/workflows/docker_update_readme.yml
+++ b/.github/workflows/docker_update_readme.yml
@ -8,10 +8,11 @@ jobs:
  dockerHubDescription:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v1
    - name: Docker Hub Description
-      uses: peter-evans/dockerhub-description@v3
+      uses: peter-evans/dockerhub-description@v2.4.3
      env:
        DOCKERHUB_USERNAME: ${{ secrets.DOCKER_USERNAME }}
        DOCKERHUB_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
        DOCKERHUB_REPOSITORY: freqtradeorg/freqtrade
+
--- a/.gitignore
+++ b/.gitignore
@ -7,15 +7,10 @@ logfile.txt
 user_data/*
 !user_data/strategy/sample_strategy.py
 !user_data/notebooks
-!user_data/models
-!user_data/freqaimodels
-user_data/freqaimodels/*
-user_data/models/*
 user_data/notebooks/*
 freqtrade-plot.html
 freqtrade-profit-plot.html
 freqtrade/rpc/api_server/ui/*
-build_helpers/ta-lib/*

 # Macos related
 .DS_Store
@ -85,8 +80,6 @@ instance/

 # Sphinx documentation
 docs/_build/
-# Mkdocs documentation
-site/

 # PyBuilder
 target/
@ -109,6 +102,6 @@ target/
 !*.gitkeep
 !config_examples/config_binance.example.json
 !config_examples/config_bittrex.example.json
+!config_examples/config_ftx.example.json
 !config_examples/config_full.example.json
 !config_examples/config_kraken.example.json
-!config_examples/config_freqai.example.json
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@ -1,55 +0,0 @@
-# See https://pre-commit.com for more information
-# See https://pre-commit.com/hooks.html for more hooks
-repos:
-  - repo: https://github.com/pycqa/flake8
-    rev: "6.0.0"
-    hooks:
-      - id: flake8
-        # stages: [push]
-
-  - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: "v1.0.1"
-    hooks:
-      - id: mypy
-        exclude: build_helpers
-        additional_dependencies:
-          - types-cachetools==5.3.0.5
-          - types-filelock==3.2.7
-          - types-requests==2.28.11.17
-          - types-tabulate==0.9.0.2
-          - types-python-dateutil==2.8.19.12
-          - SQLAlchemy==2.0.9
-        # stages: [push]
-
-  - repo: https://github.com/pycqa/isort
-    rev: "5.12.0"
-    hooks:
-      - id: isort
-        name: isort (python)
-        # stages: [push]
-
-  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    # Ruff version.
-    rev: 'v0.0.255'
-    hooks:
-      - id: ruff
-
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
-    hooks:
-      - id: end-of-file-fixer
-        exclude: |
-            (?x)^(
-                tests/.*|
-                .*\.svg|
-                .*\.yml|
-                .*\.json
-            )$
-      - id: mixed-line-ending
-      - id: debug-statements
-      - id: check-ast
-      - id: trailing-whitespace
-        exclude: |
-          (?x)^(
-                .*\.md
-            )$
--- a/.pylintrc
+++ b/.pylintrc
@ -7,3 +7,4 @@ ignore=vendor

 [TYPECHECK]
 ignored-modules=numpy,talib,talib.abstract
+
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -45,17 +45,16 @@ pytest tests/test_<file_name>.py::test_<method_name>

 ### 2. Test if your code is PEP8 compliant

-#### Run Ruff
+#### Run Flake8

 ```bash
-ruff .
+flake8 freqtrade tests scripts
 ```

-We receive a lot of code that fails the `ruff` checks.
+We receive a lot of code that fails the `flake8` checks.
 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.
-
-you can manually run pre-commit with `pre-commit run -a`.
+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

--- a/4
+++ b/4
@ -1,4 +1,4 @@
-FROM python:3.10.11-slim-bullseye as base
+FROM python:3.9.9-slim-bullseye as base

 # Setup env
 ENV LANG C.UTF-8
@ -11,7 +11,7 @@ ENV FT_APP_ENV="docker"
 # Prepare environment
 RUN mkdir /freqtrade \
  && apt-get update \
-  && apt-get -y install sudo libatlas3-base curl sqlite3 libhdf5-serial-dev libgomp1 \
+  && apt-get -y install sudo libatlas3-base curl sqlite3 libhdf5-serial-dev  \
  && apt-get clean \
  && useradd -u 1000 -G sudo -U -m -s /bin/bash ftuser \
  && chown ftuser:ftuser /freqtrade \
--- a/MANIFEST.in
+++ b/MANIFEST.in
@ -2,6 +2,5 @@ include LICENSE
 include README.md
 recursive-include freqtrade *.py
 recursive-include freqtrade/templates/ *.j2 *.ipynb
-include freqtrade/exchange/binance_leverage_tiers.json
 include freqtrade/rpc/api_server/ui/fallback_file.html
 include freqtrade/rpc/api_server/ui/favicon.ico
--- a/README.md
+++ b/README.md
@ -1,7 +1,6 @@
 # ![freqtrade](https://raw.githubusercontent.com/freqtrade/freqtrade/develop/docs/assets/freqtrade_poweredby.svg)

 [![Freqtrade CI](https://github.com/freqtrade/freqtrade/workflows/Freqtrade%20CI/badge.svg)](https://github.com/freqtrade/freqtrade/actions/)
-[![DOI](https://joss.theoj.org/papers/10.21105/joss.04864/status.svg)](https://doi.org/10.21105/joss.04864)
 [![Coverage Status](https://coveralls.io/repos/github/freqtrade/freqtrade/badge.svg?branch=develop&service=github)](https://coveralls.io/github/freqtrade/freqtrade?branch=develop)
 [![Documentation](https://readthedocs.org/projects/freqtrade/badge/)](https://www.freqtrade.io)
 [![Maintainability](https://api.codeclimate.com/v1/badges/5737e6d668200b7518ff/maintainability)](https://codeclimate.com/github/freqtrade/freqtrade/maintainability)
@ -10,6 +9,10 @@ Freqtrade is a free and open source crypto trading bot written in Python. It is

 ![freqtrade](https://raw.githubusercontent.com/freqtrade/freqtrade/develop/docs/assets/freqtrade-screenshot.png)

+## Sponsored promotion
+
+[![tokenbot-promo](https://raw.githubusercontent.com/freqtrade/freqtrade/develop/docs/assets/TokenBot-Freqtrade-banner.png)](https://tokenbot.com/?utm_source=github&utm_medium=freqtrade&utm_campaign=algodevs)
+
 ## Disclaimer

 This software is for educational purposes only. Do not risk money which
@ -27,23 +30,14 @@ hesitate to read the source code and understand the mechanism of this bot.

 Please read the [exchange specific notes](docs/exchanges.md) to learn about eventual, special configurations needed for each exchange.

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

-### Supported Futures Exchanges (experimental)
-
- [X] [Binance](https://www.binance.com/)
- [X] [Gate.io](https://www.gate.io/ref/6266643)
- [X] [OKX](https://okx.com/)
- [X] [Bybit](https://bybit.com/)
-
-Please make sure to read the [exchange specific notes](docs/exchanges.md), as well as the [trading with leverage](docs/leverage.md) documentation before diving in.
-
 ### Community tested

 Exchanges confirmed working by the community:
@ -64,7 +58,6 @@ Please find the complete documentation on the [freqtrade website](https://www.fr
 - [x] **Dry-run**: Run the bot without paying money.
 - [x] **Backtesting**: Run a simulation of your buy/sell strategy.
 - [x] **Strategy Optimization by machine learning**: Use machine learning to optimize your buy/sell strategy parameters with real exchange data.
- [X] **Adaptive prediction modeling**: Build a smart strategy with FreqAI that self-trains to the market via adaptive machine learning methods. [Learn more](https://www.freqtrade.io/en/stable/freqai/)
 - [x] **Edge position sizing** Calculate your win rate, risk reward ratio, the best stoploss and adjust your position size before taking a position for each specific market. [Learn more](https://www.freqtrade.io/en/stable/edge/).
 - [x] **Whitelist crypto-currencies**: Select which crypto-currency you want to trade or use dynamic whitelists.
 - [x] **Blacklist crypto-currencies**: Select which crypto-currency you want to avoid.
@ -75,9 +68,15 @@ Please find the complete documentation on the [freqtrade website](https://www.fr

 ## Quick start

-Please refer to the [Docker Quickstart documentation](https://www.freqtrade.io/en/stable/docker_quickstart/) on how to get started quickly.
+Freqtrade provides a Linux/macOS script to install all dependencies and help you to configure the bot.

-For further (native) installation methods, please refer to the [Installation documentation page](https://www.freqtrade.io/en/stable/installation/).
+```bash
+git clone -b develop https://github.com/freqtrade/freqtrade.git
+cd freqtrade
+./setup.sh --install
+```
+
+For any other type of installation please refer to [Installation doc](https://www.freqtrade.io/en/stable/installation/).

 ## Basic Usage

@ -131,11 +130,10 @@ Telegram is not mandatory. However, this is a great way to control your bot. Mor

 - `/start`: Starts the trader.
 - `/stop`: Stops the trader.
- `/stopentry`: Stop entering new trades.
+- `/stopbuy`: Stop entering new trades.
 - `/status <trade_id>|[table]`: Lists all or specific open trades.
 - `/profit [<n>]`: Lists cumulative profit from all finished trades, over the last n days.
- `/forceexit <trade_id>|all`: Instantly exits the given trade (Ignoring `minimum_roi`).
- `/fx <trade_id>|all`: Alias to `/forceexit`
+- `/forcesell <trade_id>|all`: Instantly sells the given trade (Ignoring `minimum_roi`).
 - `/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.
@ -165,10 +163,6 @@ first. If it hasn't been reported, please
 ensure you follow the template guide so that the team can assist you as
 quickly as possible.

-For every [issue](https://github.com/freqtrade/freqtrade/issues/new/choose) created, kindly follow up and mark satisfaction or reminder to close issue when equilibrium ground is reached.
-
--Maintain github's [community policy](https://docs.github.com/en/site-policy/github-terms/github-community-code-of-conduct)--
-
 ### [Feature Requests](https://github.com/freqtrade/freqtrade/labels/enhancement)

 Have you a great idea to improve the bot you want to share? Please,
@ -199,7 +193,7 @@ Issues labeled [good first issue](https://github.com/freqtrade/freqtrade/labels/

 The clock must be accurate, synchronized to a NTP server very frequently to avoid problems with communication to the exchanges.

-### Minimum hardware required
+### Min hardware required

 To run this bot we recommend you a cloud instance with a minimum of:

--- a/build_helpers/TA_Lib-0.4.24-cp310-cp310-win_amd64.whl
+++ b/build_helpers/TA_Lib-0.4.24-cp310-cp310-win_amd64.whl
--- a/build_helpers/TA_Lib-0.4.24-cp38-cp38-win_amd64.whl
+++ b/build_helpers/TA_Lib-0.4.24-cp38-cp38-win_amd64.whl
--- a/build_helpers/TA_Lib-0.4.24-cp39-cp39-win_amd64.whl
+++ b/build_helpers/TA_Lib-0.4.24-cp39-cp39-win_amd64.whl
--- a/build_helpers/TA_Lib-0.4.25-cp310-cp310-win_amd64.whl
+++ b/build_helpers/TA_Lib-0.4.25-cp310-cp310-win_amd64.whl
--- a/build_helpers/TA_Lib-0.4.25-cp311-cp311-win_amd64.whl
+++ b/build_helpers/TA_Lib-0.4.25-cp311-cp311-win_amd64.whl
--- a/build_helpers/TA_Lib-0.4.25-cp38-cp38-win_amd64.whl
+++ b/build_helpers/TA_Lib-0.4.25-cp38-cp38-win_amd64.whl
--- a/build_helpers/TA_Lib-0.4.25-cp39-cp39-win_amd64.whl
+++ b/build_helpers/TA_Lib-0.4.25-cp39-cp39-win_amd64.whl
--- a/build_helpers/install_ta-lib.sh
+++ b/build_helpers/install_ta-lib.sh
@ -4,12 +4,12 @@ else
  INSTALL_LOC=${1}
 fi
 echo "Installing to ${INSTALL_LOC}"
-if [ -n "$2" ] || [ ! -f "${INSTALL_LOC}/lib/libta_lib.a" ]; then
+if [ ! -f "${INSTALL_LOC}/lib/libta_lib.a" ]; then
  tar zxvf ta-lib-0.4.0-src.tar.gz
  cd ta-lib \
  && sed -i.bak "s|0.00000001|0.000000000000000001 |g" src/ta_func/ta_utility.h \
-  && curl 'https://raw.githubusercontent.com/gcc-mirror/gcc/master/config.guess' -o config.guess \
-  && curl 'https://raw.githubusercontent.com/gcc-mirror/gcc/master/config.sub' -o config.sub \
+  && curl 'http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD' -o config.guess \
+  && curl 'http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD' -o config.sub \
  && ./configure --prefix=${INSTALL_LOC}/ \
  && make
  if [ $? -ne 0 ]; then
@ -17,17 +17,11 @@ if [ -n "$2" ] || [ ! -f "${INSTALL_LOC}/lib/libta_lib.a" ]; then
    cd .. && rm -rf ./ta-lib/
    exit 1
  fi
-  if [ -z "$2" ]; then
-    which sudo && sudo make install || make install
-    if [ -x "$(command -v apt-get)" ]; then
-      echo "Updating library path using ldconfig"
-      sudo ldconfig
-    fi
-  else
-    # Don't install with sudo
-    make install
+  which sudo && sudo make install || make install
+  if [ -x "$(command -v apt-get)" ]; then
+    echo "Updating library path using ldconfig"
+    sudo ldconfig
  fi
-
  cd .. && rm -rf ./ta-lib/
 else
  echo "TA-lib already installed, skipping installation"
--- a/build_helpers/install_windows.ps1
+++ b/build_helpers/install_windows.ps1
@ -6,16 +6,13 @@ python -m pip install --upgrade pip wheel
 $pyv = python -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"

 if ($pyv -eq '3.8') {
-    pip install build_helpers\TA_Lib-0.4.25-cp38-cp38-win_amd64.whl
+    pip install build_helpers\TA_Lib-0.4.24-cp38-cp38-win_amd64.whl
 }
 if ($pyv -eq '3.9') {
-    pip install build_helpers\TA_Lib-0.4.25-cp39-cp39-win_amd64.whl
+    pip install build_helpers\TA_Lib-0.4.24-cp39-cp39-win_amd64.whl
 }
 if ($pyv -eq '3.10') {
-    pip install build_helpers\TA_Lib-0.4.25-cp310-cp310-win_amd64.whl
-}
-if ($pyv -eq '3.11') {
-    pip install build_helpers\TA_Lib-0.4.25-cp311-cp311-win_amd64.whl
+    pip install build_helpers\TA_Lib-0.4.24-cp310-cp310-win_amd64.whl
 }
 pip install -r requirements-dev.txt
 pip install -e .
--- a/build_helpers/pre_commit_update.py
+++ b/build_helpers/pre_commit_update.py
@ -1,47 +0,0 @@
-# File used in CI to ensure pre-commit dependencies are kept uptodate.
-
-import sys
-from pathlib import Path
-
-import yaml
-
-
-pre_commit_file = Path('.pre-commit-config.yaml')
-require_dev = Path('requirements-dev.txt')
-require = Path('requirements.txt')
-
-with require_dev.open('r') as rfile:
-    requirements = rfile.readlines()
-
-with require.open('r') as rfile:
-    requirements.extend(rfile.readlines())
-
-# Extract types only
-type_reqs = [r.strip('\n') for r in requirements if r.startswith(
-    'types-') or r.startswith('SQLAlchemy')]
-
-with pre_commit_file.open('r') as file:
-    f = yaml.load(file, Loader=yaml.FullLoader)
-
-
-mypy_repo = [repo for repo in f['repos'] if repo['repo']
-             == 'https://github.com/pre-commit/mirrors-mypy']
-
-hooks = mypy_repo[0]['hooks'][0]['additional_dependencies']
-
-errors = []
-for hook in hooks:
-    if hook not in type_reqs:
-        errors.append(f"{hook} is missing in requirements-dev.txt.")
-
-for req in type_reqs:
-    if req not in hooks:
-        errors.append(f"{req} is missing in pre-config file.")
-
-
-if errors:
-    for e in errors:
-        print(e)
-    sys.exit(1)
-
-sys.exit(0)
--- a/build_helpers/publish_docker_arm64.sh
+++ b/build_helpers/publish_docker_arm64.sh
@ -3,22 +3,14 @@
 # Use BuildKit, otherwise building on ARM fails
 export DOCKER_BUILDKIT=1

-IMAGE_NAME=freqtradeorg/freqtrade
-CACHE_IMAGE=freqtradeorg/freqtrade_cache
-GHCR_IMAGE_NAME=ghcr.io/freqtrade/freqtrade
-
 # Replace / with _ to create a valid tag
 TAG=$(echo "${BRANCH_NAME}" | sed -e "s/\//_/g")
 TAG_PLOT=${TAG}_plot
-TAG_FREQAI=${TAG}_freqai
-TAG_FREQAI_RL=${TAG_FREQAI}rl
-TAG_FREQAI_TORCH=${TAG_FREQAI}torch
 TAG_PI="${TAG}_pi"

 TAG_ARM=${TAG}_arm
 TAG_PLOT_ARM=${TAG_PLOT}_arm
-TAG_FREQAI_ARM=${TAG_FREQAI}_arm
-TAG_FREQAI_RL_ARM=${TAG_FREQAI_RL}_arm
+CACHE_IMAGE=freqtradeorg/freqtrade_cache

 echo "Running for ${TAG}"

@ -42,19 +34,15 @@ if [ $? -ne 0 ]; then
    echo "failed building multiarch images"
    return 1
 fi
-
-docker build --build-arg sourceimage=freqtrade --build-arg sourcetag=${TAG_ARM} -t freqtrade:${TAG_PLOT_ARM} -f docker/Dockerfile.plot .
-docker build --build-arg sourceimage=freqtrade --build-arg sourcetag=${TAG_ARM} -t freqtrade:${TAG_FREQAI_ARM} -f docker/Dockerfile.freqai .
-docker build --build-arg sourceimage=freqtrade --build-arg sourcetag=${TAG_FREQAI_ARM} -t freqtrade:${TAG_FREQAI_RL_ARM} -f docker/Dockerfile.freqai_rl .
-
 # Tag image for upload and next build step
 docker tag freqtrade:$TAG_ARM ${CACHE_IMAGE}:$TAG_ARM
+
+docker build --cache-from freqtrade:${TAG_ARM} --build-arg sourceimage=${CACHE_IMAGE} --build-arg sourcetag=${TAG_ARM} -t freqtrade:${TAG_PLOT_ARM} -f docker/Dockerfile.plot .
+
 docker tag freqtrade:$TAG_PLOT_ARM ${CACHE_IMAGE}:$TAG_PLOT_ARM
-docker tag freqtrade:$TAG_FREQAI_ARM ${CACHE_IMAGE}:$TAG_FREQAI_ARM
-docker tag freqtrade:$TAG_FREQAI_RL_ARM ${CACHE_IMAGE}:$TAG_FREQAI_RL_ARM

 # Run backtest
-docker run --rm -v $(pwd)/config_examples/config_bittrex.example.json:/freqtrade/config.json:ro -v $(pwd)/tests:/tests freqtrade:${TAG_ARM} backtesting --datadir /tests/testdata --strategy-path /tests/strategy/strats/ --strategy StrategyTestV3
+docker run --rm -v $(pwd)/config_examples/config_bittrex.example.json:/freqtrade/config.json:ro -v $(pwd)/tests:/tests freqtrade:${TAG_ARM} backtesting --datadir /tests/testdata --strategy-path /tests/strategy/strats/ --strategy StrategyTestV2

 if [ $? -ne 0 ]; then
    echo "failed running backtest"
@ -63,9 +51,8 @@ fi

 docker images

+# docker push ${IMAGE_NAME}
 docker push ${CACHE_IMAGE}:$TAG_PLOT_ARM
-docker push ${CACHE_IMAGE}:$TAG_FREQAI_ARM
-docker push ${CACHE_IMAGE}:$TAG_FREQAI_RL_ARM
 docker push ${CACHE_IMAGE}:$TAG_ARM

 # Create multi-arch image
@ -73,47 +60,19 @@ docker push ${CACHE_IMAGE}:$TAG_ARM
 # Otherwise installation might fail.
 echo "create manifests"

-docker manifest create ${IMAGE_NAME}:${TAG} ${CACHE_IMAGE}:${TAG} ${CACHE_IMAGE}:${TAG_ARM} ${IMAGE_NAME}:${TAG_PI}
+docker manifest create --amend ${IMAGE_NAME}:${TAG} ${CACHE_IMAGE}:${TAG_ARM} ${IMAGE_NAME}:${TAG_PI} ${CACHE_IMAGE}:${TAG}
 docker manifest push -p ${IMAGE_NAME}:${TAG}

-docker manifest create ${IMAGE_NAME}:${TAG_PLOT} ${CACHE_IMAGE}:${TAG_PLOT} ${CACHE_IMAGE}:${TAG_PLOT_ARM}
+docker manifest create ${IMAGE_NAME}:${TAG_PLOT} ${CACHE_IMAGE}:${TAG_PLOT_ARM} ${CACHE_IMAGE}:${TAG_PLOT}
 docker manifest push -p ${IMAGE_NAME}:${TAG_PLOT}

-docker manifest create ${IMAGE_NAME}:${TAG_FREQAI} ${CACHE_IMAGE}:${TAG_FREQAI} ${CACHE_IMAGE}:${TAG_FREQAI_ARM}
-docker manifest push -p ${IMAGE_NAME}:${TAG_FREQAI}
-
-docker manifest create ${IMAGE_NAME}:${TAG_FREQAI_RL} ${CACHE_IMAGE}:${TAG_FREQAI_RL} ${CACHE_IMAGE}:${TAG_FREQAI_RL_ARM}
-docker manifest push -p ${IMAGE_NAME}:${TAG_FREQAI_RL}
-
-# Create special Torch tag - which is identical to the RL tag.
-docker manifest create ${IMAGE_NAME}:${TAG_FREQAI_TORCH} ${CACHE_IMAGE}:${TAG_FREQAI_RL} ${CACHE_IMAGE}:${TAG_FREQAI_RL_ARM}
-docker manifest push -p ${IMAGE_NAME}:${TAG_FREQAI_TORCH}
-
-# copy images to ghcr.io
-
-alias crane="docker run --rm -i -v $(pwd)/.crane:/home/nonroot/.docker/ gcr.io/go-containerregistry/crane"
-mkdir .crane
-chmod a+rwx .crane
-
-echo "${GHCR_TOKEN}" | crane auth login ghcr.io -u "${GHCR_USERNAME}" --password-stdin
-
-crane copy ${IMAGE_NAME}:${TAG_FREQAI_RL} ${GHCR_IMAGE_NAME}:${TAG_FREQAI_RL}
-crane copy ${IMAGE_NAME}:${TAG_FREQAI_RL} ${GHCR_IMAGE_NAME}:${TAG_FREQAI_TORCH}
-crane copy ${IMAGE_NAME}:${TAG_FREQAI} ${GHCR_IMAGE_NAME}:${TAG_FREQAI}
-crane copy ${IMAGE_NAME}:${TAG_PLOT} ${GHCR_IMAGE_NAME}:${TAG_PLOT}
-crane copy ${IMAGE_NAME}:${TAG} ${GHCR_IMAGE_NAME}:${TAG}
-
 # Tag as latest for develop builds
 if [ "${TAG}" = "develop" ]; then
-    echo 'Tagging image as latest'
    docker manifest create ${IMAGE_NAME}:latest ${CACHE_IMAGE}:${TAG_ARM} ${IMAGE_NAME}:${TAG_PI} ${CACHE_IMAGE}:${TAG}
    docker manifest push -p ${IMAGE_NAME}:latest
-
-    crane copy ${IMAGE_NAME}:latest ${GHCR_IMAGE_NAME}:latest
 fi

 docker images
-rm -rf .crane

 # Cleanup old images from arm64 node.
 docker image prune -a --force --filter "until=24h"
--- a/build_helpers/publish_docker_multi.sh
+++ b/build_helpers/publish_docker_multi.sh
@ -2,17 +2,14 @@

 # The below assumes a correctly setup docker buildx environment

-IMAGE_NAME=freqtradeorg/freqtrade
-CACHE_IMAGE=freqtradeorg/freqtrade_cache
 # Replace / with _ to create a valid tag
 TAG=$(echo "${BRANCH_NAME}" | sed -e "s/\//_/g")
 TAG_PLOT=${TAG}_plot
-TAG_FREQAI=${TAG}_freqai
-TAG_FREQAI_RL=${TAG_FREQAI}rl
 TAG_PI="${TAG}_pi"

 PI_PLATFORM="linux/arm/v7"
 echo "Running for ${TAG}"
+CACHE_IMAGE=freqtradeorg/freqtrade_cache
 CACHE_TAG=${CACHE_IMAGE}:${TAG_PI}_cache

 # Add commit and commit_message to docker container
@ -27,10 +24,7 @@ if [ "${GITHUB_EVENT_NAME}" = "schedule" ]; then
        --cache-to=type=registry,ref=${CACHE_TAG} \
        -f docker/Dockerfile.armhf \
        --platform ${PI_PLATFORM} \
-        -t ${IMAGE_NAME}:${TAG_PI} \
-        --push \
-        --provenance=false \
-        .
+        -t ${IMAGE_NAME}:${TAG_PI} --push .
 else
    echo "event ${GITHUB_EVENT_NAME}: building with cache"
    # Build regular image
@ -39,16 +33,12 @@ else

    # Pull last build to avoid rebuilding the whole image
    # docker pull --platform ${PI_PLATFORM} ${IMAGE_NAME}:${TAG}
-    # disable provenance due to https://github.com/docker/buildx/issues/1509
    docker buildx build \
        --cache-from=type=registry,ref=${CACHE_TAG} \
        --cache-to=type=registry,ref=${CACHE_TAG} \
        -f docker/Dockerfile.armhf \
        --platform ${PI_PLATFORM} \
-        -t ${IMAGE_NAME}:${TAG_PI} \
-        --push \
-        --provenance=false \
-        .
+        -t ${IMAGE_NAME}:${TAG_PI} --push .
 fi

 if [ $? -ne 0 ]; then
@ -58,16 +48,12 @@ fi
 # Tag image for upload and next build step
 docker tag freqtrade:$TAG ${CACHE_IMAGE}:$TAG

-docker build --build-arg sourceimage=freqtrade --build-arg sourcetag=${TAG} -t freqtrade:${TAG_PLOT} -f docker/Dockerfile.plot .
-docker build --build-arg sourceimage=freqtrade --build-arg sourcetag=${TAG} -t freqtrade:${TAG_FREQAI} -f docker/Dockerfile.freqai .
-docker build --build-arg sourceimage=freqtrade --build-arg sourcetag=${TAG_FREQAI} -t freqtrade:${TAG_FREQAI_RL} -f docker/Dockerfile.freqai_rl .
+docker build --cache-from freqtrade:${TAG} --build-arg sourceimage=${CACHE_IMAGE} --build-arg sourcetag=${TAG} -t freqtrade:${TAG_PLOT} -f docker/Dockerfile.plot .

 docker tag freqtrade:$TAG_PLOT ${CACHE_IMAGE}:$TAG_PLOT
-docker tag freqtrade:$TAG_FREQAI ${CACHE_IMAGE}:$TAG_FREQAI
-docker tag freqtrade:$TAG_FREQAI_RL ${CACHE_IMAGE}:$TAG_FREQAI_RL

 # Run backtest
-docker run --rm -v $(pwd)/config_examples/config_bittrex.example.json:/freqtrade/config.json:ro -v $(pwd)/tests:/tests freqtrade:${TAG} backtesting --datadir /tests/testdata --strategy-path /tests/strategy/strats/ --strategy StrategyTestV3
+docker run --rm -v $(pwd)/config_examples/config_bittrex.example.json:/freqtrade/config.json:ro -v $(pwd)/tests:/tests freqtrade:${TAG} backtesting --datadir /tests/testdata --strategy-path /tests/strategy/strats/ --strategy StrategyTestV2

 if [ $? -ne 0 ]; then
    echo "failed running backtest"
@ -76,10 +62,10 @@ fi

 docker images

-docker push ${CACHE_IMAGE}:$TAG
+docker push ${CACHE_IMAGE}
 docker push ${CACHE_IMAGE}:$TAG_PLOT
-docker push ${CACHE_IMAGE}:$TAG_FREQAI
-docker push ${CACHE_IMAGE}:$TAG_FREQAI_RL
+docker push ${CACHE_IMAGE}:$TAG
+

 docker images

--- a/build_helpers/pyarrow-11.0.0-cp39-cp39-linux_armv7l.whl
+++ b/build_helpers/pyarrow-11.0.0-cp39-cp39-linux_armv7l.whl
--- a/config_examples/config_binance.example.json
+++ b/config_examples/config_binance.example.json
@ -8,23 +8,21 @@
    "dry_run": true,
    "cancel_open_orders_on_exit": false,
    "unfilledtimeout": {
-        "entry": 10,
-        "exit": 10,
+        "buy": 10,
+        "sell": 10,
        "exit_timeout_count": 0,
        "unit": "minutes"
    },
-    "entry_pricing": {
-        "price_side": "same",
+    "bid_strategy": {
+        "ask_last_balance": 0.0,
        "use_order_book": true,
        "order_book_top": 1,
-        "price_last_balance": 0.0,
        "check_depth_of_market": {
            "enabled": false,
            "bids_to_ask_delta": 1
        }
    },
-    "exit_pricing": {
-        "price_side": "same",
+    "ask_strategy": {
        "use_order_book": true,
        "order_book_top": 1
    },
@ -53,12 +51,26 @@
            "XTZ/BTC"
        ],
        "pair_blacklist": [
-            "BNB/.*"
+            "BNB/BTC"
        ]
    },
    "pairlists": [
        {"method": "StaticPairList"}
    ],
+    "edge": {
+        "enabled": false,
+        "process_throttle_secs": 3600,
+        "calculate_since_number_of_days": 7,
+        "allowed_risk": 0.01,
+        "stoploss_range_min": -0.01,
+        "stoploss_range_max": -0.1,
+        "stoploss_range_step": -0.01,
+        "minimum_winrate": 0.60,
+        "minimum_expectancy": 0.20,
+        "min_trade_number": 10,
+        "max_trade_duration_minute": 1440,
+        "remove_pumps": false
+    },
    "telegram": {
        "enabled": false,
        "token": "your_telegram_token",
@ -76,7 +88,7 @@
    },
    "bot_name": "freqtrade",
    "initial_state": "running",
-    "force_entry_enable": false,
+    "forcebuy_enable": false,
    "internals": {
        "process_throttle_secs": 5
    }
--- a/config_examples/config_bittrex.example.json
+++ b/config_examples/config_bittrex.example.json
@ -8,23 +8,21 @@
    "dry_run": true,
    "cancel_open_orders_on_exit": false,
    "unfilledtimeout": {
-        "entry": 10,
-        "exit": 10,
+        "buy": 10,
+        "sell": 10,
        "exit_timeout_count": 0,
        "unit": "minutes"
    },
-    "entry_pricing": {
-        "price_side": "same",
+    "bid_strategy": {
        "use_order_book": true,
+        "ask_last_balance": 0.0,
        "order_book_top": 1,
-        "price_last_balance": 0.0,
        "check_depth_of_market": {
            "enabled": false,
            "bids_to_ask_delta": 1
        }
    },
-    "exit_pricing":{
-        "price_side": "same",
+    "ask_strategy":{
        "use_order_book": true,
        "order_book_top": 1
    },
@ -56,6 +54,20 @@
    "pairlists": [
        {"method": "StaticPairList"}
    ],
+    "edge": {
+        "enabled": false,
+        "process_throttle_secs": 3600,
+        "calculate_since_number_of_days": 7,
+        "allowed_risk": 0.01,
+        "stoploss_range_min": -0.01,
+        "stoploss_range_max": -0.1,
+        "stoploss_range_step": -0.01,
+        "minimum_winrate": 0.60,
+        "minimum_expectancy": 0.20,
+        "min_trade_number": 10,
+        "max_trade_duration_minute": 1440,
+        "remove_pumps": false
+    },
    "telegram": {
        "enabled": false,
        "token": "your_telegram_token",
@ -73,7 +85,7 @@
    },
    "bot_name": "freqtrade",
    "initial_state": "running",
-    "force_entry_enable": false,
+    "forcebuy_enable": false,
    "internals": {
        "process_throttle_secs": 5
    }
--- a/config_examples/config_freqai.example.json
+++ b/config_examples/config_freqai.example.json
@ -1,90 +0,0 @@
-{
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "max_open_trades": 5,
-    "stake_currency": "USDT",
-    "stake_amount": 200,
-    "tradable_balance_ratio": 1,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "timeframe": "3m",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "unfilledtimeout": {
-        "entry": 10,
-        "exit": 30
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "",
-        "secret": "",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "1INCH/USDT:USDT",
-            "ALGO/USDT:USDT"
-        ],
-        "pair_blacklist": []
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing": {
-        "price_side": "other",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList"
-        }
-    ],
-    "freqai": {
-        "enabled": true,
-        "purge_old_models": 2,
-        "train_period_days": 15,
-        "backtest_period_days": 7,
-        "live_retrain_hours": 0,
-        "identifier": "uniqe-id",
-        "feature_parameters": {
-            "include_timeframes": [
-                "3m",
-                "15m",
-                "1h"
-            ],
-            "include_corr_pairlist": [
-                "BTC/USDT:USDT",
-                "ETH/USDT:USDT"
-            ],
-            "label_period_candles": 20,
-            "include_shifted_candles": 2,
-            "DI_threshold": 0.9,
-            "weight_factor": 0.9,
-            "principal_component_analysis": false,
-            "use_SVM_to_remove_outliers": true,
-            "indicator_periods_candles": [
-                10,
-                20
-            ],
-            "plot_feature_importances": 0
-        },
-        "data_split_parameters": {
-            "test_size": 0.33,
-            "random_state": 1
-        },
-        "model_training_parameters": {}
-    },
-    "bot_name": "",
-    "force_entry_enable": true,
-    "initial_state": "running",
-    "internals": {
-        "process_throttle_secs": 5
-    }
-}
--- a/config_examples/config_ftx.example.json
+++ b/config_examples/config_ftx.example.json
@ -0,0 +1,94 @@
+{
+    "max_open_trades": 3,
+    "stake_currency": "USD",
+    "stake_amount": 50,
+    "tradable_balance_ratio": 0.99,
+    "fiat_display_currency": "USD",
+    "timeframe": "5m",
+    "dry_run": true,
+    "cancel_open_orders_on_exit": false,
+    "unfilledtimeout": {
+        "buy": 10,
+        "sell": 10,
+        "exit_timeout_count": 0,
+        "unit": "minutes"
+    },
+    "bid_strategy": {
+        "ask_last_balance": 0.0,
+        "use_order_book": true,
+        "order_book_top": 1,
+        "check_depth_of_market": {
+            "enabled": false,
+            "bids_to_ask_delta": 1
+        }
+    },
+    "ask_strategy": {
+        "use_order_book": true,
+        "order_book_top": 1
+    },
+    "exchange": {
+        "name": "ftx",
+        "key": "your_exchange_key",
+        "secret": "your_exchange_secret",
+        "ccxt_config": {},
+        "ccxt_async_config": {},
+        "pair_whitelist": [
+            "BTC/USD",
+            "ETH/USD",
+            "BNB/USD",
+            "USDT/USD",
+            "LTC/USD",
+            "SRM/USD",
+            "SXP/USD",
+            "XRP/USD",
+            "DOGE/USD",
+            "1INCH/USD",
+            "CHZ/USD",
+            "MATIC/USD",
+            "LINK/USD",
+            "OXY/USD",
+            "SUSHI/USD"
+        ],
+        "pair_blacklist": [
+            "FTT/USD"
+        ]
+    },
+    "pairlists": [
+        {"method": "StaticPairList"}
+    ],
+    "edge": {
+        "enabled": false,
+        "process_throttle_secs": 3600,
+        "calculate_since_number_of_days": 7,
+        "allowed_risk": 0.01,
+        "stoploss_range_min": -0.01,
+        "stoploss_range_max": -0.1,
+        "stoploss_range_step": -0.01,
+        "minimum_winrate": 0.60,
+        "minimum_expectancy": 0.20,
+        "min_trade_number": 10,
+        "max_trade_duration_minute": 1440,
+        "remove_pumps": false
+    },
+    "telegram": {
+        "enabled": false,
+        "token": "your_telegram_token",
+        "chat_id": "your_telegram_chat_id"
+    },
+    "api_server": {
+        "enabled": false,
+        "listen_ip_address": "127.0.0.1",
+        "listen_port": 8080,
+        "verbosity": "error",
+        "jwt_secret_key": "somethingrandom",
+        "CORS_origins": [],
+        "username": "freqtrader",
+        "password": "SuperSecurePassword"
+    },
+    "bot_name": "freqtrade",
+    "initial_state": "running",
+    "forcebuy_enable": false,
+    "internals": {
+        "process_throttle_secs": 5
+    }
+}
--- a/config_examples/config_full.example.json
+++ b/config_examples/config_full.example.json
@ -5,7 +5,6 @@
    "tradable_balance_ratio": 0.99,
    "fiat_display_currency": "USD",
    "amount_reserve_percent": 0.05,
-    "available_capital": 1000,
    "amend_last_stake_amount": false,
    "last_stake_amount_min_ratio": 0.5,
    "dry_run": true,
@ -16,13 +15,11 @@
    "trailing_stop_positive": 0.005,
    "trailing_stop_positive_offset": 0.0051,
    "trailing_only_offset_is_reached": false,
-    "use_exit_signal": true,
-    "exit_profit_only": false,
-    "exit_profit_offset": 0.0,
-    "ignore_roi_if_entry_signal": false,
+    "use_sell_signal": true,
+    "sell_profit_only": false,
+    "sell_profit_offset": 0.0,
+    "ignore_roi_if_buy_signal": false,
    "ignore_buying_expired_candle_after": 300,
-    "trading_mode": "spot",
-    "margin_mode": "",
    "minimal_roi": {
        "40":  0.0,
        "30":  0.01,
@ -31,42 +28,39 @@
    },
    "stoploss": -0.10,
    "unfilledtimeout": {
-        "entry": 10,
-        "exit": 10,
+        "buy": 10,
+        "sell": 10,
        "exit_timeout_count": 0,
        "unit": "minutes"
    },
-    "entry_pricing": {
-        "price_side": "same",
+    "bid_strategy": {
+        "price_side": "bid",
        "use_order_book": true,
+        "ask_last_balance": 0.0,
        "order_book_top": 1,
-        "price_last_balance": 0.0,
        "check_depth_of_market": {
            "enabled": false,
            "bids_to_ask_delta": 1
        }
    },
-    "exit_pricing":{
-        "price_side": "same",
+    "ask_strategy":{
+        "price_side": "ask",
        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0
+        "order_book_top": 1
    },
    "order_types": {
-        "entry": "limit",
-        "exit": "limit",
-        "emergency_exit": "market",
-        "force_exit": "market",
-        "force_entry": "market",
+        "buy": "limit",
+        "sell": "limit",
+        "emergencysell": "market",
+        "forcesell": "market",
+        "forcebuy": "market",
        "stoploss": "market",
        "stoploss_on_exchange": false,
-        "stoploss_price_type": "last",
-        "stoploss_on_exchange_interval": 60,
-        "stoploss_on_exchange_limit_ratio": 0.99
+        "stoploss_on_exchange_interval": 60
    },
    "order_time_in_force": {
-        "entry": "GTC",
-        "exit": "GTC"
+        "buy": "gtc",
+        "sell": "gtc"
    },
    "pairlists": [
        {"method": "StaticPairList"},
@ -94,7 +88,6 @@
        "secret": "your_exchange_secret",
        "password": "",
        "log_responses": false,
-        // "unknown_fee_rate": 1,
        "ccxt_config": {},
        "ccxt_async_config": {},
        "pair_whitelist": [
@ -142,24 +135,23 @@
            "status": "on",
            "warning": "on",
            "startup": "on",
-            "entry": "on",
-            "entry_fill": "on",
-            "exit": {
+            "buy": "on",
+            "buy_fill": "on",
+            "sell": {
                "roi": "off",
-                "emergency_exit": "off",
-                "force_exit": "off",
-                "exit_signal": "off",
+                "emergency_sell": "off",
+                "force_sell": "off",
+                "sell_signal": "off",
                "trailing_stop_loss": "off",
                "stop_loss": "off",
                "stoploss_on_exchange": "off",
-                "custom_exit": "off"
+                "custom_sell": "off"
            },
-            "exit_fill": "on",
-            "entry_cancel": "on",
-            "exit_cancel": "on",
+            "sell_fill": "on",
+            "buy_cancel": "on",
+            "sell_cancel": "on",
            "protection_trigger": "off",
-            "protection_trigger_global": "on",
-            "show_candle": "off"
+            "protection_trigger_global": "on"
        },
        "reload": true,
        "balance_dust_level": 0.01
@ -173,29 +165,12 @@
        "jwt_secret_key": "somethingrandom",
        "CORS_origins": [],
        "username": "freqtrader",
-        "password": "SuperSecurePassword",
-        "ws_token": "secret_ws_t0ken."
-    },
-    "external_message_consumer": {
-        "enabled": false,
-        "producers": [
-          {
-            "name": "default",
-            "host": "127.0.0.2",
-            "port": 8080,
-            "ws_token": "secret_ws_t0ken."
-          }
-        ],
-        "wait_timeout": 300,
-        "ping_timeout": 10,
-        "sleep_time": 10,
-        "remove_entry_exit_signals": false,
-        "message_size_limit": 8
+        "password": "SuperSecurePassword"
    },
    "bot_name": "freqtrade",
    "db_url": "sqlite:///tradesv3.sqlite",
    "initial_state": "running",
-    "force_entry_enable": false,
+    "forcebuy_enable": false,
    "internals": {
        "process_throttle_secs": 5,
        "heartbeat_interval": 60
@ -203,9 +178,6 @@
    "disable_dataframe_checks": false,
    "strategy": "SampleStrategy",
    "strategy_path": "user_data/strategies/",
-    "recursive_strategy_search": false,
-    "add_config_files": [],
-    "reduce_df_footprint": false,
    "dataformat_ohlcv": "json",
    "dataformat_trades": "jsongz"
 }
--- a/config_examples/config_kraken.example.json
+++ b/config_examples/config_kraken.example.json
@ -8,23 +8,21 @@
    "dry_run": true,
    "cancel_open_orders_on_exit": false,
    "unfilledtimeout": {
-        "entry": 10,
-        "exit": 10,
+        "buy": 10,
+        "sell": 10,
        "exit_timeout_count": 0,
        "unit": "minutes"
    },
-    "entry_pricing": {
-        "price_side": "same",
+    "bid_strategy": {
        "use_order_book": true,
+        "ask_last_balance": 0.0,
        "order_book_top": 1,
-        "price_last_balance": 0.0,
        "check_depth_of_market": {
            "enabled": false,
            "bids_to_ask_delta": 1
        }
    },
-    "exit_pricing":{
-        "price_side": "same",
+    "ask_strategy":{
        "use_order_book": true,
        "order_book_top": 1
    },
@ -64,6 +62,20 @@
    "pairlists": [
        {"method": "StaticPairList"}
    ],
+    "edge": {
+        "enabled": false,
+        "process_throttle_secs": 3600,
+        "calculate_since_number_of_days": 7,
+        "allowed_risk": 0.01,
+        "stoploss_range_min": -0.01,
+        "stoploss_range_max": -0.1,
+        "stoploss_range_step": -0.01,
+        "minimum_winrate": 0.60,
+        "minimum_expectancy": 0.20,
+        "min_trade_number": 10,
+        "max_trade_duration_minute": 1440,
+        "remove_pumps": false
+    },
    "telegram": {
        "enabled": false,
        "token": "your_telegram_token",
@ -81,7 +93,7 @@
    },
    "bot_name": "freqtrade",
    "initial_state": "running",
-    "force_entry_enable": false,
+    "forcebuy_enable": false,
    "internals": {
        "process_throttle_secs": 5
    },
--- a/docker/Dockerfile.armhf
+++ b/docker/Dockerfile.armhf
@ -1,4 +1,4 @@
-FROM python:3.9.16-slim-bullseye as base
+FROM python:3.9.9-slim-bullseye as base

 # Setup env
 ENV LANG C.UTF-8
@ -11,7 +11,7 @@ ENV FT_APP_ENV="docker"
 # Prepare environment
 RUN mkdir /freqtrade \
  && apt-get update \
-  && apt-get -y install sudo libatlas3-base curl sqlite3 libhdf5-dev libutf8proc-dev libsnappy-dev \
+  && apt-get -y install sudo libatlas3-base curl sqlite3 libhdf5-dev \
  && apt-get clean \
  && useradd -u 1000 -G sudo -U -m ftuser \
  && chown ftuser:ftuser /freqtrade \
@ -37,7 +37,6 @@ ENV LD_LIBRARY_PATH /usr/local/lib
 COPY --chown=ftuser:ftuser requirements.txt /freqtrade/
 USER ftuser
 RUN  pip install --user --no-cache-dir numpy \
-  && pip install --user /tmp/pyarrow-*.whl \
  && pip install --user --no-cache-dir -r requirements.txt

 # Copy dependencies to runtime-image
--- a/docker/Dockerfile.custom
+++ b/docker/Dockerfile.custom
@ -7,5 +7,4 @@ FROM freqtradeorg/freqtrade:develop
 # The below dependency - pyti - serves as an example. Please use whatever you need!
 RUN pip install --user pyti

-# Switch back to user (only if you required root above)
 # USER ftuser
--- a/docker/Dockerfile.freqai
+++ b/docker/Dockerfile.freqai
@ -1,8 +0,0 @@
-ARG sourceimage=freqtradeorg/freqtrade
-ARG sourcetag=develop
-FROM ${sourceimage}:${sourcetag}
-
-# Install dependencies
-COPY requirements-freqai.txt /freqtrade/
-
-RUN pip install -r requirements-freqai.txt --user --no-cache-dir
--- a/docker/Dockerfile.freqai_rl
+++ b/docker/Dockerfile.freqai_rl
@ -1,8 +0,0 @@
-ARG sourceimage=freqtradeorg/freqtrade
-ARG sourcetag=develop_freqai
-FROM ${sourceimage}:${sourcetag}
-
-# Install dependencies
-COPY requirements-freqai.txt requirements-freqai-rl.txt /freqtrade/
-
-RUN pip install -r requirements-freqai-rl.txt --user --no-cache-dir
--- a/docker/Dockerfile.jupyter
+++ b/docker/Dockerfile.jupyter
@ -1,8 +1,7 @@
 FROM freqtradeorg/freqtrade:develop_plot


-# Pin jupyter-client to avoid tornado version conflict
-RUN pip install jupyterlab jupyter-client==7.3.4 --user --no-cache-dir
+RUN pip install jupyterlab --user --no-cache-dir

 # Empty the ENTRYPOINT to allow all commands
 ENTRYPOINT []
--- a/docker/docker-compose-jupyter.yml
+++ b/docker/docker-compose-jupyter.yml
@ -10,7 +10,7 @@ services:
    ports:
      - "127.0.0.1:8888:8888"
    volumes:
-      - "../user_data:/freqtrade/user_data"
+      - "./user_data:/freqtrade/user_data"
    # Default command used when running `docker compose up`
    command: >
      jupyter lab --port=8888 --ip 0.0.0.0 --allow-root
--- a/docs/advanced-backtesting.md
+++ b/docs/advanced-backtesting.md
@ -1,117 +0,0 @@
-# Advanced Backtesting Analysis
-
-## Analyze the buy/entry and sell/exit tags
-
-It can be helpful to understand how a strategy behaves according to the buy/entry tags used to
-mark up different buy conditions. You might want to see more complex statistics about each buy and
-sell condition above those provided by the default backtesting output. You may also want to
-determine indicator values on the signal candle that resulted in a trade opening.
-
-!!! Note
-    The following buy reason analysis is only available for backtesting, *not hyperopt*.
-
-We need to run backtesting with the `--export` option set to `signals` to enable the exporting of
-signals **and** trades:
-
-``` bash
-freqtrade backtesting -c <config.json> --timeframe <tf> --strategy <strategy_name> --timerange=<timerange> --export=signals
-```
-
-This will tell freqtrade to output a pickled dictionary of strategy, pairs and corresponding
-DataFrame of the candles that resulted in buy signals. Depending on how many buys your strategy
-makes, this file may get quite large, so periodically check your `user_data/backtest_results`
-folder to delete old exports.
-
-Before running your next backtest, make sure you either delete your old backtest results or run
-backtesting with the `--cache none` option to make sure no cached results are used.
-
-If all goes well, you should now see a `backtest-result-{timestamp}_signals.pkl` file in the
-`user_data/backtest_results` folder.
-
-To analyze the entry/exit tags, we now need to use the `freqtrade backtesting-analysis` command
-with `--analysis-groups` option provided with space-separated arguments (default `0 1 2`):
-
-``` bash
-freqtrade backtesting-analysis -c <config.json> --analysis-groups 0 1 2 3 4 5
-```
-
-This command will read from the last backtesting results. The `--analysis-groups` option is
-used to specify the various tabular outputs showing the profit fo each group or trade,
-ranging from the simplest (0) to the most detailed per pair, per buy and per sell tag (4):
-
-* 1: profit summaries grouped by enter_tag
-* 2: profit summaries grouped by enter_tag and exit_tag
-* 3: profit summaries grouped by pair and enter_tag
-* 4: profit summaries grouped by pair, enter_ and exit_tag (this can get quite large)
-* 5: profit summaries grouped by exit_tag
-
-More options are available by running with the `-h` option.
-
-### Using export-filename
-
-Normally, `backtesting-analysis` uses the latest backtest results, but if you wanted to go
-back to a previous backtest output, you need to supply the `--export-filename` option.
-You can supply the same parameter to `backtest-analysis` with the name of the final backtest
-output file. This allows you to keep historical versions of backtest results and re-analyse
-them at a later date:
-
-``` bash
-freqtrade backtesting -c <config.json> --timeframe <tf> --strategy <strategy_name> --timerange=<timerange> --export=signals --export-filename=/tmp/mystrat_backtest.json
-```
-
-You should see some output similar to below in the logs with the name of the timestamped
-filename that was exported:
-
-```
-2022-06-14 16:28:32,698 - freqtrade.misc - INFO - dumping json to "/tmp/mystrat_backtest-2022-06-14_16-28-32.json"
-```
-
-You can then use that filename in `backtesting-analysis`:
-
-```
-freqtrade backtesting-analysis -c <config.json> --export-filename=/tmp/mystrat_backtest-2022-06-14_16-28-32.json
-```
-
-### Tuning the buy tags and sell tags to display
-
-To show only certain buy and sell tags in the displayed output, use the following two options:
-
-```
--enter-reason-list : Space-separated list of enter signals to analyse. Default: "all"
--exit-reason-list : Space-separated list of exit signals to analyse. Default: "all"
-```
-
-For example:
-
-```bash
-freqtrade backtesting-analysis -c <config.json> --analysis-groups 0 2 --enter-reason-list enter_tag_a enter_tag_b --exit-reason-list roi custom_exit_tag_a stop_loss
-```
-
-### Outputting signal candle indicators
-
-The real power of `freqtrade backtesting-analysis` comes from the ability to print out the indicator
-values present on signal candles to allow fine-grained investigation and tuning of buy signal
-indicators. To print out a column for a given set of indicators, use the `--indicator-list`
-option:
-
-```bash
-freqtrade backtesting-analysis -c <config.json> --analysis-groups 0 2 --enter-reason-list enter_tag_a enter_tag_b --exit-reason-list roi custom_exit_tag_a stop_loss --indicator-list rsi rsi_1h bb_lowerband ema_9 macd macdsignal
-```
-
-The indicators have to be present in your strategy's main DataFrame (either for your main
-timeframe or for informative timeframes) otherwise they will simply be ignored in the script
-output.
-
-### Filtering the trade output by date
-
-To show only trades between dates within your backtested timerange, supply the usual `timerange` option in `YYYYMMDD-[YYYYMMDD]` format:
-
-```
--timerange : Timerange to filter output trades, start date inclusive, end date exclusive. e.g. 20220101-20221231
-```
-
-For example, if your backtest timerange was `20220101-20221231` but you only want to output trades in January:
-
-```bash
-freqtrade backtesting-analysis -c <config.json> --timerange 20220101-20220201
-```
--- a/docs/advanced-hyperopt.md
+++ b/docs/advanced-hyperopt.md
@ -17,7 +17,6 @@ from typing import Any, Dict

 from pandas import DataFrame

-from freqtrade.constants import Config
 from freqtrade.optimize.hyperopt import IHyperOptLoss

 TARGET_TRADES = 600
@ -32,7 +31,7 @@ class SuperDuperHyperOptLoss(IHyperOptLoss):
    @staticmethod
    def hyperopt_loss_function(results: DataFrame, trade_count: int,
                               min_date: datetime, max_date: datetime,
-                               config: Config, processed: Dict[str, DataFrame],
+                               config: Dict, processed: Dict[str, DataFrame],
                               backtest_stats: Dict[str, Any],
                               *args, **kwargs) -> float:
        """
@ -57,7 +56,7 @@ Currently, the arguments are:

 * `results`: DataFrame containing the resulting trades.
    The following columns are available in results (corresponds to the output-file of backtesting when used with `--export trades`):  
-    `pair, profit_ratio, profit_abs, open_date, open_rate, fee_open, close_date, close_rate, fee_close, amount, trade_duration, is_open, exit_reason, stake_amount, min_rate, max_rate, stop_loss_ratio, stop_loss_abs`
+    `pair, profit_ratio, profit_abs, open_date, open_rate, fee_open, close_date, close_rate, fee_close, amount, trade_duration, is_open, sell_reason, stake_amount, min_rate, max_rate, stop_loss_ratio, stop_loss_abs`
 * `trade_count`: Amount of trades (identical to `len(results)`)
 * `min_date`: Start date of the timerange used
 * `min_date`: End date of the timerange used
@ -75,11 +74,9 @@ This function needs to return a floating point number (`float`). Smaller numbers

 ## Overriding pre-defined spaces

-To override a pre-defined space (`roi_space`, `generate_roi_table`, `stoploss_space`, `trailing_space`, `max_open_trades_space`), define a nested class called Hyperopt and define the required spaces as follows:
+To override a pre-defined space (`roi_space`, `generate_roi_table`, `stoploss_space`, `trailing_space`), define a nested class called Hyperopt and define the required spaces as follows:

 ```python
-from freqtrade.optimize.space import Categorical, Dimension, Integer, SKDecimal
-
 class MyAwesomeStrategy(IStrategy):
    class HyperOpt:
        # Define a custom stoploss space.
@ -96,61 +93,11 @@ class MyAwesomeStrategy(IStrategy):
                SKDecimal(0.01, 0.07, decimals=3, name='roi_p2'),
                SKDecimal(0.01, 0.20, decimals=3, name='roi_p3'),
            ]
-
-        def generate_roi_table(params: Dict) -> Dict[int, float]:
-
-            roi_table = {}
-            roi_table[0] = params['roi_p1'] + params['roi_p2'] + params['roi_p3']
-            roi_table[params['roi_t3']] = params['roi_p1'] + params['roi_p2']
-            roi_table[params['roi_t3'] + params['roi_t2']] = params['roi_p1']
-            roi_table[params['roi_t3'] + params['roi_t2'] + params['roi_t1']] = 0
-
-            return roi_table
-
-        def trailing_space() -> List[Dimension]:
-            # All parameters here are mandatory, you can only modify their type or the range.
-            return [
-                # Fixed to true, if optimizing trailing_stop we assume to use trailing stop at all times.
-                Categorical([True], name='trailing_stop'),
-
-                SKDecimal(0.01, 0.35, decimals=3, name='trailing_stop_positive'),
-                # 'trailing_stop_positive_offset' should be greater than 'trailing_stop_positive',
-                # so this intermediate parameter is used as the value of the difference between
-                # them. The value of the 'trailing_stop_positive_offset' is constructed in the
-                # generate_trailing_params() method.
-                # This is similar to the hyperspace dimensions used for constructing the ROI tables.
-                SKDecimal(0.001, 0.1, decimals=3, name='trailing_stop_positive_offset_p1'),
-
-                Categorical([True, False], name='trailing_only_offset_is_reached'),
-        ]
-
-        # Define a custom max_open_trades space
-        def max_open_trades_space(self) -> List[Dimension]:
-            return [
-                Integer(-1, 10, name='max_open_trades'),
-            ]
 ```

 !!! Note
    All overrides are optional and can be mixed/matched as necessary.

-### Dynamic parameters
-
-Parameters can also be defined dynamically, but must be available to the instance once the * [`bot_start()` callback](strategy-callbacks.md#bot-start) has been called.
-
-``` python
-
-class MyAwesomeStrategy(IStrategy):
-
-    def bot_start(self, **kwargs) -> None:
-        self.buy_adx = IntParameter(20, 30, default=30, optimize=True)
-
-    # ...
-```
-
-!!! Warning
-    Parameters created this way will not show up in the `list-strategies` parameter count.
-
 ### Overriding Base estimator

 You can define your own estimator for Hyperopt by implementing `generate_estimator()` in the Hyperopt subclass.
--- a/docs/advanced-setup.md
+++ b/docs/advanced-setup.md
@ -192,7 +192,7 @@ $RepeatedMsgReduction on

 ### Logging to journald

-This needs the `cysystemd` python package installed as dependency (`pip install cysystemd`), which is not available on Windows. Hence, the whole journald logging functionality is not available for a bot running on Windows.
+This needs the `systemd` python package installed as the dependency, which is not available on Windows. Hence, the whole journald logging functionality is not available for a bot running on Windows.

 To send Freqtrade log messages to `journald` system service use the `--logfile` command line option with the value in the following format:

--- a/docs/assets/binance_futures_settings.png
+++ b/docs/assets/binance_futures_settings.png
--- a/docs/assets/discord_notification.png
+++ b/docs/assets/discord_notification.png
--- a/docs/assets/freqai_DI.jpg
+++ b/docs/assets/freqai_DI.jpg
--- a/docs/assets/freqai_algo.jpg
+++ b/docs/assets/freqai_algo.jpg
--- a/docs/assets/freqai_algorithm-diagram.jpg
+++ b/docs/assets/freqai_algorithm-diagram.jpg
--- a/docs/assets/freqai_dbscan.jpg
+++ b/docs/assets/freqai_dbscan.jpg
--- a/docs/assets/freqai_doc_logo.svg
+++ b/docs/assets/freqai_doc_logo.svg
--- a/docs/assets/freqai_inlier-metric.jpg
+++ b/docs/assets/freqai_inlier-metric.jpg
--- a/docs/assets/freqai_moving-window.jpg
+++ b/docs/assets/freqai_moving-window.jpg
--- a/docs/assets/freqai_pytorch-diagram.png
+++ b/docs/assets/freqai_pytorch-diagram.png
--- a/docs/assets/freqai_weight-factor.jpg
+++ b/docs/assets/freqai_weight-factor.jpg
--- a/docs/assets/tensorboard.jpg
+++ b/docs/assets/tensorboard.jpg
--- a/docs/backtesting.md
+++ b/docs/backtesting.md
@ -20,14 +20,13 @@ usage: freqtrade backtesting [-h] [-v] [--logfile FILE] [-V] [-c PATH]
                             [--dry-run-wallet DRY_RUN_WALLET]
                             [--timeframe-detail TIMEFRAME_DETAIL]
                             [--strategy-list STRATEGY_LIST [STRATEGY_LIST ...]]
-                             [--export {none,trades,signals}]
-                             [--export-filename PATH]
+                             [--export {none,trades}] [--export-filename PATH]
                             [--breakdown {day,week,month} [{day,week,month} ...]]
                             [--cache {none,day,week,month}]

 optional arguments:
  -h, --help            show this help message and exit
-  -i TIMEFRAME, --timeframe TIMEFRAME
+  -i TIMEFRAME, --timeframe TIMEFRAME, --ticker-interval TIMEFRAME
                        Specify timeframe (`1m`, `5m`, `30m`, `1h`, `1d`).
  --timerange TIMERANGE
                        Specify what timerange of data to use.
@ -64,17 +63,18 @@ optional arguments:
                        `30m`, `1h`, `1d`).
  --strategy-list STRATEGY_LIST [STRATEGY_LIST ...]
                        Provide a space-separated list of strategies to
-                        backtest. Please note that timeframe needs to be set
-                        either in config or via command line. When using this
-                        together with `--export trades`, the strategy-name is
-                        injected into the filename (so `backtest-data.json`
-                        becomes `backtest-data-SampleStrategy.json`
-  --export {none,trades,signals}
+                        backtest. Please note that ticker-interval needs to be
+                        set either in config or via command line. When using
+                        this together with `--export trades`, the strategy-
+                        name is injected into the filename (so `backtest-
+                        data.json` becomes `backtest-data-SampleStrategy.json`
+  --export {none,trades}
                        Export backtest results (default: trades).
-  --export-filename PATH, --backtest-filename PATH
-                        Use this filename for backtest results.Requires
-                        `--export` to be set as well. Example: `--export-filen
-                        ame=user_data/backtest_results/backtest_today.json`
+  --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`
  --breakdown {day,week,month} [{day,week,month} ...]
                        Show backtesting breakdown per [day, week, month].
  --cache {none,day,week,month}
@ -107,7 +107,7 @@ Strategy arguments:

 ## Test your strategy with Backtesting

-Now you have good Entry and exit strategies and some historic data, you want to test it against
+Now you have good Buy and Sell strategies and some historic data, you want to test it against
 real data. This is what we call [backtesting](https://en.wikipedia.org/wiki/Backtesting).

 Backtesting will use the crypto-currencies (pairs) from your config file and load historical candle (OHLCV) data from `user_data/data/<exchange>` by default.
@ -215,7 +215,7 @@ Sometimes your account has certain fee rebates (fee reductions starting with a c
 To account for this in backtesting, you can use the `--fee` command line option to supply this value to backtesting.
 This fee must be a ratio, and will be applied twice (once for trade entry, and once for trade exit).

-For example, if the commission fee per order is 0.1% (i.e., 0.001 written as ratio), then you would run backtesting as the following:
+For example, if the buying and selling commission fee is 0.1% (i.e., 0.001 written as ratio), then you would run backtesting as the following:

 ```bash
 freqtrade backtesting --fee 0.001
@ -252,95 +252,79 @@ The most important in the backtesting is to understand the result.
 A backtesting result will look like that:

 ```
-========================================================= BACKTESTING REPORT =========================================================
-| Pair     | Entries |   Avg Profit % |   Cum Profit % |   Tot Profit BTC |   Tot Profit % | Avg Duration |  Wins Draws Loss   Win%  |
-|:---------|--------:|---------------:|---------------:|-----------------:|---------------:|:-------------|-------------------------:|
-| ADA/BTC  |      35 |          -0.11 |          -3.88 |      -0.00019428 |          -1.94 | 4:35:00      |    14     0    21   40.0 |
-| ARK/BTC  |      11 |          -0.41 |          -4.52 |      -0.00022647 |          -2.26 | 2:03:00      |     3     0     8   27.3 |
-| BTS/BTC  |      32 |           0.31 |           9.78 |       0.00048938 |           4.89 | 5:05:00      |    18     0    14   56.2 |
-| DASH/BTC |      13 |          -0.08 |          -1.07 |      -0.00005343 |          -0.53 | 4:39:00      |     6     0     7   46.2 |
-| ENG/BTC  |      18 |           1.36 |          24.54 |       0.00122807 |          12.27 | 2:50:00      |     8     0    10   44.4 |
-| EOS/BTC  |      36 |           0.08 |           3.06 |       0.00015304 |           1.53 | 3:34:00      |    16     0    20   44.4 |
-| ETC/BTC  |      26 |           0.37 |           9.51 |       0.00047576 |           4.75 | 6:14:00      |    11     0    15   42.3 |
-| ETH/BTC  |      33 |           0.30 |           9.96 |       0.00049856 |           4.98 | 7:31:00      |    16     0    17   48.5 |
-| IOTA/BTC |      32 |           0.03 |           1.09 |       0.00005444 |           0.54 | 3:12:00      |    14     0    18   43.8 |
-| LSK/BTC  |      15 |           1.75 |          26.26 |       0.00131413 |          13.13 | 2:58:00      |     6     0     9   40.0 |
-| LTC/BTC  |      32 |          -0.04 |          -1.38 |      -0.00006886 |          -0.69 | 4:49:00      |    11     0    21   34.4 |
-| NANO/BTC |      17 |           1.26 |          21.39 |       0.00107058 |          10.70 | 1:55:00      |    10     0     7   58.5 |
-| NEO/BTC  |      23 |           0.82 |          18.97 |       0.00094936 |           9.48 | 2:59:00      |    10     0    13   43.5 |
-| REQ/BTC  |       9 |           1.17 |          10.54 |       0.00052734 |           5.27 | 3:47:00      |     4     0     5   44.4 |
-| XLM/BTC  |      16 |           1.22 |          19.54 |       0.00097800 |           9.77 | 3:15:00      |     7     0     9   43.8 |
-| XMR/BTC  |      23 |          -0.18 |          -4.13 |      -0.00020696 |          -2.07 | 5:30:00      |    12     0    11   52.2 |
-| XRP/BTC  |      35 |           0.66 |          22.96 |       0.00114897 |          11.48 | 3:49:00      |    12     0    23   34.3 |
-| ZEC/BTC  |      22 |          -0.46 |         -10.18 |      -0.00050971 |          -5.09 | 2:22:00      |     7     0    15   31.8 |
-| TOTAL    |     429 |           0.36 |         152.41 |       0.00762792 |          76.20 | 4:12:00      |   186     0   243   43.4 |
-====================================================== LEFT OPEN TRADES REPORT ======================================================
-| Pair     |  Entries |   Avg Profit % |   Cum Profit % |   Tot Profit BTC |   Tot Profit % | Avg Duration   |  Win Draw Loss Win% |
-|:---------|---------:|---------------:|---------------:|-----------------:|---------------:|:---------------|--------------------:|
-| ADA/BTC  |        1 |           0.89 |           0.89 |       0.00004434 |           0.44 | 6:00:00        |    1    0    0  100 |
-| LTC/BTC  |        1 |           0.68 |           0.68 |       0.00003421 |           0.34 | 2:00:00        |    1    0    0  100 |
-| TOTAL    |        2 |           0.78 |           1.57 |       0.00007855 |           0.78 | 4:00:00        |    2    0    0  100 |
-==================== EXIT REASON STATS ====================
-| Exit Reason        |   Exits |  Wins |  Draws |  Losses |
+========================================================= BACKTESTING REPORT ==========================================================
+| Pair     |   Buys |   Avg Profit % |   Cum Profit % |   Tot Profit BTC |   Tot Profit % | Avg Duration |  Wins Draws Loss   Win%  |
+|:---------|-------:|---------------:|---------------:|-----------------:|---------------:|:-------------|-------------------------:|
+| ADA/BTC  |     35 |          -0.11 |          -3.88 |      -0.00019428 |          -1.94 | 4:35:00      |    14     0    21   40.0 |
+| ARK/BTC  |     11 |          -0.41 |          -4.52 |      -0.00022647 |          -2.26 | 2:03:00      |     3     0     8   27.3 |
+| BTS/BTC  |     32 |           0.31 |           9.78 |       0.00048938 |           4.89 | 5:05:00      |    18     0    14   56.2 |
+| DASH/BTC |     13 |          -0.08 |          -1.07 |      -0.00005343 |          -0.53 | 4:39:00      |     6     0     7   46.2 |
+| ENG/BTC  |     18 |           1.36 |          24.54 |       0.00122807 |          12.27 | 2:50:00      |     8     0    10   44.4 |
+| EOS/BTC  |     36 |           0.08 |           3.06 |       0.00015304 |           1.53 | 3:34:00      |    16     0    20   44.4 |
+| ETC/BTC  |     26 |           0.37 |           9.51 |       0.00047576 |           4.75 | 6:14:00      |    11     0    15   42.3 |
+| ETH/BTC  |     33 |           0.30 |           9.96 |       0.00049856 |           4.98 | 7:31:00      |    16     0    17   48.5 |
+| IOTA/BTC |     32 |           0.03 |           1.09 |       0.00005444 |           0.54 | 3:12:00      |    14     0    18   43.8 |
+| LSK/BTC  |     15 |           1.75 |          26.26 |       0.00131413 |          13.13 | 2:58:00      |     6     0     9   40.0 |
+| LTC/BTC  |     32 |          -0.04 |          -1.38 |      -0.00006886 |          -0.69 | 4:49:00      |    11     0    21   34.4 |
+| NANO/BTC |     17 |           1.26 |          21.39 |       0.00107058 |          10.70 | 1:55:00      |    10     0     7   58.5 |
+| NEO/BTC  |     23 |           0.82 |          18.97 |       0.00094936 |           9.48 | 2:59:00      |    10     0    13   43.5 |
+| REQ/BTC  |      9 |           1.17 |          10.54 |       0.00052734 |           5.27 | 3:47:00      |     4     0     5   44.4 |
+| XLM/BTC  |     16 |           1.22 |          19.54 |       0.00097800 |           9.77 | 3:15:00      |     7     0     9   43.8 |
+| XMR/BTC  |     23 |          -0.18 |          -4.13 |      -0.00020696 |          -2.07 | 5:30:00      |    12     0    11   52.2 |
+| XRP/BTC  |     35 |           0.66 |          22.96 |       0.00114897 |          11.48 | 3:49:00      |    12     0    23   34.3 |
+| ZEC/BTC  |     22 |          -0.46 |         -10.18 |      -0.00050971 |          -5.09 | 2:22:00      |     7     0    15   31.8 |
+| TOTAL    |    429 |           0.36 |         152.41 |       0.00762792 |          76.20 | 4:12:00      |   186     0   243   43.4 |
+========================================================= SELL REASON STATS ==========================================================
+| Sell Reason        |   Sells |  Wins |  Draws |  Losses |
 |:-------------------|--------:|------:|-------:|--------:|
 | trailing_stop_loss |     205 |   150 |      0 |      55 |
 | stop_loss          |     166 |     0 |      0 |     166 |
-| exit_signal        |      56 |    36 |      0 |      20 |
-| force_exit         |       2 |     0 |      0 |       2 |
-
-================== SUMMARY METRICS ==================
-| Metric                      | Value               |
-|-----------------------------+---------------------|
-| Backtesting from            | 2019-01-01 00:00:00 |
-| Backtesting to              | 2019-05-01 00:00:00 |
-| Max open trades             | 3                   |
-|                             |                     |
-| Total/Daily Avg Trades      | 429 / 3.575         |
-| Starting balance            | 0.01000000 BTC      |
-| Final balance               | 0.01762792 BTC      |
-| Absolute profit             | 0.00762792 BTC      |
-| Total profit %              | 76.2%               |
-| CAGR %                      | 460.87%             |
-| Sortino                     | 1.88                |
-| Sharpe                      | 2.97                |
-| Calmar                      | 6.29                |
-| Profit factor               | 1.11                |
-| Expectancy                  | -0.15               |
-| Avg. stake amount           | 0.001      BTC      |
-| Total trade volume          | 0.429      BTC      |
-|                             |                     |
-| Long / Short                | 352 / 77            |
-| Total profit Long %         | 1250.58%            |
-| Total profit Short %        | -15.02%             |
-| Absolute profit Long        | 0.00838792 BTC      |
-| Absolute profit Short       | -0.00076 BTC        |
-|                             |                     |
-| Best Pair                   | LSK/BTC 26.26%      |
-| Worst Pair                  | ZEC/BTC -10.18%     |
-| Best Trade                  | LSK/BTC 4.25%       |
-| Worst Trade                 | ZEC/BTC -10.25%     |
-| Best day                    | 0.00076 BTC         |
-| Worst day                   | -0.00036 BTC        |
-| Days win/draw/lose          | 12 / 82 / 25        |
-| Avg. Duration Winners       | 4:23:00             |
-| Avg. Duration Loser         | 6:55:00             |
-| Rejected Entry signals      | 3089                |
-| Entry/Exit Timeouts         | 0 / 0               |
-| Canceled Trade Entries      | 34                  |
-| Canceled Entry Orders       | 123                 |
-| Replaced Entry Orders       | 89                  |
-|                             |                     |
-| Min balance                 | 0.00945123 BTC      |
-| Max balance                 | 0.01846651 BTC      |
-| Max % of account underwater | 25.19%              |
-| Absolute Drawdown (Account) | 13.33%              |
-| Drawdown                    | 0.0015 BTC          |
-| Drawdown high               | 0.0013 BTC          |
-| Drawdown low                | -0.0002 BTC         |
-| Drawdown Start              | 2019-02-15 14:10:00 |
-| Drawdown End                | 2019-04-11 18:15:00 |
-| Market change               | -5.88%              |
-=====================================================
+| sell_signal        |      56 |    36 |      0 |      20 |
+| force_sell         |       2 |     0 |      0 |       2 |
+====================================================== LEFT OPEN TRADES REPORT ======================================================
+| Pair     |   Buys |   Avg Profit % |   Cum Profit % |   Tot Profit BTC |   Tot Profit % | Avg Duration   |  Win Draw Loss Win% |
+|:---------|-------:|---------------:|---------------:|-----------------:|---------------:|:---------------|--------------------:|
+| ADA/BTC  |      1 |           0.89 |           0.89 |       0.00004434 |           0.44 | 6:00:00        |    1    0    0  100 |
+| LTC/BTC  |      1 |           0.68 |           0.68 |       0.00003421 |           0.34 | 2:00:00        |    1    0    0  100 |
+| TOTAL    |      2 |           0.78 |           1.57 |       0.00007855 |           0.78 | 4:00:00        |    2    0    0  100 |
+=============== SUMMARY METRICS ===============
+| Metric                | Value               |
+|-----------------------+---------------------|
+| Backtesting from      | 2019-01-01 00:00:00 |
+| Backtesting to        | 2019-05-01 00:00:00 |
+| Max open trades       | 3                   |
+|                       |                     |
+| Total/Daily Avg Trades| 429 / 3.575         |
+| Starting balance      | 0.01000000 BTC      |
+| Final balance         | 0.01762792 BTC      |
+| Absolute profit       | 0.00762792 BTC      |
+| Total profit %        | 76.2%               |
+| Trades per day        | 3.575               |
+| Avg. stake amount     | 0.001      BTC      |
+| Total trade volume    | 0.429      BTC      |
+|                       |                     |
+| Best Pair             | LSK/BTC 26.26%      |
+| Worst Pair            | ZEC/BTC -10.18%     |
+| Best Trade            | LSK/BTC 4.25%       |
+| Worst Trade           | ZEC/BTC -10.25%     |
+| Best day              | 0.00076 BTC         |
+| Worst day             | -0.00036 BTC        |
+| Days win/draw/lose    | 12 / 82 / 25        |
+| Avg. Duration Winners | 4:23:00             |
+| Avg. Duration Loser   | 6:55:00             |
+| Rejected Buy signals  | 3089                |
+| Entry/Exit Timeouts   | 0 / 0               |
+|                       |                     |
+| Min balance           | 0.00945123 BTC      |
+| Max balance           | 0.01846651 BTC      |
+| Drawdown (Account)    | 13.33%              |
+| Drawdown              | 0.0015 BTC          |
+| Drawdown high         | 0.0013 BTC          |
+| Drawdown low          | -0.0002 BTC         |
+| Drawdown Start        | 2019-02-15 14:10:00 |
+| Drawdown End          | 2019-04-11 18:15:00 |
+| Market change         | -5.88%              |
+===============================================
 ```

 ### Backtesting report table
@ -361,9 +345,9 @@ The column `Avg Profit %` shows the average profit for all trades made while the
 The column `Tot Profit %` shows instead the total profit % in relation to the starting balance.
 In the above results, we have a starting balance of 0.01 BTC and an absolute profit of 0.00762792 BTC - so the `Tot Profit %` will be `(0.00762792 / 0.01) * 100 ~= 76.2%`.

-Your strategy performance is influenced by your entry strategy, your exit strategy, and also by the `minimal_roi` and `stop_loss` you have set.
+Your strategy performance is influenced by your buy strategy, your sell strategy, and also by the `minimal_roi` and `stop_loss` you have set.

-For example, if your `minimal_roi` is only `"0":  0.01` you cannot expect the bot to make more profit than 1% (because it will exit every time a trade reaches 1%).
+For example, if your `minimal_roi` is only `"0":  0.01` you cannot expect the bot to make more profit than 1% (because it will sell every time a trade reaches 1%).

 ```json
 "minimal_roi": {
@ -375,14 +359,14 @@ On the other hand, if you set a too high `minimal_roi` like `"0":  0.55`
 (55%), there is almost no chance that the bot will ever reach this profit.
 Hence, keep in mind that your performance is an integral mix of all different elements of the strategy, your configuration, and the crypto-currency pairs you have set up.

-### Exit reasons table
+### Sell reasons table

-The 2nd table contains a recap of exit reasons.
-This table can tell you which area needs some additional work (e.g. all or many of the `exit_signal` trades are losses, so you should work on improving the exit signal, or consider disabling it).
+The 2nd table contains a recap of sell reasons.
+This table can tell you which area needs some additional work (e.g. all or many of the `sell_signal` trades are losses, so you should work on improving the sell signal, or consider disabling it).

 ### Left open trades table

-The 3rd table contains all trades the bot had to `force_exit` at the end of the backtesting period to present you the full picture.
+The 3rd table contains all trades the bot had to `forcesell` at the end of the backtesting period to present you the full picture.
 This is necessary to simulate realistic behavior, since the backtest period has to end at some point, while realistically, you could leave the bot running forever.
 These trades are also included in the first table, but are also shown separately in this table for clarity.

@ -392,59 +376,43 @@ The last element of the backtest report is the summary metrics table.
 It contains some useful key metrics about performance of your strategy on backtesting data.

 ```
-================== SUMMARY METRICS ==================
-| Metric                      | Value               |
-|-----------------------------+---------------------|
-| Backtesting from            | 2019-01-01 00:00:00 |
-| Backtesting to              | 2019-05-01 00:00:00 |
-| Max open trades             | 3                   |
-|                             |                     |
-| Total/Daily Avg Trades      | 429 / 3.575         |
-| Starting balance            | 0.01000000 BTC      |
-| Final balance               | 0.01762792 BTC      |
-| Absolute profit             | 0.00762792 BTC      |
-| Total profit %              | 76.2%               |
-| CAGR %                      | 460.87%             |
-| Sortino                     | 1.88                |
-| Sharpe                      | 2.97                |
-| Calmar                      | 6.29                |
-| Profit factor               | 1.11                |
-| Expectancy                  | -0.15               |
-| Avg. stake amount           | 0.001      BTC      |
-| Total trade volume          | 0.429      BTC      |
-|                             |                     |
-| Long / Short                | 352 / 77            |
-| Total profit Long %         | 1250.58%            |
-| Total profit Short %        | -15.02%             |
-| Absolute profit Long        | 0.00838792 BTC      |
-| Absolute profit Short       | -0.00076 BTC        |
-|                             |                     |
-| Best Pair                   | LSK/BTC 26.26%      |
-| Worst Pair                  | ZEC/BTC -10.18%     |
-| Best Trade                  | LSK/BTC 4.25%       |
-| Worst Trade                 | ZEC/BTC -10.25%     |
-| Best day                    | 0.00076 BTC         |
-| Worst day                   | -0.00036 BTC        |
-| Days win/draw/lose          | 12 / 82 / 25        |
-| Avg. Duration Winners       | 4:23:00             |
-| Avg. Duration Loser         | 6:55:00             |
-| Rejected Entry signals      | 3089                |
-| Entry/Exit Timeouts         | 0 / 0               |
-| Canceled Trade Entries      | 34                  |
-| Canceled Entry Orders       | 123                 |
-| Replaced Entry Orders       | 89                  |
-|                             |                     |
-| Min balance                 | 0.00945123 BTC      |
-| Max balance                 | 0.01846651 BTC      |
-| Max % of account underwater | 25.19%              |
-| Absolute Drawdown (Account) | 13.33%              |
-| Drawdown                    | 0.0015 BTC          |
-| Drawdown high               | 0.0013 BTC          |
-| Drawdown low                | -0.0002 BTC         |
-| Drawdown Start              | 2019-02-15 14:10:00 |
-| Drawdown End                | 2019-04-11 18:15:00 |
-| Market change               | -5.88%              |
-=====================================================
+=============== SUMMARY METRICS ===============
+| Metric                | Value               |
+|-----------------------+---------------------|
+| Backtesting from      | 2019-01-01 00:00:00 |
+| Backtesting to        | 2019-05-01 00:00:00 |
+| Max open trades       | 3                   |
+|                       |                     |
+| Total/Daily Avg Trades| 429 / 3.575         |
+| Starting balance      | 0.01000000 BTC      |
+| Final balance         | 0.01762792 BTC      |
+| Absolute profit       | 0.00762792 BTC      |
+| Total profit %        | 76.2%               |
+| Avg. stake amount     | 0.001      BTC      |
+| Total trade volume    | 0.429      BTC      |
+|                       |                     |
+| Best Pair             | LSK/BTC 26.26%      |
+| Worst Pair            | ZEC/BTC -10.18%     |
+| Best Trade            | LSK/BTC 4.25%       |
+| Worst Trade           | ZEC/BTC -10.25%     |
+| Best day              | 0.00076 BTC         |
+| Worst day             | -0.00036 BTC        |
+| Days win/draw/lose    | 12 / 82 / 25        |
+| Avg. Duration Winners | 4:23:00             |
+| Avg. Duration Loser   | 6:55:00             |
+| Rejected Buy signals  | 3089                |
+| Entry/Exit Timeouts   | 0 / 0               |
+|                       |                     |
+| Min balance           | 0.00945123 BTC      |
+| Max balance           | 0.01846651 BTC      |
+| Drawdown (Account)    | 13.33%              |
+| Drawdown              | 0.0015 BTC          |
+| Drawdown high         | 0.0013 BTC          |
+| Drawdown low          | -0.0002 BTC         |
+| Drawdown Start        | 2019-02-15 14:10:00 |
+| Drawdown End          | 2019-04-11 18:15:00 |
+| Market change         | -5.88%              |
+===============================================

 ```

@ -455,11 +423,6 @@ It contains some useful key metrics about performance of your strategy on backte
 - `Final balance`: Final balance - starting balance + absolute profit.
 - `Absolute profit`: Profit made in stake currency.
 - `Total profit %`: Total profit. Aligned to the `TOTAL` row's `Tot Profit %` from the first table. Calculated as `(End capital − Starting capital) / Starting capital`.
- `CAGR %`: Compound annual growth rate.
- `Sortino`: Annualized Sortino ratio.
- `Sharpe`: Annualized Sharpe ratio.
- `Calmar`: Annualized Calmar ratio.
- `Profit factor`: profit / loss.
 - `Avg. stake amount`: Average stake amount, either `stake_amount` or the average when using dynamic stake amount.
 - `Total trade volume`: Volume generated on the exchange to reach the above profit.
 - `Best Pair` / `Worst Pair`: Best and worst performing pair, and it's corresponding `Cum Profit %`.
@ -467,22 +430,14 @@ It contains some useful key metrics about performance of your strategy on backte
 - `Best day` / `Worst day`: Best and worst day based on daily profit.
 - `Days win/draw/lose`: Winning / Losing days (draws are usually days without closed trade).
 - `Avg. Duration Winners` / `Avg. Duration Loser`: Average durations for winning and losing trades.
- `Rejected Entry signals`: Trade entry signals that could not be acted upon due to `max_open_trades` being reached.
+- `Rejected Buy signals`: Buy signals that could not be acted upon due to max_open_trades being reached.
 - `Entry/Exit Timeouts`: Entry/exit orders which did not fill (only applicable if custom pricing is used).
- `Canceled Trade Entries`: Number of trades that have been canceled by user request via `adjust_entry_price`.
- `Canceled Entry Orders`: Number of entry orders that have been canceled by user request via `adjust_entry_price`.
- `Replaced Entry Orders`: Number of entry orders that have been replaced by user request via `adjust_entry_price`.
 - `Min balance` / `Max balance`: Lowest and Highest Wallet balance during the backtest period.
- `Max % of account underwater`: Maximum percentage your account has decreased from the top since the simulation started.
-Calculated as the maximum of `(Max Balance - Current Balance) / (Max Balance)`.
- `Absolute Drawdown (Account)`: Maximum Account Drawdown experienced. Calculated as `(Absolute Drawdown) / (DrawdownHigh + startingBalance)`.
+- `Drawdown (Account)`: Maximum Account Drawdown experienced. Calculated as $(Absolute Drawdown) / (DrawdownHigh + startingBalance)$.
 - `Drawdown`: Maximum, absolute drawdown experienced. Difference between Drawdown High and Subsequent Low point.
 - `Drawdown high` / `Drawdown low`: Profit at the beginning and end of the largest drawdown period. A negative low value means initial capital lost.
 - `Drawdown Start` / `Drawdown End`: Start and end datetime for this largest drawdown (can also be visualized via the `plot-dataframe` sub-command).
 - `Market change`: Change of the market during the backtest period. Calculated as average of all pairs changes from the first to the last candle using the "close" column.
- `Long / Short`: Split long/short values (Only shown when short trades were made).
- `Total profit Long %` / `Absolute profit Long`: Profit long trades only (Only shown when short trades were made).
- `Total profit Short %` / `Absolute profit Short`: Profit short trades only (Only shown when short trades were made).

 ### Daily / Weekly / Monthly breakdown

@ -491,7 +446,7 @@ You can get an overview over daily / weekly or monthly results by using the `--b
 To visualize daily and weekly breakdowns, you can use the following:

 ``` bash
-freqtrade backtesting --strategy MyAwesomeStrategy --breakdown day week
+freqtrade backtesting --strategy MyAwesomeStrategy --breakdown day month
 ```

 ``` output
@ -507,7 +462,7 @@ freqtrade backtesting --strategy MyAwesomeStrategy --breakdown day week

 ```

-The output will show a table containing the realized absolute Profit (in stake currency) for the given timeperiod, as well as wins, draws and losses that materialized (closed) on this day. Below that there will be a second table for the summarized values of weeks indicated by the date of the closing Sunday. The same would apply to a monthly breakdown indicated by the last day of the month.
+The output will show a table containing the realized absolute Profit (in stake currency) for the given timeperiod, as well as wins, draws and losses that materialized (closed) on this day.

 ### Backtest result caching

@ -526,62 +481,35 @@ You can then load the trades to perform further analysis as shown in the [data a

 Since backtesting lacks some detailed information about what happens within a candle, it needs to take a few assumptions:

- Exchange [trading limits](#trading-limits-in-backtesting) are respected
- Entries happen at open-price
+- Buys happen at open-price
 - All orders are filled at the requested price (no slippage, no unfilled orders)
- Exit-signal exits happen at open-price of the consecutive candle
- Exit-signal is favored over Stoploss, because exit-signals are assumed to trigger on candle's open
+- Sell-signal sells happen at open-price of the consecutive candle
+- Sell-signal is favored over Stoploss, because sell-signals are assumed to trigger on candle's open
 - ROI
-  - exits are compared to high - but the ROI value is used (e.g. ROI = 2%, high=5% - so the exit will be at 2%)
-  - exits are never "below the candle", so a ROI of 2% may result in a exit at 2.4% if low was at 2.4% profit
-  - Force-exits caused by `<N>=-1` ROI entries use low as exit value, unless N falls on the candle open (e.g. `120: -1` for 1h candles)
- Stoploss exits happen exactly at stoploss price, even if low was lower, but the loss will be `2 * fees` higher than the stoploss price
- Stoploss is evaluated before ROI within one candle. So you can often see more trades with the `stoploss` exit reason comparing to the results obtained with the same strategy in the Dry Run/Live Trade modes
+  - sells are compared to high - but the ROI value is used (e.g. ROI = 2%, high=5% - so the sell will be at 2%)
+  - sells are never "below the candle", so a ROI of 2% may result in a sell at 2.4% if low was at 2.4% profit
+  - Forcesells caused by `<N>=-1` ROI entries use low as sell value, unless N falls on the candle open (e.g. `120: -1` for 1h candles)
+- Stoploss sells happen exactly at stoploss price, even if low was lower, but the loss will be `2 * fees` higher than the stoploss price
+- Stoploss is evaluated before ROI within one candle. So you can often see more trades with the `stoploss` sell reason comparing to the results obtained with the same strategy in the Dry Run/Live Trade modes
 - 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. This rule is NOT applicable to custom-stoploss scenarios, since there's no information about the stoploss logic available.
+  - 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 exits with large high-low difference are backtested correctly)
+  - 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
- Exit-reason does not explain if a trade was positive or negative, just what triggered the exit (this can look odd if negative ROI values are used)
+- Sell-reason does not explain if a trade was positive or negative, just what triggered the sell (this can look odd if negative ROI values are used)
 - Evaluation sequence (if multiple signals happen on the same candle)
-  - Exit-signal
+  - Sell-signal
+  - ROI (if not stoploss)
  - Stoploss
-  - ROI
-  - Trailing stoploss

 Taking these assumptions, backtesting tries to mirror real trading as closely as possible. However, backtesting will **never** replace running a strategy in dry-run mode.
 Also, keep in mind that past results don't guarantee future success.

 In addition to the above assumptions, strategy authors should carefully read the [Common Mistakes](strategy-customization.md#common-mistakes-when-developing-strategies) section, to avoid using data in backtesting which is not available in real market conditions.

-### Trading limits in backtesting
-
-Exchanges have certain trading limits, like minimum (and maximum) base currency, or minimum/maximum stake (quote) currency.
-These limits are usually listed in the exchange documentation as "trading rules" or similar and can be quite different between different pairs.
-
-Backtesting (as well as live and dry-run) does honor these limits, and will ensure that a stoploss can be placed below this value - so the value will be slightly higher than what the exchange specifies.
-Freqtrade has however no information about historic limits.
-
-This can lead to situations where trading-limits are inflated by using a historic price, resulting in minimum amounts > 50$.
-
-For example:
-
-BTC minimum tradable amount is 0.001.
-BTC trades at 22.000\$ today (0.001 BTC is related to this) - but the backtesting period includes prices as high as 50.000\$.
-Today's minimum would be `0.001 * 22_000` - or 22\$.  
-However the limit could also be 50$ - based on `0.001 * 50_000` in some historic setting.
-
-#### Trading precision limits
-
-Most exchanges pose precision limits on both price and amounts, so you cannot buy 1.0020401 of a pair, or at a price of 1.24567123123.  
-Instead, these prices and amounts will be rounded or truncated (based on the exchange definition) to the defined trading precision.
-The above values may for example be rounded to an amount of 1.002, and a price of 1.24567.
-
-These precision values are based on current exchange limits (as described in the [above section](#trading-limits-in-backtesting)), as historic precision limits are not available.
-
-## Improved backtest accuracy
+### Improved backtest accuracy

 One big limitation of backtesting is it's inability to know how prices moved intra-candle (was high before close, or viceversa?).
 So assuming you run backtesting with a 1h timeframe, there will be 4 prices for that candle (Open, High, Low, Close).
@ -595,9 +523,8 @@ To utilize this, you can append `--timeframe-detail 5m` to your regular backtest
 freqtrade backtesting --strategy AwesomeStrategy --timeframe 1h --timeframe-detail 5m
 ```

-This will load 1h data as well as 5m data for the timeframe. The strategy will be analyzed with the 1h timeframe, and Entry orders will only be placed at the main timeframe, however Order fills and exit signals will be evaluated at the 5m candle, simulating intra-candle movements.
-
-All callback functions (`custom_exit()`, `custom_stoploss()`, ... ) will be running for each 5m candle once the trade is opened (so 12 times in the above example of 1h timeframe, and 5m detailed timeframe).
+This will load 1h data as well as 5m data for the timeframe. The strategy will be analyzed with the 1h timeframe - and for every "open trade candle" (candles where a trade is open) the 5m data will be used to simulate intra-candle movements.
+All callback functions (`custom_sell()`, `custom_stoploss()`, ... ) will be running for each 5m candle once the trade is opened (so 12 times in the above example of 1h timeframe, and 5m detailed timeframe).

 `--timeframe-detail` must be smaller than the original timeframe, otherwise backtesting will fail to start.

@ -625,11 +552,11 @@ There will be an additional table comparing win/losses of the different strategi
 Detailed output for all strategies one after the other will be available, so make sure to scroll up to see the details per strategy.

 ```
-=========================================================== STRATEGY SUMMARY ===========================================================================
-| Strategy    |  Entries |   Avg Profit % |   Cum Profit % |   Tot Profit BTC |   Tot Profit % | Avg Duration   |  Wins |  Draws | Losses | Drawdown % |
-|:------------|---------:|---------------:|---------------:|-----------------:|---------------:|:---------------|------:|-------:|-------:|-----------:|
-| Strategy1   |      429 |           0.36 |         152.41 |       0.00762792 |          76.20 | 4:12:00        |   186 |      0 |    243 |       45.2 |
-| Strategy2   |     1487 |          -0.13 |        -197.58 |      -0.00988917 |         -98.79 | 4:43:00        |   662 |      0 |    825 |     241.68 |
+=========================================================== STRATEGY SUMMARY =========================================================================
+| Strategy    |   Buys |   Avg Profit % |   Cum Profit % |   Tot Profit BTC |   Tot Profit % | Avg Duration   |  Wins |  Draws | Losses | Drawdown % |
+|:------------|-------:|---------------:|---------------:|-----------------:|---------------:|:---------------|------:|-------:|-------:|-----------:|
+| Strategy1   |    429 |           0.36 |         152.41 |       0.00762792 |          76.20 | 4:12:00        |   186 |      0 |    243 |       45.2 |
+| Strategy2   |   1487 |          -0.13 |        -197.58 |      -0.00988917 |         -98.79 | 4:43:00        |   662 |      0 |    825 |     241.68 |
 ```

 ## Next step
--- a/docs/bot-basics.md
+++ b/docs/bot-basics.md
@ -12,9 +12,6 @@ This page provides you some basic concepts on how Freqtrade works and operates.
 * **Indicators**: Technical indicators (SMA, EMA, RSI, ...).
 * **Limit order**: Limit orders which execute at the defined limit price or better.
 * **Market order**: Guaranteed to fill, may move price depending on the order size.
-* **Current Profit**: Currently pending (unrealized) profit for this trade. This is mainly used throughout the bot and UI.
-* **Realized Profit**: Already realized profit. Only relevant in combination with [partial exits](strategy-callbacks.md#adjust-trade-position) - which also explains the calculation logic for this.
-* **Total Profit**: Combined realized and unrealized profit. The relative number (%) is calculated against the total investment in this trade.

 ## Fee handling

@ -23,34 +20,30 @@ All profit calculations of Freqtrade include fees. For Backtesting / Hyperopt /
 ## Bot execution logic

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

 * Fetch open trades from persistence.
 * Calculate current list of tradable pairs.
-* Download OHLCV data for the pairlist including all [informative pairs](strategy-customization.md#get-data-for-non-tradeable-pairs)  
+* Download ohlcv data for the pairlist including all [informative pairs](strategy-customization.md#get-data-for-non-tradeable-pairs)  
  This step is only executed once per Candle to avoid unnecessary network traffic.
 * Call `bot_loop_start()` strategy callback.
 * Analyze strategy per pair.
  * Call `populate_indicators()`
-  * Call `populate_entry_trend()`
-  * Call `populate_exit_trend()`
+  * Call `populate_buy_trend()`
+  * Call `populate_sell_trend()`
 * Check timeouts for open orders.
-  * Calls `check_entry_timeout()` strategy callback for open entry orders.
-  * Calls `check_exit_timeout()` strategy callback for open exit orders.
-  * Calls `adjust_entry_price()` strategy callback for open entry orders.
-* Verifies existing positions and eventually places exit orders.
-  * Considers stoploss, ROI and exit-signal, `custom_exit()` and `custom_stoploss()`.
-  * Determine exit-price based on `exit_pricing` configuration setting or by using the `custom_exit_price()` callback.
-  * Before a exit order is placed, `confirm_trade_exit()` strategy callback is called.
+  * Calls `check_buy_timeout()` strategy callback for open buy orders.
+  * Calls `check_sell_timeout()` strategy callback for open sell orders.
+* Verifies existing positions and eventually places sell orders.
+  * Considers stoploss, ROI and sell-signal, `custom_sell()` and `custom_stoploss()`.
+  * Determine sell-price based on `ask_strategy` configuration setting or by using the `custom_exit_price()` callback.
+  * Before a sell order is placed, `confirm_trade_exit()` strategy callback is called.
 * Check position adjustments for open trades if enabled by calling `adjust_trade_position()` and place additional order if required.
 * Check if trade-slots are still available (if `max_open_trades` is reached).
-* Verifies entry signal trying to enter new positions.
-  * Determine entry-price based on `entry_pricing` configuration setting, or by using the `custom_entry_price()` callback.
-  * In Margin and Futures mode, `leverage()` strategy callback is called to determine the desired leverage.
+* Verifies buy signal trying to enter new positions.
+  * Determine buy-price based on `bid_strategy` configuration setting, or by using the `custom_entry_price()` callback.
  * Determine stake size by calling the `custom_stake_amount()` callback.
-  * Before an entry order is placed, `confirm_trade_entry()` strategy callback is called.
+  * Before a buy order is placed, `confirm_trade_entry()` strategy callback is called.

 This loop will be repeated again and again until the bot is stopped.

@ -59,26 +52,18 @@ This loop will be repeated again and again until the bot is stopped.
 [backtesting](backtesting.md) or [hyperopt](hyperopt.md) do only part of the above logic, since most of the trading operations are fully simulated.

 * Load historic data for configured pairlist.
-* Calls `bot_start()` once.
+* Calls `bot_loop_start()` once.
 * Calculate indicators (calls `populate_indicators()` once per pair).
-* Calculate entry / exit signals (calls `populate_entry_trend()` and `populate_exit_trend()` once per pair).
+* Calculate buy / sell signals (calls `populate_buy_trend()` and `populate_sell_trend()` once per pair).
 * Loops per candle simulating entry and exit points.
-  * Calls `bot_loop_start()` strategy callback.
-  * Check for Order timeouts, either via the `unfilledtimeout` configuration, or via `check_entry_timeout()` / `check_exit_timeout()` strategy callbacks.
-  * Calls `adjust_entry_price()` strategy callback for open entry orders.
-  * Check for trade entry signals (`enter_long` / `enter_short` columns).
-  * Confirm trade entry / exits (calls `confirm_trade_entry()` and `confirm_trade_exit()` if implemented in the strategy).
+  * 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).
-  * In Margin and Futures mode, `leverage()` strategy callback is called to determine the desired leverage.
  * Determine stake size by calling the `custom_stake_amount()` callback.
  * Check position adjustments for open trades if enabled and call `adjust_trade_position()` to determine if an additional order is requested.
-  * Call `custom_stoploss()` and `custom_exit()` to find custom exit points.
-  * For exits based on exit-signal, custom-exit and partial exits: Call `custom_exit_price()` to determine exit price (Prices are moved to be within the closing candle).
+  * 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).
+  * Check for Order timeouts, either via the `unfilledtimeout` configuration, or via `check_buy_timeout()` / `check_sell_timeout()` strategy callbacks.
 * Generate backtest report output

 !!! Note
    Both Backtesting and Hyperopt include exchange default Fees in the calculation. Custom fees can be passed to backtesting / hyperopt by specifying the `--fee` argument.
-
-!!! Warning "Callback call frequency"
-    Backtesting will call each callback at max. once per candle (`--timeframe-detail` modifies this behavior to once per detailed candle).
-    Most callbacks will be called once per iteration in live (usually every ~5s) - which can cause backtesting mismatches.
--- a/docs/configuration.md
+++ b/docs/configuration.md
@ -11,7 +11,7 @@ Per default, the bot loads the configuration from the `config.json` file, locate

 You can specify a different configuration file used by the bot with the `-c/--config` command-line option.

-If you used the [Quick start](docker_quickstart.md#docker-quick-start) method for installing
+If you used the [Quick start](installation.md/#quick-start) method for installing 
 the bot, the installation script should have already created the default configuration file (`config.json`) for you.

 If the default configuration file is not created we recommend to use `freqtrade new-config --config config.json` to generate a basic configuration file.
@ -53,74 +53,20 @@ FREQTRADE__EXCHANGE__SECRET=<yourExchangeSecret>

 Multiple configuration files can be specified and used by the bot or the bot can read its configuration parameters from the process standard input stream.

-You can specify additional configuration files in `add_config_files`. Files specified in this parameter will be loaded and merged with the initial config file. The files are resolved relative to the initial configuration file.
-This is similar to using multiple `--config` parameters, but simpler in usage as you don't have to specify all files for all commands.
-
 !!! Tip "Use multiple configuration files to keep secrets secret"
    You can use a 2nd configuration file containing your secrets. That way you can share your "primary" configuration file, while still keeping your API keys for yourself.
+
+    ``` bash
+    freqtrade trade --config user_data/config.json --config user_data/config-private.json <...>
+    ```
    The 2nd file should only specify what you intend to override.
    If a key is in more than one of the configurations, then the "last specified configuration" wins (in the above example, `config-private.json`).

-    For one-off commands, you can also use the below syntax by specifying multiple "--config" parameters.
-
-    ``` bash
-    freqtrade trade --config user_data/config1.json --config user_data/config-private.json <...>
-    ```
-
-    The below is equivalent to the example above - but having 2 configuration files in the configuration, for easier reuse.
-
-    ``` json title="user_data/config.json"
-    "add_config_files": [
-        "config1.json",
-        "config-private.json"
-    ]
-    ```
-
-    ``` bash
-    freqtrade trade --config user_data/config.json <...>
-    ```
-
-??? Note "config collision handling"
-    If the same configuration setting takes place in both `config.json` and `config-import.json`, then the parent configuration wins.
-    In the below case, `max_open_trades` would be 3 after the merging - as the reusable "import" configuration has this key overwritten.
-
-    ``` json title="user_data/config.json"
-    {
-        "max_open_trades": 3,
-        "stake_currency": "USDT",
-        "add_config_files": [
-            "config-import.json"
-        ]
-    }
-    ```
-
-    ``` json title="user_data/config-import.json"
-    {
-        "max_open_trades": 10,
-        "stake_amount": "unlimited",
-    }
-    ```
-
-    Resulting combined configuration:
-
-    ``` json title="Result"
-    {
-        "max_open_trades": 3,
-        "stake_currency": "USDT",
-        "stake_amount": "unlimited"
-    }
-    ```
-
-    If multiple files are in the `add_config_files` section, then they will be assumed to be at identical levels, having the last occurrence override the earlier config (unless a parent already defined such a key).
-
 ## Configuration parameters

 The table below will list all configuration parameters available.

 Freqtrade can also load many options via command line (CLI) arguments (check out the commands `--help` output for details).
-
-### Configuration option prevalence
-
 The prevalence for all Options is as follows:

 - CLI arguments override any other option
@ -128,13 +74,11 @@ The prevalence for all Options is as follows:
 - Configuration files are used in sequence (the last file wins) and override Strategy configurations.
 - Strategy configurations are only used if they are not set via configuration or command-line arguments. These options are marked with [Strategy Override](#parameters-in-the-strategy) in the below table.

-### Parameters table
-
 Mandatory parameters are marked as **Required**, which means that they are required to be set in one of the possible ways.

 |  Parameter | Description |
 |------------|-------------|
-| `max_open_trades` | **Required.** Number of open trades your bot is allowed to have. Only one open trade per pair is possible, so the length of your pairlist is another limitation that can apply. If -1 then it is ignored (i.e. potentially unlimited open trades, limited by the pairlist). [More information below](#configuring-amount-per-trade). [Strategy Override](#parameters-in-the-strategy).<br> **Datatype:** Positive integer or -1.
+| `max_open_trades` | **Required.** Number of open trades your bot is allowed to have. Only one open trade per pair is possible, so the length of your pairlist is another limitation that can apply. If -1 then it is ignored (i.e. potentially unlimited open trades, limited by the pairlist). [More information below](#configuring-amount-per-trade).<br> **Datatype:** Positive integer or -1.
 | `stake_currency` | **Required.** Crypto-currency used for trading. <br> **Datatype:** String
 | `stake_amount` | **Required.** Amount of crypto-currency your bot will use for each trade. Set it to `"unlimited"` to allow the bot to use all available balance. [More information below](#configuring-amount-per-trade). <br> **Datatype:** Positive float or `"unlimited"`.
 | `tradable_balance_ratio` | Ratio of the total account balance the bot is allowed to trade. [More information below](#configuring-amount-per-trade). <br>*Defaults to `0.99` 99%).*<br> **Datatype:** Positive float between `0.1` and `1.0`.
@ -142,51 +86,41 @@ Mandatory parameters are marked as **Required**, which means that they are requi
 | `amend_last_stake_amount` | Use reduced last stake amount if necessary. [More information below](#configuring-amount-per-trade). <br>*Defaults to `false`.* <br> **Datatype:** Boolean
 | `last_stake_amount_min_ratio` | Defines minimum stake amount that has to be left and executed. Applies only to the last stake amount when it's amended to a reduced value (i.e. if `amend_last_stake_amount` is set to `true`). [More information below](#configuring-amount-per-trade). <br>*Defaults to `0.5`.* <br> **Datatype:** Float (as ratio)
 | `amount_reserve_percent` | Reserve some amount in min pair stake amount. The bot will reserve `amount_reserve_percent` + stoploss value when calculating min pair stake amount in order to avoid possible trade refusals. <br>*Defaults to `0.05` (5%).* <br> **Datatype:** Positive Float as ratio.
-| `timeframe` | The timeframe to use (e.g `1m`, `5m`, `15m`, `30m`, `1h` ...). Usually missing in configuration, and specified in the strategy. [Strategy Override](#parameters-in-the-strategy). <br> **Datatype:** String
+| `timeframe` | The timeframe (former ticker interval) to use (e.g `1m`, `5m`, `15m`, `30m`, `1h` ...). [Strategy Override](#parameters-in-the-strategy). <br> **Datatype:** String
 | `fiat_display_currency` | Fiat currency used to show your profits. [More information below](#what-values-can-be-used-for-fiat_display_currency). <br> **Datatype:** String
 | `dry_run` | **Required.** Define if the bot must be in Dry Run or production mode. <br>*Defaults to `true`.* <br> **Datatype:** Boolean
 | `dry_run_wallet` | Define the starting amount in stake currency for the simulated wallet used by the bot running in Dry Run mode.<br>*Defaults to `1000`.* <br> **Datatype:** Float
 | `cancel_open_orders_on_exit` | Cancel open orders when the `/stop` RPC command is issued, `Ctrl+C` is pressed or the bot dies unexpectedly. When set to `true`, this allows you to use `/stop` to cancel unfilled and partially filled orders in the event of a market crash. It does not impact open positions. <br>*Defaults to `false`.* <br> **Datatype:** Boolean
-| `process_only_new_candles` | Enable processing of indicators only when new candles arrive. If false each loop populates the indicators, this will mean the same candle is processed many times creating system load but can be useful of your strategy depends on tick data not only candle. [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `true`.*  <br> **Datatype:** Boolean
-| `minimal_roi` | **Required.** Set the threshold as ratio the bot will use to exit a trade. [More information below](#understand-minimal_roi). [Strategy Override](#parameters-in-the-strategy). <br> **Datatype:** Dict
+| `process_only_new_candles` | Enable processing of indicators only when new candles arrive. If false each loop populates the indicators, this will mean the same candle is processed many times creating system load but can be useful of your strategy depends on tick data not only candle. [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `false`.*  <br> **Datatype:** Boolean
+| `minimal_roi` | **Required.** Set the threshold as ratio the bot will use to sell a trade. [More information below](#understand-minimal_roi). [Strategy Override](#parameters-in-the-strategy). <br> **Datatype:** Dict
 | `stoploss` |  **Required.** Value as ratio of the stoploss used by the bot. More details in the [stoploss documentation](stoploss.md). [Strategy Override](#parameters-in-the-strategy).  <br> **Datatype:** Float (as ratio)
 | `trailing_stop` | Enables trailing stoploss (based on `stoploss` in either configuration or strategy file). More details in the [stoploss documentation](stoploss.md#trailing-stop-loss). [Strategy Override](#parameters-in-the-strategy). <br> **Datatype:** Boolean
 | `trailing_stop_positive` | Changes stoploss once profit has been reached. More details in the [stoploss documentation](stoploss.md#trailing-stop-loss-custom-positive-loss). [Strategy Override](#parameters-in-the-strategy). <br> **Datatype:** Float
 | `trailing_stop_positive_offset` | Offset on when to apply `trailing_stop_positive`. Percentage value which should be positive. More details in the [stoploss documentation](stoploss.md#trailing-stop-loss-only-once-the-trade-has-reached-a-certain-offset). [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `0.0` (no offset).* <br> **Datatype:** Float
 | `trailing_only_offset_is_reached` | Only apply trailing stoploss when the offset is reached. [stoploss documentation](stoploss.md). [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `false`.*  <br> **Datatype:** Boolean
 | `fee` | Fee used during backtesting / dry-runs. Should normally not be configured, which has freqtrade fall back to the exchange default fee. Set as ratio (e.g. 0.001 = 0.1%). Fee is applied twice for each trade, once when buying, once when selling. <br> **Datatype:** Float (as ratio)
-| `futures_funding_rate` | User-specified funding rate to be used when historical funding rates are not available from the exchange. This does not overwrite real historical rates. It is recommended that this be set to 0 unless you are testing a specific coin and you understand how the funding rate will affect freqtrade's profit calculations. [More information here](leverage.md#unavailable-funding-rates) <br>*Defaults to None.*<br> **Datatype:** Float
-| `trading_mode` | Specifies if you want to trade regularly, trade with leverage, or trade contracts whose prices are derived from matching cryptocurrency prices. [leverage documentation](leverage.md). <br>*Defaults to `"spot"`.*  <br> **Datatype:** String
-| `margin_mode` | When trading with leverage, this determines if the collateral owned by the trader will be shared or isolated to each trading pair [leverage documentation](leverage.md). <br> **Datatype:** String
-| `liquidation_buffer` | A ratio specifying how large of a safety net to place between the liquidation price and the stoploss to prevent a position from reaching the liquidation price [leverage documentation](leverage.md). <br>*Defaults to `0.05`.*  <br> **Datatype:** Float
-| | **Unfilled timeout**
-| `unfilledtimeout.entry` | **Required.** How long (in minutes or seconds) the bot will wait for an unfilled entry 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.exit` | **Required.** How long (in minutes or seconds) the bot will wait for an unfilled exit 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.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 exit is triggered. 0 to disable and allow unlimited order cancels. [Strategy Override](#parameters-in-the-strategy).<br>*Defaults to `0`.* <br> **Datatype:** Integer
-| | **Pricing**
-| `entry_pricing.price_side` | Select the side of the spread the bot should look at to get the entry rate. [More information below](#buy-price-side).<br> *Defaults to `same`.* <br> **Datatype:** String (either `ask`, `bid`, `same` or `other`).
-| `entry_pricing.price_last_balance` | **Required.** Interpolate the bidding price. More information [below](#entry-price-without-orderbook-enabled).
-| `entry_pricing.use_order_book` | Enable entering using the rates in [Order Book Entry](#entry-price-with-orderbook-enabled). <br> *Defaults to `True`.*<br> **Datatype:** Boolean
-| `entry_pricing.order_book_top` | Bot will use the top N rate in Order Book "price_side" to enter a trade. I.e. a value of 2 will allow the bot to pick the 2nd entry in [Order Book Entry](#entry-price-with-orderbook-enabled). <br>*Defaults to `1`.*  <br> **Datatype:** Positive Integer
-| `entry_pricing. check_depth_of_market.enabled` | Do not enter if the difference of buy orders and sell orders is met in Order Book. [Check market depth](#check-depth-of-market). <br>*Defaults to `false`.* <br> **Datatype:** Boolean
-| `entry_pricing. check_depth_of_market.bids_to_ask_delta` | The difference ratio of buy orders and sell orders found in Order Book. A value below 1 means sell order size is greater, while value greater than 1 means buy order size is higher. [Check market depth](#check-depth-of-market) <br> *Defaults to `0`.*  <br> **Datatype:** Float (as ratio)
-| `exit_pricing.price_side` | Select the side of the spread the bot should look at to get the exit rate. [More information below](#exit-price-side).<br> *Defaults to `same`.* <br> **Datatype:** String (either `ask`, `bid`, `same` or `other`).
-| `exit_pricing.price_last_balance` | Interpolate the exiting price. More information [below](#exit-price-without-orderbook-enabled).
-| `exit_pricing.use_order_book` | Enable exiting of open trades using [Order Book Exit](#exit-price-with-orderbook-enabled). <br> *Defaults to `True`.*<br> **Datatype:** Boolean
-| `exit_pricing.order_book_top` | Bot will use the top N rate in Order Book "price_side" to exit. I.e. a value of 2 will allow the bot to pick the 2nd ask rate in [Order Book Exit](#exit-price-with-orderbook-enabled)<br>*Defaults to `1`.* <br> **Datatype:** Positive Integer
-| `custom_price_max_distance_ratio` | Configure maximum distance ratio between current and custom entry or exit price. <br>*Defaults to `0.02` 2%).*<br> **Datatype:** Positive float
-| | **TODO**
-| `use_exit_signal` | Use exit signals produced by the strategy in addition to the `minimal_roi`. [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `true`.* <br> **Datatype:** Boolean
-| `exit_profit_only` | Wait until the bot reaches `exit_profit_offset` before taking an exit decision. [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `false`.* <br> **Datatype:** Boolean
-| `exit_profit_offset` | Exit-signal is only active above this value. Only active in combination with `exit_profit_only=True`. [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `0.0`.* <br> **Datatype:** Float (as ratio)
-| `ignore_roi_if_entry_signal` | Do not exit if the entry signal is still active. This setting takes preference over `minimal_roi` and `use_exit_signal`. [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `false`.* <br> **Datatype:** Boolean
+| `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
+| `bid_strategy.order_book_top` | Bot will use the top N rate in Order Book "price_side" to buy. I.e. a value of 2 will allow the bot to pick the 2nd bid rate in [Order Book Bids](#buy-price-with-orderbook-enabled). <br>*Defaults to `1`.*  <br> **Datatype:** Positive Integer
+| `bid_strategy. check_depth_of_market.enabled` | Do not buy if the difference of buy orders and sell orders is met in Order Book. [Check market depth](#check-depth-of-market). <br>*Defaults to `false`.* <br> **Datatype:** Boolean
+| `bid_strategy. check_depth_of_market.bids_to_ask_delta` | The difference ratio of buy orders and sell orders found in Order Book. A value below 1 means sell order size is greater, while value greater than 1 means buy order size is higher. [Check market depth](#check-depth-of-market) <br> *Defaults to `0`.*  <br> **Datatype:** Float (as ratio)
+| `ask_strategy.price_side` | Select the side of the spread the bot should look at to get the sell rate. [More information below](#sell-price-side).<br> *Defaults to `ask`.* <br> **Datatype:** String (either `ask` or `bid`).
+| `ask_strategy.bid_last_balance` | Interpolate the selling price. More information [below](#sell-price-without-orderbook-enabled).
+| `ask_strategy.use_order_book` | Enable selling of open trades using [Order Book Asks](#sell-price-with-orderbook-enabled). <br> **Datatype:** Boolean
+| `ask_strategy.order_book_top` | Bot will use the top N rate in Order Book "price_side" to sell. I.e. a value of 2 will allow the bot to pick the 2nd ask rate in [Order Book Asks](#sell-price-with-orderbook-enabled)<br>*Defaults to `1`.* <br> **Datatype:** Positive Integer
+| `use_sell_signal` | Use sell signals produced by the strategy in addition to the `minimal_roi`. [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `true`.* <br> **Datatype:** Boolean
+| `sell_profit_only` | Wait until the bot reaches `sell_profit_offset` before taking a sell decision. [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `false`.* <br> **Datatype:** Boolean
+| `sell_profit_offset` | Sell-signal is only active above this value. Only active in combination with `sell_profit_only=True`. [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `0.0`.* <br> **Datatype:** Float (as ratio)
+| `ignore_roi_if_buy_signal` | Do not sell if the buy signal is still active. This setting takes preference over `minimal_roi` and `use_sell_signal`. [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `false`.* <br> **Datatype:** Boolean
 | `ignore_buying_expired_candle_after` | Specifies the number of seconds until a buy signal is no longer used. <br> **Datatype:** Integer
-| `order_types` | Configure order-types depending on the action (`"entry"`, `"exit"`, `"stoploss"`, `"stoploss_on_exchange"`). [More information below](#understand-order_types). [Strategy Override](#parameters-in-the-strategy).<br> **Datatype:** Dict
-| `order_time_in_force` | Configure time in force for entry and exit orders. [More information below](#understand-order_time_in_force). [Strategy Override](#parameters-in-the-strategy). <br> **Datatype:** Dict
-| `position_adjustment_enable` | Enables the strategy to use position adjustments (additional buys or sells). [More information here](strategy-callbacks.md#adjust-trade-position). <br> [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `false`.*<br> **Datatype:** Boolean
-| `max_entry_position_adjustment` | Maximum additional order(s) for each open trade on top of the first entry Order. Set it to `-1` for unlimited additional orders. [More information here](strategy-callbacks.md#adjust-trade-position). <br> [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `-1`.*<br> **Datatype:** Positive Integer or -1
-| | **Exchange**
+| `order_types` | Configure order-types depending on the action (`"buy"`, `"sell"`, `"stoploss"`, `"stoploss_on_exchange"`). [More information below](#understand-order_types). [Strategy Override](#parameters-in-the-strategy).<br> **Datatype:** Dict
+| `order_time_in_force` | Configure time in force for buy and sell orders. [More information below](#understand-order_time_in_force). [Strategy Override](#parameters-in-the-strategy). <br> **Datatype:** Dict
+| `custom_price_max_distance_ratio` | Configure maximum distance ratio between current and custom entry or exit price. <br>*Defaults to `0.02` 2%).*<br> **Datatype:** Positive float
 | `exchange.name` | **Required.** Name of the exchange class to use. [List below](#user-content-what-values-for-exchangename). <br> **Datatype:** String
 | `exchange.sandbox` | Use the 'sandbox' version of the exchange, where the exchange provides a sandbox for risk-free integration. See [here](sandbox-testing.md) in more details.<br> **Datatype:** Boolean
 | `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
@ -203,57 +137,43 @@ Mandatory parameters are marked as **Required**, which means that they are requi
 | `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
-| | **Plugins**
-| `edge.*` | Please refer to [edge configuration document](edge.md) for detailed explanation of all possible configuration options.
 | `pairlists` | Define one or more pairlists to be used. [More information](plugins.md#pairlists-and-pairlist-handlers). <br>*Defaults to `StaticPairList`.*  <br> **Datatype:** List of Dicts
 | `protections` | Define one or more protections to be used. [More information](plugins.md#protections). <br> **Datatype:** List of Dicts
-| | **Telegram**
 | `telegram.enabled` | Enable the usage of Telegram. <br> **Datatype:** Boolean
 | `telegram.token` | Your Telegram bot token. Only required if `telegram.enabled` is `true`. <br>**Keep it in secret, do not disclose publicly.** <br> **Datatype:** String
 | `telegram.chat_id` | Your personal Telegram account id. Only required if `telegram.enabled` is `true`. <br>**Keep it in secret, do not disclose publicly.** <br> **Datatype:** String
 | `telegram.balance_dust_level` | Dust-level (in stake currency) - currencies with a balance below this will not be shown by `/balance`. <br> **Datatype:** float
-| `telegram.reload` | Allow "reload" buttons on telegram messages. <br>*Defaults to `True`.<br> **Datatype:** boolean
-| `telegram.notification_settings.*` | Detailed notification settings. Refer to the [telegram documentation](telegram-usage.md) for details.<br> **Datatype:** dictionary
-| `telegram.allow_custom_messages` | Enable the sending of Telegram messages from strategies via the dataprovider.send_msg() function. <br> **Datatype:** Boolean
-| | **Webhook**
 | `webhook.enabled` | Enable usage of Webhook notifications <br> **Datatype:** Boolean
 | `webhook.url` | URL for the webhook. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.entry` | Payload to send on entry. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.entry_cancel` | Payload to send on entry order cancel. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.entry_fill` | Payload to send on entry order filled. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.exit` | Payload to send on exit. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.exit_cancel` | Payload to send on exit order cancel. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.exit_fill` | Payload to send on exit order filled. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.status` | Payload to send on status calls. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.allow_custom_messages` | Enable the sending of Webhook messages from strategies via the dataprovider.send_msg() function. <br> **Datatype:** Boolean
-| | **Rest API / FreqUI / Producer-Consumer**
+| `webhook.webhookbuy` | Payload to send on buy. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.webhookbuycancel` | Payload to send on buy order cancel. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.webhooksell` | Payload to send on sell. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.webhooksellcancel` | Payload to send on sell order cancel. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.webhookstatus` | Payload to send on status calls. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
 | `api_server.enabled` | Enable usage of API Server. See the [API Server documentation](rest-api.md) for more details. <br> **Datatype:** Boolean
 | `api_server.listen_ip_address` | Bind IP address. See the [API Server documentation](rest-api.md) for more details. <br> **Datatype:** IPv4
 | `api_server.listen_port` | Bind Port. See the [API Server documentation](rest-api.md) for more details. <br>**Datatype:** Integer between 1024 and 65535
 | `api_server.verbosity` | Logging verbosity. `info` will print all RPC Calls, while "error" will only display errors. <br>**Datatype:** Enum, either `info` or `error`. Defaults to `info`.
 | `api_server.username` | Username for API server. See the [API Server documentation](rest-api.md) for more details. <br>**Keep it in secret, do not disclose publicly.**<br> **Datatype:** String
 | `api_server.password` | Password for API server. See the [API Server documentation](rest-api.md) for more details. <br>**Keep it in secret, do not disclose publicly.**<br> **Datatype:** String
-| `api_server.ws_token` | API token for the Message WebSocket. See the [API Server documentation](rest-api.md) for more details.  <br>**Keep it in secret, do not disclose publicly.** <br> **Datatype:** String
 | `bot_name` | Name of the bot. Passed via API to a client - can be shown to distinguish / name bots.<br> *Defaults to `freqtrade`*<br> **Datatype:** String
-| `external_message_consumer` | Enable [Producer/Consumer mode](producer-consumer.md) for more details. <br> **Datatype:** Dict
-| | **Other**
+| `db_url` | Declares database URL to use. NOTE: This defaults to `sqlite:///tradesv3.dryrun.sqlite` if `dry_run` is `true`, and to `sqlite:///tradesv3.sqlite` for production instances. <br> **Datatype:** String, SQLAlchemy connect string
 | `initial_state` | Defines the initial application state. If set to stopped, then the bot has to be explicitly started via `/start` RPC command. <br>*Defaults to `stopped`.* <br> **Datatype:** Enum, either `stopped` or `running`
-| `force_entry_enable` | Enables the RPC Commands to force a Trade entry. More information below. <br> **Datatype:** Boolean
+| `forcebuy_enable` | Enables the RPC Commands to force a buy. More information below. <br> **Datatype:** Boolean
 | `disable_dataframe_checks` | Disable checking the OHLCV dataframe returned from the strategy methods for correctness. Only use when intentionally changing the dataframe and understand what you are doing. [Strategy Override](#parameters-in-the-strategy).<br> *Defaults to `False`*. <br> **Datatype:** Boolean
+| `strategy` | **Required** Defines Strategy class to use. Recommended to be set via `--strategy NAME`. <br> **Datatype:** ClassName
+| `strategy_path` | Adds an additional strategy lookup path (must be a directory). <br> **Datatype:** String
 | `internals.process_throttle_secs` | Set the process throttle, or minimum loop duration for one bot iteration loop. Value in second. <br>*Defaults to `5` seconds.* <br> **Datatype:** Positive Integer
 | `internals.heartbeat_interval` | Print heartbeat message every N seconds. Set to 0 to disable heartbeat messages. <br>*Defaults to `60` seconds.* <br> **Datatype:** Positive Integer or 0
 | `internals.sd_notify` | Enables use of the sd_notify protocol to tell systemd service manager about changes in the bot state and issue keep-alive pings. See [here](installation.md#7-optional-configure-freqtrade-as-a-systemd-service) for more details. <br> **Datatype:** Boolean
-| `strategy` | **Required** Defines Strategy class to use. Recommended to be set via `--strategy NAME`. <br> **Datatype:** ClassName
-| `strategy_path` | Adds an additional strategy lookup path (must be a directory). <br> **Datatype:** String
-| `recursive_strategy_search` | Set to `true` to recursively search sub-directories inside `user_data/strategies` for a strategy. <br> **Datatype:** Boolean
-| `user_data_dir` | Directory containing user data. <br> *Defaults to `./user_data/`*. <br> **Datatype:** String
-| `db_url` | Declares database URL to use. NOTE: This defaults to `sqlite:///tradesv3.dryrun.sqlite` if `dry_run` is `true`, and to `sqlite:///tradesv3.sqlite` for production instances. <br> **Datatype:** String, SQLAlchemy connect string
 | `logfile` | Specifies logfile name. Uses a rolling strategy for log file rotation for 10 files with the 1MB limit per file. <br> **Datatype:** String
-| `add_config_files` | Additional config files. These files will be loaded and merged with the current config file. The files are resolved relative to the initial file.<br> *Defaults to `[]`*. <br> **Datatype:** List of strings
+| `user_data_dir` | Directory containing user data. <br> *Defaults to `./user_data/`*. <br> **Datatype:** String
 | `dataformat_ohlcv` | Data format to use to store historical candle (OHLCV) data. <br> *Defaults to `json`*. <br> **Datatype:** String
 | `dataformat_trades` | Data format to use to store historical trades data. <br> *Defaults to `jsongz`*. <br> **Datatype:** String
-| `reduce_df_footprint` | Recast all numeric columns to float32/int32, with the objective of reducing ram/disk usage (and decreasing train/inference timing in FreqAI). (Currently only affects FreqAI use-cases) <br> **Datatype:** Boolean. <br> Default: `False`.
+| `position_adjustment_enable` | Enables the strategy to use position adjustments (additional buys or sells). [More information here](strategy-callbacks.md#adjust-trade-position). <br> [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `false`.*<br> **Datatype:** Boolean
+| `max_entry_position_adjustment` | Maximum additional order(s) for each open trade on top of the first entry Order. Set it to `-1` for unlimited additional orders. [More information here](strategy-callbacks.md#adjust-trade-position). <br> [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `-1`.*<br> **Datatype:** Positive Integer or -1

 ### Parameters in the strategy

@ -263,7 +183,6 @@ Values set in the configuration file always overwrite values set in the strategy
 * `minimal_roi`
 * `timeframe`
 * `stoploss`
-* `max_open_trades`
 * `trailing_stop`
 * `trailing_stop_positive`
 * `trailing_stop_positive_offset`
@ -274,10 +193,10 @@ Values set in the configuration file always overwrite values set in the strategy
 * `order_time_in_force`
 * `unfilledtimeout`
 * `disable_dataframe_checks`
- `use_exit_signal`
-* `exit_profit_only`
- `exit_profit_offset`
- `ignore_roi_if_entry_signal`
+* `use_sell_signal`
+* `sell_profit_only`
+* `sell_profit_offset`
+* `ignore_roi_if_buy_signal`
 * `ignore_buying_expired_candle_after`
 * `position_adjustment_enable`
 * `max_entry_position_adjustment`
@ -406,10 +325,10 @@ See the example below:

 ```json
 "minimal_roi": {
-    "40": 0.0,    # Exit after 40 minutes if the profit is not negative
-    "30": 0.01,   # Exit after 30 minutes if there is at least 1% profit
-    "20": 0.02,   # Exit after 20 minutes if there is at least 2% profit
-    "0":  0.04    # Exit immediately if there is at least 4% profit
+    "40": 0.0,    # Sell after 40 minutes if the profit is not negative
+    "30": 0.01,   # Sell after 30 minutes if there is at least 1% profit
+    "20": 0.02,   # Sell after 20 minutes if there is at least 2% profit
+    "0":  0.04    # Sell immediately if there is at least 4% profit
 },
 ```

@ -418,14 +337,14 @@ This parameter can be set in either Strategy or Configuration file. If you use i
 `minimal_roi` value from the strategy file.
 If it is not set in either Strategy or Configuration, a default of 1000% `{"0": 10}` is used, and minimal ROI is disabled unless your trade generates 1000% profit.

-!!! Note "Special case to forceexit after a specific time"
-    A special case presents using `"<N>": -1` as ROI. This forces the bot to exit a trade after N Minutes, no matter if it's positive or negative, so represents a time-limited force-exit.
+!!! Note "Special case to forcesell after a specific time"
+    A special case presents using `"<N>": -1` as ROI. This forces the bot to sell a trade after N Minutes, no matter if it's positive or negative, so represents a time-limited force-sell.

-### Understand force_entry_enable
+### Understand forcebuy_enable

-The `force_entry_enable` configuration parameter enables the usage of force-enter (`/forcelong`, `/forceshort`) commands via Telegram and REST API.
+The `forcebuy_enable` configuration parameter enables the usage of forcebuy commands via Telegram and REST API.
 For security reasons, it's disabled by default, and freqtrade will show a warning message on startup if enabled.
-For example, you can send `/forceenter ETH/BTC` to the bot, which will result in freqtrade buying the pair and holds it until a regular exit-signal (ROI, stoploss, /forceexit) appears.
+For example, you can send `/forcebuy ETH/BTC` to the bot, which will result in freqtrade buying the pair and holds it until a regular sell-signal (ROI, stoploss, /forcesell) appears.

 This can be dangerous with some strategies, so use with care.

@ -452,27 +371,29 @@ For example, if your strategy is using a 1h timeframe, and you only want to buy

 ### Understand order_types

-The `order_types` configuration parameter maps actions (`entry`, `exit`, `stoploss`, `emergency_exit`, `force_exit`, `force_entry`) to order-types (`market`, `limit`, ...) as well as configures stoploss to be on the exchange and defines stoploss on exchange update interval in seconds.
-
-This allows to enter using limit orders, exit using limit-orders, and create stoplosses using market orders.
-It also allows to set the
-stoploss "on exchange" which means stoploss order would be placed immediately once the buy order is fulfilled.
+The `order_types` configuration parameter maps actions (`buy`, `sell`, `stoploss`, `emergencysell`, `forcesell`, `forcebuy`) to order-types (`market`, `limit`, ...) as well as configures stoploss to be on the exchange and defines stoploss on exchange update interval in seconds.

+This allows to buy using limit orders, sell using
+limit-orders, and create stoplosses using market orders. It also allows to set the
+stoploss "on exchange" which means stoploss order would be placed immediately once
+the buy order is fulfilled.
+    
 `order_types` set in the configuration file overwrites values set in the strategy as a whole, so you need to configure the whole `order_types` dictionary in one place.

-If this is configured, the following 4 values (`entry`, `exit`, `stoploss` and `stoploss_on_exchange`) need to be present, otherwise, the bot will fail to start.
+If this is configured, the following 4 values (`buy`, `sell`, `stoploss` and
+`stoploss_on_exchange`) need to be present, otherwise, the bot will fail to start.

-For information on (`emergency_exit`,`force_exit`, `force_entry`, `stoploss_on_exchange`,`stoploss_on_exchange_interval`,`stoploss_on_exchange_limit_ratio`) please see stop loss documentation [stop loss on exchange](stoploss.md)
+For information on (`emergencysell`,`forcesell`, `forcebuy`, `stoploss_on_exchange`,`stoploss_on_exchange_interval`,`stoploss_on_exchange_limit_ratio`) please see stop loss documentation [stop loss on exchange](stoploss.md)

 Syntax for Strategy:

 ```python
 order_types = {
-    "entry": "limit",
-    "exit": "limit",
-    "emergency_exit": "market",
-    "force_entry": "market",
-    "force_exit": "market",
+    "buy": "limit",
+    "sell": "limit",
+    "emergencysell": "market",
+    "forcebuy": "market",
+    "forcesell": "market",
    "stoploss": "market",
    "stoploss_on_exchange": False,
    "stoploss_on_exchange_interval": 60,
@ -484,11 +405,11 @@ Configuration:

 ```json
 "order_types": {
-    "entry": "limit",
-    "exit": "limit",
-    "emergency_exit": "market",
-    "force_entry": "market",
-    "force_exit": "market",
+    "buy": "limit",
+    "sell": "limit",
+    "emergencysell": "market",
+    "forcebuy": "market",
+    "forcesell": "market",
    "stoploss": "market",
    "stoploss_on_exchange": false,
    "stoploss_on_exchange_interval": 60
@ -511,7 +432,7 @@ Configuration:
    If `stoploss_on_exchange` is enabled and the stoploss is cancelled manually on the exchange, then the bot will create a new stoploss order.

 !!! Warning "Warning: stoploss_on_exchange failures"
-    If stoploss on exchange creation fails for some reason, then an "emergency exit" is initiated. By default, this will exit the trade using a market order. The order-type for the emergency-exit can be changed by setting the `emergency_exit` value in the `order_types` dictionary - however, this is not advised.
+    If stoploss on exchange creation fails for some reason, then an "emergency sell" is initiated. By default, this will sell the asset using a market order. The order-type for the emergency-sell can be changed by setting the `emergencysell` value in the `order_types` dictionary - however, this is not advised.

 ### Understand order_time_in_force

@ -533,28 +454,21 @@ It means if the order is not executed immediately AND fully then it is cancelled
 It is the same as FOK (above) except it can be partially fulfilled. The remaining part
 is automatically cancelled by the exchange.

-**PO (Post only):**
-
-Post only order. The order is either placed as a maker order, or it is canceled.
-This means the order must be placed on orderbook for at at least time in an unfilled state.
-
-#### time_in_force config
-
-The `order_time_in_force` parameter contains a dict with entry and exit time in force policy values.
+The `order_time_in_force` parameter contains a dict with buy and sell time in force policy values.
 This can be set in the configuration file or in the strategy.
 Values set in the configuration file overwrites values set in the strategy.

-The possible values are: `GTC` (default), `FOK` or `IOC`.
+The possible values are: `gtc` (default), `fok` or `ioc`.

 ``` python
 "order_time_in_force": {
-    "entry": "GTC",
-    "exit": "GTC"
+    "buy": "gtc",
+    "sell": "gtc"
 },
 ```

 !!! Warning
-    This is ongoing work. For now, it is supported only for binance, gate and kucoin.
+    This is ongoing work. For now, it is supported only for binance and kucoin.
    Please don't change the default value unless you know what you are doing and have researched the impact of using different values for your particular exchange.

 ### What values can be used for fiat_display_currency?
@ -595,10 +509,10 @@ creating trades on the exchange.

 ```json
 "exchange": {
-    "name": "bittrex",
-    "key": "key",
-    "secret": "secret",
-    ...
+        "name": "bittrex",
+        "key": "key",
+        "secret": "secret",
+        ...
 }
 ```

@ -615,7 +529,7 @@ Once you will be happy with your bot performance running in the Dry-run mode, yo
 * Market orders fill based on orderbook volume the moment the order is placed.
 * Limit orders fill once the price reaches the defined level - or time out based on `unfilledtimeout` settings.
 * In combination with `stoploss_on_exchange`, the stop_loss price is assumed to be filled.
-* Open orders (not trades, which are stored in the database) are kept open after bot restarts, with the assumption that they were not filled while being offline.
+* Open orders (not trades, which are stored in the database) are reset on bot restart.

 ## Switch to production mode

@ -665,8 +579,17 @@ You should also make sure to read the [Exchanges](exchanges.md) section of the d

 ### Using proxy with Freqtrade

-To use a proxy with freqtrade, export your proxy settings using the variables `"HTTP_PROXY"` and `"HTTPS_PROXY"` set to the appropriate values.
-This will have the proxy settings applied to everything (telegram, coingecko, ...) **except** for exchange requests.
+To use a proxy with freqtrade, add the kwarg `"aiohttp_trust_env"=true` to the `"ccxt_async_kwargs"` dict in the exchange section of the configuration.
+
+An example for this can be found in `config_examples/config_full.example.json`
+
+``` json
+"ccxt_async_config": {
+    "aiohttp_trust_env": true
+}
+```
+
+Then, export your proxy settings using the variables `"HTTP_PROXY"` and `"HTTPS_PROXY"` set to the appropriate values

 ``` bash
 export HTTP_PROXY="http://addr:port"
@ -674,24 +597,6 @@ export HTTPS_PROXY="http://addr:port"
 freqtrade
 ```

-#### Proxy exchange requests
-
-To use a proxy for exchange connections - you will have to define the proxies as part of the ccxt configuration.
-
-``` json
-{ 
-  "exchange": {
-    "ccxt_config": {
-      "aiohttp_proxy": "http://addr:port",
-      "proxies": {
-        "http": "http://addr:port",
-        "https": "http://addr:port"
-      },
-    }
-  }
-}
-```
-
 ## Next step

 Now you have configured your config.json, the next step is to [start your bot](bot-usage.md).
--- a/docs/data-analysis.md
+++ b/docs/data-analysis.md
@ -5,7 +5,7 @@ You can analyze the results of backtests and trading history easily using Jupyte
 ## Quick start with docker

 Freqtrade provides a docker-compose file which starts up a jupyter lab server.
-You can run this server using the following command: `docker compose -f docker/docker-compose-jupyter.yml up`
+You can run this server using the following command: `docker-compose -f docker/docker-compose-jupyter.yml up`

 This will create a dockercontainer running jupyter lab, which will be accessible using `https://127.0.0.1:8888/lab`.
 Please use the link that's printed in the console after startup for simplified login.
@ -83,7 +83,7 @@ from pathlib import Path
 project_root = "somedir/freqtrade"
 i=0
 try:
-    os.chdir(project_root)
+    os.chdirdir(project_root)
    assert Path('LICENSE').is_file()
 except:
    while i<4 and (not Path('LICENSE').is_file()):
@ -122,6 +122,5 @@ Best avoid relative paths, since this starts at the storage location of the jupy

 * [Strategy debugging](strategy_analysis_example.md) - also available as Jupyter notebook (`user_data/notebooks/strategy_analysis_example.ipynb`)
 * [Plotting](plotting.md)
-* [Tag Analysis](advanced-backtesting.md)

 Feel free to submit an issue or Pull Request enhancing this document if you would like to share ideas on how to best analyze the data.
--- a/docs/data-download.md
+++ b/docs/data-download.md
@ -25,19 +25,17 @@ usage: freqtrade download-data [-h] [-v] [--logfile FILE] [-V] [-c PATH]
                               [--include-inactive-pairs]
                               [--timerange TIMERANGE] [--dl-trades]
                               [--exchange EXCHANGE]
-                               [-t TIMEFRAMES [TIMEFRAMES ...]] [--erase]
-                               [--data-format-ohlcv {json,jsongz,hdf5,feather,parquet}]
+                               [-t {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} ...]]
+                               [--erase]
+                               [--data-format-ohlcv {json,jsongz,hdf5}]
                               [--data-format-trades {json,jsongz,hdf5}]
-                               [--trading-mode {spot,margin,futures}]
-                               [--prepend]

 optional arguments:
  -h, --help            show this help message and exit
  -p PAIRS [PAIRS ...], --pairs PAIRS [PAIRS ...]
                        Limit command to these pairs. Pairs are space-
                        separated.
-  --pairs-file FILE     File containing a list of pairs. Takes precedence over
-                        --pairs or pairs configured in the configuration.
+  --pairs-file FILE     File containing a list of pairs to download.
  --days INT            Download data for given number of days.
  --new-pairs-days INT  Download data of new pairs for given number of days.
                        Default: `None`.
@ -50,20 +48,17 @@ optional arguments:
                        as --timeframes/-t.
  --exchange EXCHANGE   Exchange name (default: `bittrex`). Only valid if no
                        config is provided.
-  -t TIMEFRAMES [TIMEFRAMES ...], --timeframes TIMEFRAMES [TIMEFRAMES ...]
+  -t {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} ...], --timeframes {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} ...]
                        Specify which tickers to download. Space-separated
                        list. Default: `1m 5m`.
  --erase               Clean all existing data for the selected
                        exchange/pairs/timeframes.
-  --data-format-ohlcv {json,jsongz,hdf5,feather,parquet}
+  --data-format-ohlcv {json,jsongz,hdf5}
                        Storage format for downloaded candle (OHLCV) data.
                        (default: `json`).
  --data-format-trades {json,jsongz,hdf5}
                        Storage format for downloaded trades data. (default:
                        `jsongz`).
-  --trading-mode {spot,margin,futures}, --tradingmode {spot,margin,futures}
-                        Select Trading mode
-  --prepend             Allow data prepending. (Data-appending is disabled)

 Common arguments:
  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
@ -76,7 +71,7 @@ Common arguments:
                        `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, --data-dir PATH
+  -d PATH, --datadir PATH
                        Path to directory with historical backtesting data.
  --userdir PATH, --user-data-dir PATH
                        Path to userdata directory.
@ -159,36 +154,23 @@ freqtrade download-data --exchange binance --pairs .*/USDT
 - To change the exchange used to download the historical data from, please use a different configuration file (you'll probably need to adjust rate limits etc.)
 - To use `pairs.json` from some other directory, use `--pairs-file some_other_dir/pairs.json`.
 - To download historical candle (OHLCV) data for only 10 days, use `--days 10` (defaults to 30 days).
- To download historical candle (OHLCV) data from a fixed starting point, use `--timerange 20200101-` - which will download all data from January 1st, 2020.
+- To download historical candle (OHLCV) data from a fixed starting point, use `--timerange 20200101-` - which will download all data from January 1st, 2020. Eventually set end dates are ignored.
 - Use `--timeframes` to specify what timeframe download the historical candle (OHLCV) data for. Default is `--timeframes 1m 5m` which will download 1-minute and 5-minute data.
 - To use exchange, timeframe and list of pairs as defined in your configuration file, use the `-c/--config` option. With this, the script uses the whitelist defined in the config as the list of currency pairs to download data for and does not require the pairs.json file. You can combine `-c/--config` with most other options.

-#### Download additional data before the current timerange
-
-Assuming you downloaded all data from 2022 (`--timerange 20220101-`) - but you'd now like to also backtest with earlier data.
-You can do so by using the `--prepend` flag, combined with `--timerange` - specifying an end-date.
-
-``` bash
-freqtrade download-data --exchange binance --pairs ETH/USDT XRP/USDT BTC/USDT --prepend --timerange 20210101-20220101
-```
-
-!!! Note
-    Freqtrade will ignore the end-date in this mode if data is available, updating the end-date to the existing data start point.

 ### Data format

-Freqtrade currently supports the following data-formats:
+Freqtrade currently supports 3 data-formats for both OHLCV and trades data:

-* `json` -  plain "text" json files
-* `jsongz` - a gzip-zipped version of json files
-* `hdf5` - a high performance datastore
-* `feather` - a dataformat based on Apache Arrow (OHLCV only)
-* `parquet` - columnar datastore (OHLCV only)
+* `json` (plain "text" json files)
+* `jsongz` (a gzip-zipped version of json files)
+* `hdf5` (a high performance datastore)

 By default, OHLCV data is stored as `json` data, while trades data is stored as `jsongz` data.

 This can be changed via the `--data-format-ohlcv` and `--data-format-trades` command line arguments respectively.
-To persist this change, you should also add the following snippet to your configuration, so you don't have to insert the above arguments each time:
+To persist this change, you can should also add the following snippet to your configuration, so you don't have to insert the above arguments each time:

 ``` jsonc
    // ...
@ -202,75 +184,30 @@ If the default data-format has been changed during download, then the keys `data
 !!! Note
    You can convert between data-formats using the [convert-data](#sub-command-convert-data) and [convert-trade-data](#sub-command-convert-trade-data) methods.

-#### Dataformat comparison
-
-The following comparisons have been made with the following data, and by using the linux `time` command.
-
-```
-Found 6 pair / timeframe combinations.
-+----------+-------------+--------+---------------------+---------------------+
-|     Pair |   Timeframe |   Type |                From |                  To |
-|----------+-------------+--------+---------------------+---------------------|
-| BTC/USDT |          5m |   spot | 2017-08-17 04:00:00 | 2022-09-13 19:25:00 |
-| ETH/USDT |          1m |   spot | 2017-08-17 04:00:00 | 2022-09-13 19:26:00 |
-| BTC/USDT |          1m |   spot | 2017-08-17 04:00:00 | 2022-09-13 19:30:00 |
-| XRP/USDT |          5m |   spot | 2018-05-04 08:10:00 | 2022-09-13 19:15:00 |
-| XRP/USDT |          1m |   spot | 2018-05-04 08:11:00 | 2022-09-13 19:22:00 |
-| ETH/USDT |          5m |   spot | 2017-08-17 04:00:00 | 2022-09-13 19:20:00 |
-+----------+-------------+--------+---------------------+---------------------+
-```
-
-Timings have been taken in a not very scientific way with the following command, which forces reading the data into memory.
-
-``` bash
-time freqtrade list-data --show-timerange --data-format-ohlcv <dataformat>
-```
-
-|  Format | Size | timing |
-|------------|-------------|-------------|
-| `json` | 149Mb | 25.6s |
-| `jsongz` | 39Mb | 27s |
-| `hdf5` | 145Mb | 3.9s |
-| `feather` | 72Mb | 3.5s |
-| `parquet` | 83Mb | 3.8s |
-
-Size has been taken from the BTC/USDT 1m spot combination for the timerange specified above.
-
-To have a best performance/size mix, we recommend the use of either feather or parquet.
-
 #### Sub-command convert data

 ```
 usage: freqtrade convert-data [-h] [-v] [--logfile FILE] [-V] [-c PATH]
                              [-d PATH] [--userdir PATH]
                              [-p PAIRS [PAIRS ...]] --format-from
-                              {json,jsongz,hdf5,feather,parquet} --format-to
-                              {json,jsongz,hdf5,feather,parquet} [--erase]
-                              [--exchange EXCHANGE]
-                              [-t TIMEFRAMES [TIMEFRAMES ...]]
-                              [--trading-mode {spot,margin,futures}]
-                              [--candle-types {spot,futures,mark,index,premiumIndex,funding_rate} [{spot,futures,mark,index,premiumIndex,funding_rate} ...]]
+                              {json,jsongz,hdf5} --format-to
+                              {json,jsongz,hdf5} [--erase]
+                              [-t {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} ...]]

 optional arguments:
  -h, --help            show this help message and exit
  -p PAIRS [PAIRS ...], --pairs PAIRS [PAIRS ...]
-                        Limit command to these pairs. Pairs are space-
+                        Show profits for only these pairs. Pairs are space-
                        separated.
-  --format-from {json,jsongz,hdf5,feather,parquet}
+  --format-from {json,jsongz,hdf5}
                        Source format for data conversion.
-  --format-to {json,jsongz,hdf5,feather,parquet}
+  --format-to {json,jsongz,hdf5}
                        Destination format for data conversion.
  --erase               Clean all existing data for the selected
                        exchange/pairs/timeframes.
-  --exchange EXCHANGE   Exchange name (default: `bittrex`). Only valid if no
-                        config is provided.
-  -t TIMEFRAMES [TIMEFRAMES ...], --timeframes TIMEFRAMES [TIMEFRAMES ...]
+  -t {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} ...], --timeframes {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} ...]
                        Specify which tickers to download. Space-separated
                        list. Default: `1m 5m`.
-  --trading-mode {spot,margin,futures}, --tradingmode {spot,margin,futures}
-                        Select Trading mode
-  --candle-types {spot,futures,mark,index,premiumIndex,funding_rate} [{spot,futures,mark,index,premiumIndex,funding_rate} ...]
-                        Select candle type to use

 Common arguments:
  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
@ -283,11 +220,10 @@ Common arguments:
                        `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, --data-dir PATH
+  -d PATH, --datadir PATH
                        Path to directory with historical backtesting data.
  --userdir PATH, --user-data-dir PATH
                        Path to userdata directory.
-
 ```

 ##### Example converting data
@ -305,24 +241,20 @@ freqtrade convert-data --format-from json --format-to jsongz --datadir ~/.freqtr
 usage: freqtrade convert-trade-data [-h] [-v] [--logfile FILE] [-V] [-c PATH]
                                    [-d PATH] [--userdir PATH]
                                    [-p PAIRS [PAIRS ...]] --format-from
-                                    {json,jsongz,hdf5,feather,parquet}
-                                    --format-to
-                                    {json,jsongz,hdf5,feather,parquet}
-                                    [--erase] [--exchange EXCHANGE]
+                                    {json,jsongz,hdf5} --format-to
+                                    {json,jsongz,hdf5} [--erase]

 optional arguments:
  -h, --help            show this help message and exit
  -p PAIRS [PAIRS ...], --pairs PAIRS [PAIRS ...]
-                        Limit command to these pairs. Pairs are space-
+                        Show profits for only these pairs. Pairs are space-
                        separated.
-  --format-from {json,jsongz,hdf5,feather,parquet}
+  --format-from {json,jsongz,hdf5}
                        Source format for data conversion.
-  --format-to {json,jsongz,hdf5,feather,parquet}
+  --format-to {json,jsongz,hdf5}
                        Destination format for data conversion.
  --erase               Clean all existing data for the selected
                        exchange/pairs/timeframes.
-  --exchange EXCHANGE   Exchange name (default: `bittrex`). Only valid if no
-                        config is provided.

 Common arguments:
  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
@ -335,7 +267,7 @@ Common arguments:
                        `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, --data-dir PATH
+  -d PATH, --datadir PATH
                        Path to directory with historical backtesting data.
  --userdir PATH, --user-data-dir PATH
                        Path to userdata directory.
@ -360,9 +292,9 @@ This command will allow you to repeat this last step for additional timeframes w
 usage: freqtrade trades-to-ohlcv [-h] [-v] [--logfile FILE] [-V] [-c PATH]
                                 [-d PATH] [--userdir PATH]
                                 [-p PAIRS [PAIRS ...]]
-                                 [-t TIMEFRAMES [TIMEFRAMES ...]]
+                                 [-t {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} ...]]
                                 [--exchange EXCHANGE]
-                                 [--data-format-ohlcv {json,jsongz,hdf5,feather,parquet}]
+                                 [--data-format-ohlcv {json,jsongz,hdf5}]
                                 [--data-format-trades {json,jsongz,hdf5}]

 optional arguments:
@ -370,12 +302,12 @@ optional arguments:
  -p PAIRS [PAIRS ...], --pairs PAIRS [PAIRS ...]
                        Limit command to these pairs. Pairs are space-
                        separated.
-  -t TIMEFRAMES [TIMEFRAMES ...], --timeframes TIMEFRAMES [TIMEFRAMES ...]
+  -t {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} ...], --timeframes {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} ...]
                        Specify which tickers to download. Space-separated
                        list. Default: `1m 5m`.
  --exchange EXCHANGE   Exchange name (default: `bittrex`). Only valid if no
                        config is provided.
-  --data-format-ohlcv {json,jsongz,hdf5,feather,parquet}
+  --data-format-ohlcv {json,jsongz,hdf5}
                        Storage format for downloaded candle (OHLCV) data.
                        (default: `json`).
  --data-format-trades {json,jsongz,hdf5}
@ -393,7 +325,7 @@ Common arguments:
                        `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, --data-dir PATH
+  -d PATH, --datadir PATH
                        Path to directory with historical backtesting data.
  --userdir PATH, --user-data-dir PATH
                        Path to userdata directory.
@ -413,25 +345,19 @@ You can get a list of downloaded data using the `list-data` sub-command.
 ```
 usage: freqtrade list-data [-h] [-v] [--logfile FILE] [-V] [-c PATH] [-d PATH]
                           [--userdir PATH] [--exchange EXCHANGE]
-                           [--data-format-ohlcv {json,jsongz,hdf5,feather,parquet}]
+                           [--data-format-ohlcv {json,jsongz,hdf5}]
                           [-p PAIRS [PAIRS ...]]
-                           [--trading-mode {spot,margin,futures}]
-                           [--show-timerange]

 optional arguments:
  -h, --help            show this help message and exit
  --exchange EXCHANGE   Exchange name (default: `bittrex`). Only valid if no
                        config is provided.
-  --data-format-ohlcv {json,jsongz,hdf5,feather,parquet}
+  --data-format-ohlcv {json,jsongz,hdf5}
                        Storage format for downloaded candle (OHLCV) data.
                        (default: `json`).
  -p PAIRS [PAIRS ...], --pairs PAIRS [PAIRS ...]
-                        Limit command to these pairs. Pairs are space-
+                        Show profits for only these pairs. Pairs are space-
                        separated.
-  --trading-mode {spot,margin,futures}, --tradingmode {spot,margin,futures}
-                        Select Trading mode
-  --show-timerange      Show timerange available for available data. (May take
-                        a while to calculate).

 Common arguments:
  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
@ -444,7 +370,7 @@ Common arguments:
                        `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, --data-dir PATH
+  -d PATH, --datadir PATH
                        Path to directory with historical backtesting data.
  --userdir PATH, --user-data-dir PATH
                        Path to userdata directory.
--- a/docs/deprecated.md
+++ b/docs/deprecated.md
@ -24,10 +24,6 @@ Please refer to [pairlists](plugins.md#pairlists-and-pairlist-handlers) instead.
 Did only download the latest 500 candles, so was ineffective in getting good backtest data.
 Removed in 2019-7-dev (develop branch) and in freqtrade 2019.8.

-### `ticker_interval` (now `timeframe`)
-
-Support for `ticker_interval` terminology was deprecated in 2020.6 in favor of `timeframe` - and compatibility code was removed in 2022.3.
-
 ### Allow running multiple pairlists in sequence

 The former `"pairlist"` section in the configuration has been removed, and is replaced by `"pairlists"` - being a list to specify a sequence of pairlists.
@ -38,7 +34,7 @@ The old section of configuration parameters (`"pairlist"`) has been deprecated i

 Since only quoteVolume can be compared between assets, the other options (bidVolume, askVolume) have been deprecated in 2020.4, and have been removed in 2020.9.

-### Using order book steps for exit price
+### Using order book steps for sell price

 Using `order_book_min` and `order_book_max` used to allow stepping the orderbook and trying to find the next ROI slot - trying to place sell-orders early.
 As this does however increase risk and provides no benefit, it's been removed for maintainability purposes in 2021.7.
@ -47,35 +43,3 @@ As this does however increase risk and provides no benefit, it's been removed fo

 Using separate hyperopt files was deprecated in 2021.4 and was removed in 2021.9.
 Please switch to the new [Parametrized Strategies](hyperopt.md) to benefit from the new hyperopt interface.
-
-## Strategy changes between V2 and V3
-
-Isolated Futures / short trading was introduced in 2022.4. This required major changes to configuration settings, strategy interfaces, ...
-
-We have put a great effort into keeping compatibility with existing strategies, so if you just want to continue using freqtrade in spot markets, there are no changes necessary.
-While we may drop support for the current interface sometime in the future, we will announce this separately and have an appropriate transition period.
-
-Please follow the [Strategy migration](strategy_migration.md) guide to migrate your strategy to the new format to start using the new functionalities.
-
-### webhooks - changes with 2022.4
-
-#### `buy_tag` has been renamed to `enter_tag`
-
-This should apply only to your strategy and potentially to webhooks.
-We will keep a compatibility layer for 1-2 versions (so both `buy_tag` and `enter_tag` will still work), but support for this in webhooks will disappear after that.
-
-#### Naming changes
-
-Webhook terminology changed from "sell" to "exit", and from "buy" to "entry", removing "webhook" in the process.
-
-* `webhookbuy`, `webhookentry` -> `entry`
-* `webhookbuyfill`, `webhookentryfill` -> `entry_fill`
-* `webhookbuycancel`, `webhookentrycancel` -> `entry_cancel`
-* `webhooksell`, `webhookexit` -> `exit`
-* `webhooksellfill`, `webhookexitfill` -> `exit_fill`
-* `webhooksellcancel`, `webhookexitcancel` -> `exit_cancel`
-
-
-## Removal of `populate_any_indicators`
-
-version 2023.3 saw the removal of `populate_any_indicators` in favor of split methods for feature engineering and targets. Please read the [migration document](strategy_migration.md#freqai-strategy) for full details.
--- a/docs/developer.md
+++ b/docs/developer.md
@ -24,10 +24,7 @@ This will spin up a local server (usually on port 8000) so you can see if everyt
 To configure a development environment, you can either use the provided [DevContainer](#devcontainer-setup), or use the `setup.sh` script and answer "y" when asked "Do you want to install dependencies for dev [y/N]? ".
 Alternatively (e.g. if your system is not supported by the setup.sh script), follow the manual installation process and run `pip3 install -e .[all]`.

-This will install all required tools for development, including `pytest`, `ruff`, `mypy`, and `coveralls`.
-
-Then install the git hook scripts by running `pre-commit install`, so your changes will be verified locally before committing.
-This avoids a lot of waiting for CI already, as some basic formatting checks are done locally on your machine.
+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).

@ -49,13 +46,6 @@ For more information about the [Remote container extension](https://code.visuals
 New code should be covered by basic unittests. Depending on the complexity of the feature, Reviewers may request more in-depth unittests.
 If necessary, the Freqtrade team can assist and give guidance with writing good tests (however please don't expect anyone to write the tests for you).

-#### How to run tests
-
-Use `pytest` in root folder to run all available testcases and confirm your local environment is setup correctly
-
-!!! Note "feature branches"
-    Tests are expected to pass on the `develop` and `stable` branches. Other branches may be work in progress with tests not working yet.
-
 #### Checking log content in tests

 Freqtrade uses 2 main methods to check log content in tests, `log_has()` and `log_has_re()` (to check using regex, in case of dynamic log-messages).
@ -75,36 +65,6 @@ def test_method_to_test(caplog):

 ```

-### Debug configuration
-
-To debug freqtrade, we recommend VSCode with the following launch configuration (located in `.vscode/launch.json`).
-Details will obviously vary between setups - but this should work to get you started.
-
-``` json
-{
-    "name": "freqtrade trade",
-    "type": "python",
-    "request": "launch",
-    "module": "freqtrade",
-    "console": "integratedTerminal",
-    "args": [
-        "trade",
-        // Optional:
-        // "--userdir", "user_data",
-        "--strategy", 
-        "MyAwesomeStrategy",
-    ]
-},
-```
-
-Command line arguments can be added in the `"args"` array.
-This method can also be used to debug a strategy, by setting the breakpoints within the strategy.
-
-A similar setup can also be taken for Pycharm - using `freqtrade` as module name, and setting the command line arguments as "parameters".
-
-!!! Note "Startup directory"
-    This assumes that you have the repository checked out, and the editor is started at the repository root level (so setup.py is at the top level of your repository).
-
 ## ErrorHandling

 Freqtrade Exceptions all inherit from `FreqtradeException`.
@ -237,12 +197,11 @@ For that reason, they must implement the following methods:
 * `global_stop()`
 * `stop_per_pair()`.

-`global_stop()` and `stop_per_pair()` must return a ProtectionReturn object, which consists of:
+`global_stop()` and `stop_per_pair()` must return a ProtectionReturn tuple, which consists of:

 * lock pair - boolean
 * lock until - datetime - until when should the pair be locked (will be rounded up to the next new candle)
 * reason - string, used for logging and storage in the database
-* lock_side - long, short or '*'.

 The `until` portion should be calculated using the provided `calculate_lock_end()` method.

@ -261,13 +220,13 @@ Protections can have 2 different ways to stop trading for a limited :
 ##### Protections - per pair

 Protections that implement the per pair approach must set `has_local_stop=True`.
-The method `stop_per_pair()` will be called whenever a trade closed (exit order completed).
+The method `stop_per_pair()` will be called whenever a trade closed (sell order completed).

 ##### Protections - global protection

 These Protections should do their evaluation across all pairs, and consequently will also lock all pairs from trading (called a global PairLock).
 Global protection must set `has_global_stop=True` to be evaluated for global stops.
-The method `global_stop()` will be called whenever a trade closed (exit order completed).
+The method `global_stop()` will be called whenever a trade closed (sell order completed).

 ##### Protections - calculating lock end time

@ -305,7 +264,7 @@ Additional tests / steps to complete:
 * Check if balance shows correctly (*)
 * Create market order (*)
 * Create limit order (*)
-* Complete trade (enter + exit) (*)
+* Complete trade (buy + sell) (*)
  * Compare result calculation between exchange and bot
  * Ensure fees are applied correctly (check the database against the exchange)

@ -351,32 +310,6 @@ The output will show the last entry from the Exchange as well as the current UTC
 If the day shows the same day, then the last candle can be assumed as incomplete and should be dropped (leave the setting `"ohlcv_partial_candle"` from the exchange-class untouched / True). Otherwise, set `"ohlcv_partial_candle"` to `False` to not drop Candles (shown in the example above).
 Another way is to run this command multiple times in a row and observe if the volume is changing (while the date remains the same).

-### Update binance cached leverage tiers
-
-Updating leveraged tiers should be done regularly - and requires an authenticated account with futures enabled.
-
-``` python
-import ccxt
-import json
-from pathlib import Path
-
-exchange = ccxt.binance({
-    'apiKey': '<apikey>',
-    'secret': '<secret>'
-    'options': {'defaultType': 'swap'}
-    })
-_ = exchange.load_markets()
-
-lev_tiers = exchange.fetch_leverage_tiers()
-
-# Assumes this is running in the root of the repository.
-file = Path('freqtrade/exchange/binance_leverage_tiers.json')
-json.dump(dict(sorted(lev_tiers.items())), file.open('w'), indent=2)
-
-```
-
-This file should then be contributed upstream, so others can benefit from this, too.
-
 ## Updating example notebooks

 To keep the jupyter notebooks aligned with the documentation, the following should be ran after updating a example notebook.
@ -416,9 +349,8 @@ Determine if crucial bugfixes have been made between this commit and the current

 * Merge the release branch (stable) into this branch.
 * Edit `freqtrade/__init__.py` and add the version matching the current date (for example `2019.7` for July 2019). Minor versions can be `2019.7.1` should we need to do a second release that month. Version numbers must follow allowed versions from PEP0440 to avoid failures pushing to pypi.
-* Commit this part.
-* push that branch to the remote and create a PR against the stable branch.
-* Update develop version to next version following the pattern `2019.8-dev`.
+* Commit this part
+* push that branch to the remote and create a PR against the stable branch

 ### Create changelog from git commits

@ -441,11 +373,6 @@ To keep the release-log short, best wrap the full git changelog into a collapsib
 </details>
 ```

-### FreqUI release
-
-If FreqUI has been updated substantially, make sure to create a release before merging the release branch.
-Make sure that freqUI CI on the release is finished and passed before merging the release.
-
 ### Create github release / tag

 Once the PR against stable is merged (best right after merging):
--- a/docs/docker_quickstart.md
+++ b/docs/docker_quickstart.md
@ -4,22 +4,20 @@ This page explains how to run the bot with Docker. It is not meant to work out o

 ## Install Docker

-Start by downloading and installing Docker / Docker Desktop for your platform:
+Start by downloading and installing Docker CE for your platform:

 * [Mac](https://docs.docker.com/docker-for-mac/install/)
 * [Windows](https://docs.docker.com/docker-for-windows/install/)
 * [Linux](https://docs.docker.com/install/)

-!!! Info "Docker compose install"
-    Freqtrade documentation assumes the use of Docker desktop (or the docker compose plugin).  
-    While the docker-compose standalone installation still works, it will require changing all `docker compose` commands from `docker compose` to `docker-compose` to work (e.g. `docker compose up -d` will become `docker-compose up -d`).
+To simplify running freqtrade, [`docker-compose`](https://docs.docker.com/compose/install/) should be installed and available to follow the below [docker quick start guide](#docker-quick-start).

-## Freqtrade with docker
+## Freqtrade with docker-compose

-Freqtrade provides an official Docker image on [Dockerhub](https://hub.docker.com/r/freqtradeorg/freqtrade/), as well as a [docker compose file](https://github.com/freqtrade/freqtrade/blob/stable/docker-compose.yml) ready for usage.
+Freqtrade provides an official Docker image on [Dockerhub](https://hub.docker.com/r/freqtradeorg/freqtrade/), as well as a [docker-compose file](https://github.com/freqtrade/freqtrade/blob/stable/docker-compose.yml) ready for usage.

 !!! Note
-    - The following section assumes that `docker` is installed and available to the logged in user.
+    - The following section assumes that `docker` and `docker-compose` are installed and available to the logged in user.
    - All below commands use relative directories and will have to be executed from the directory containing the `docker-compose.yml` file.

 ### Docker quick start
@ -33,13 +31,13 @@ cd ft_userdata/
 curl https://raw.githubusercontent.com/freqtrade/freqtrade/stable/docker-compose.yml -o docker-compose.yml

 # Pull the freqtrade image
-docker compose pull
+docker-compose pull

 # Create user directory structure
-docker compose run --rm freqtrade create-userdir --userdir user_data
+docker-compose run --rm freqtrade create-userdir --userdir user_data

 # Create configuration - Requires answering interactive questions
-docker compose run --rm freqtrade new-config --config user_data/config.json
+docker-compose run --rm freqtrade new-config --config user_data/config.json
 ```

 The above snippet creates a new directory called `ft_userdata`, downloads the latest compose file and pulls the freqtrade image.
@ -66,7 +64,7 @@ The `SampleStrategy` is run by default.
 Once this is done, you're ready to launch the bot in trading mode (Dry-run or Live-trading, depending on your answer to the corresponding question you made above).

 ``` bash
-docker compose up -d
+docker-compose up -d
 ```

 !!! Warning "Default configuration"
@ -86,27 +84,27 @@ You can now access the UI by typing localhost:8080 in your browser.

 #### Monitoring the bot

-You can check for running instances with `docker compose ps`.
+You can check for running instances with `docker-compose ps`.
 This should list the service `freqtrade` as `running`. If that's not the case, best check the logs (see next point).

-#### Docker compose logs
+#### Docker-compose logs

 Logs will be written to: `user_data/logs/freqtrade.log`.  
-You can also check the latest log with the command `docker compose logs -f`.
+You can also check the latest log with the command `docker-compose logs -f`.

 #### Database

 The database will be located at: `user_data/tradesv3.sqlite`

-#### Updating freqtrade with docker
+#### Updating freqtrade with docker-compose

-Updating freqtrade when using `docker` is as simple as running the following 2 commands:
+Updating freqtrade when using `docker-compose` is as simple as running the following 2 commands:

 ``` bash
 # Download the latest image
-docker compose pull
+docker-compose pull
 # Restart the image
-docker compose up -d
+docker-compose up -d
 ```

 This will first pull the latest image, and will then restart the container with the just pulled version.
@ -118,43 +116,43 @@ This will first pull the latest image, and will then restart the container with

 Advanced users may edit the docker-compose file further to include all possible options or arguments.

-All freqtrade arguments will be available by running `docker compose run --rm freqtrade <command> <optional arguments>`.
+All freqtrade arguments will be available by running `docker-compose run --rm freqtrade <command> <optional arguments>`.

-!!! Warning "`docker compose` for trade commands"
-    Trade commands (`freqtrade trade <...>`) should not be ran via `docker compose run` - but should use `docker compose up -d` instead.
+!!! Warning "`docker-compose` for trade commands"
+    Trade commands (`freqtrade trade <...>`) should not be ran via `docker-compose run` - but should use `docker-compose up -d` instead.
    This makes sure that the container is properly started (including port forwardings) and will make sure that the container will restart after a system reboot.
    If you intend to use freqUI, please also ensure to adjust the [configuration accordingly](rest-api.md#configuration-with-docker), otherwise the UI will not be available.

-!!! Note "`docker compose run --rm`"
+!!! Note "`docker-compose run --rm`"
    Including `--rm` will remove the container after completion, and is highly recommended for all modes except trading mode (running with `freqtrade trade` command).

-??? Note "Using docker without docker"
-    "`docker compose run --rm`" will require a compose file to be provided.
+??? Note "Using docker without docker-compose"
+    "`docker-compose run --rm`" will require a compose file to be provided.
    Some freqtrade commands that don't require authentication such as `list-pairs` can be run with "`docker run --rm`" instead.  
    For example `docker run --rm freqtradeorg/freqtrade:stable list-pairs --exchange binance --quote BTC --print-json`.  
    This can be useful for fetching exchange information to add to your `config.json` without affecting your running containers.

-#### Example: Download data with docker
+#### Example: Download data with docker-compose

 Download backtesting data for 5 days for the pair ETH/BTC and 1h timeframe from Binance. The data will be stored in the directory `user_data/data/` on the host.

 ``` bash
-docker compose run --rm freqtrade download-data --pairs ETH/BTC --exchange binance --days 5 -t 1h
+docker-compose run --rm freqtrade download-data --pairs ETH/BTC --exchange binance --days 5 -t 1h
 ```

 Head over to the [Data Downloading Documentation](data-download.md) for more details on downloading data.

-#### Example: Backtest with docker
+#### Example: Backtest with docker-compose

 Run backtesting in docker-containers for SampleStrategy and specified timerange of historical data, on 5m timeframe:

 ``` bash
-docker compose run --rm freqtrade backtesting --config user_data/config.json --strategy SampleStrategy --timerange 20190801-20191001 -i 5m
+docker-compose run --rm freqtrade backtesting --config user_data/config.json --strategy SampleStrategy --timerange 20190801-20191001 -i 5m
 ```

 Head over to the [Backtesting Documentation](backtesting.md) to learn more.

-### Additional dependencies with docker
+### Additional dependencies with docker-compose

 If your strategy requires dependencies not included in the default image - it will be necessary to build the image on your host.
 For this, please create a Dockerfile containing installation steps for the additional dependencies (have a look at [docker/Dockerfile.custom](https://github.com/freqtrade/freqtrade/blob/develop/docker/Dockerfile.custom) for an example).
@ -168,15 +166,15 @@ You'll then also need to modify the `docker-compose.yml` file and uncomment the
      dockerfile: "./Dockerfile.<yourextension>"
 ```

-You can then run `docker compose build --pull` to build the docker image, and run it using the commands described above.
+You can then run `docker-compose build --pull` to build the docker image, and run it using the commands described above.

-### Plotting with docker
+### Plotting with docker-compose

 Commands `freqtrade plot-profit` and `freqtrade plot-dataframe` ([Documentation](plotting.md)) are available by changing the image to `*_plot` in your docker-compose.yml file.
 You can then use these commands as follows:

 ``` bash
-docker compose run --rm freqtrade plot-dataframe --strategy AwesomeStrategy -p BTC/ETH --timerange=20180801-20180805
+docker-compose run --rm freqtrade plot-dataframe --strategy AwesomeStrategy -p BTC/ETH --timerange=20180801-20180805
 ```

 The output will be stored in the `user_data/plot` directory, and can be opened with any modern browser.
@ -187,7 +185,7 @@ Freqtrade provides a docker-compose file which starts up a jupyter lab server.
 You can run this server using the following command:

 ``` bash
-docker compose -f docker/docker-compose-jupyter.yml up
+docker-compose -f docker/docker-compose-jupyter.yml up
 ```

 This will create a docker-container running jupyter lab, which will be accessible using `https://127.0.0.1:8888/lab`.
@ -196,7 +194,7 @@ Please use the link that's printed in the console after startup for simplified l
 Since part of this image is built on your machine, it is recommended to rebuild the image from time to time to keep freqtrade (and dependencies) up-to-date.

 ``` bash
-docker compose -f docker/docker-compose-jupyter.yml build --no-cache
+docker-compose -f docker/docker-compose-jupyter.yml build --no-cache
 ```

 ## Troubleshooting
--- a/docs/edge.md
+++ b/docs/edge.md
@ -222,7 +222,7 @@ usage: freqtrade edge [-h] [-v] [--logfile FILE] [-V] [-c PATH] [-d PATH]

 optional arguments:
  -h, --help            show this help message and exit
-  -i TIMEFRAME, --timeframe TIMEFRAME
+  -i TIMEFRAME, --timeframe TIMEFRAME, --ticker-interval TIMEFRAME
                        Specify timeframe (`1m`, `5m`, `30m`, `1h`, `1d`).
  --timerange TIMERANGE
                        Specify what timerange of data to use.
--- a/docs/exchanges.md
+++ b/docs/exchanges.md
@ -1,6 +1,6 @@
 # Exchange-specific Notes

-This page combines common gotchas and Information which are exchange-specific and most likely don't apply to other exchanges.
+This page combines common gotchas and informations which are exchange-specific and most likely don't apply to other exchanges.

 ## Exchange configuration

@ -54,19 +54,15 @@ This configuration enables kraken, as well as rate-limiting to avoid bans from t

 ## Binance

-!!! Warning "Server location and geo-ip restrictions"
-    Please be aware that binance restrict api access regarding the server country. The currents and non exhaustive countries blocked are United States, Malaysia (Singapour), Ontario (Canada). Please go to [binance terms > b. Eligibility](https://www.binance.com/en/terms) to find up to date list.
-
 Binance supports [time_in_force](configuration.md#understand-order_time_in_force).

 !!! Tip "Stoploss on Exchange"
-    Binance supports `stoploss_on_exchange` and uses `stop-loss-limit` orders. It provides great advantages, so we recommend to benefit from it by enabling stoploss on exchange.
-    On futures, Binance supports both `stop-limit` as well as `stop-market` orders. You can use either `"limit"` or `"market"` in the `order_types.stoploss` configuration setting to decide which type to use.
+    Binance supports `stoploss_on_exchange` and uses stop-loss-limit orders. It provides great advantages, so we recommend to benefit from it.

-### Binance Blacklist recommendation
+### Binance Blacklist

-For Binance, it is suggested to add `"BNB/<STAKE>"` to your blacklist to avoid issues, unless you are willing to maintain enough extra `BNB` on the account or unless you're willing to disable using `BNB` for fees.
-Binance accounts may use `BNB` for fees, and if a trade happens to be on `BNB`, further trades may consume this position and make the initial BNB trade unsellable as the expected amount is not there anymore.
+For Binance, please add `"BNB/<STAKE>"` to your blacklist to avoid issues.
+Accounts having BNB accounts use this to pay for fees - if your first trade happens to be on `BNB`, further trades will consume this position and make the initial BNB trade unsellable as the expected amount is not there anymore.

 ### Binance sites

@ -75,56 +71,6 @@ Binance has been split into 2, and users must use the correct ccxt exchange ID f
 * [binance.com](https://www.binance.com/) - International users. Use exchange id: `binance`.
 * [binance.us](https://www.binance.us/) - US based users. Use exchange id: `binanceus`.

-### Binance RSA keys
-
-Freqtrade supports binance RSA API keys.
-
-We recommend to use them as environment variable.
-
-``` bash
-export FREQTRADE__EXCHANGE__SECRET="$(cat ./rsa_binance.private)"
-```
-
-They can however also be configured via configuration file. Since json doesn't support multi-line strings, you'll have to replace all newlines with `\n` to have a valid json file.
-
-``` json
-// ...
- "key": "<someapikey>",
- "secret": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBABACAFQA<...>s8KX8=\n-----END PRIVATE KEY-----"
-// ...
-```
-
-### Binance Futures
-
-Binance has specific (unfortunately complex) [Futures Trading Quantitative Rules](https://www.binance.com/en/support/faq/4f462ebe6ff445d4a170be7d9e897272) which need to be followed, and which prohibit a too low stake-amount (among others) for too many orders.
-Violating these rules will result in a trading restriction.
-
-When trading on Binance Futures market, orderbook must be used because there is no price ticker data for futures.
-
-``` jsonc
-  "entry_pricing": {
-      "use_order_book": true,
-      "order_book_top": 1,
-      "check_depth_of_market": {
-          "enabled": false,
-          "bids_to_ask_delta": 1
-      }
-  },
-  "exit_pricing": {
-      "use_order_book": true,
-      "order_book_top": 1
-  },
-```
-
-#### Binance futures settings
-
-Users will also have to have the futures-setting "Position Mode" set to "One-way Mode", and "Asset Mode" set to "Single-Asset Mode".
-These settings will be checked on startup, and freqtrade will show an error if this setting is wrong.
-
-![Binance futures settings](assets/binance_futures_settings.png)
-
-Freqtrade will not attempt to change these settings.
-
 ## Kraken

 !!! Tip "Stoploss on Exchange"
@ -195,6 +141,26 @@ res = [p for p, x in lm.items() if 'US' in x['info']['prohibitedIn']]
 print(res)
 ```

+## FTX
+
+!!! Tip "Stoploss on Exchange"
+    FTX supports `stoploss_on_exchange` and can use both stop-loss-market and stop-loss-limit orders. It provides great advantages, so we recommend to benefit from it.
+    You can use either `"limit"` or `"market"` in the `order_types.stoploss` configuration setting to decide which type of stoploss shall be used.
+
+### Using subaccounts
+
+To use subaccounts with FTX, you need to edit the configuration and add the following:
+
+``` json
+"exchange": {
+    "ccxt_config": {
+        "headers": {
+            "FTX-SUBACCOUNT": "name"
+        }
+    },
+}
+```
+
 ## Kucoin

 Kucoin 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:
@ -211,21 +177,12 @@ Kucoin requires a passphrase for each api key, you will therefore need to add th

 Kucoin supports [time_in_force](configuration.md#understand-order_time_in_force).

-!!! Tip "Stoploss on Exchange"
-    Kucoin supports `stoploss_on_exchange` and can use both stop-loss-market and stop-loss-limit orders. It provides great advantages, so we recommend to benefit from it.
-    You can use either `"limit"` or `"market"` in the `order_types.stoploss` configuration setting to decide which type of stoploss shall be used.
-
 ### Kucoin Blacklists

-For Kucoin, it is suggested to add `"KCS/<STAKE>"` to your blacklist to avoid issues, unless you are willing to maintain enough extra `KCS` on the account or unless you're willing to disable using `KCS` for fees. 
-Kucoin accounts may use `KCS` for fees, and if a trade happens to be on `KCS`, further trades may consume this position and make the initial `KCS` trade unsellable as the expected amount is not there anymore.
+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.

-## Huobi
-
-!!! Tip "Stoploss on Exchange"
-    Huobi supports `stoploss_on_exchange` and uses `stop-limit` orders. It provides great advantages, so we recommend to benefit from it by enabling stoploss on exchange.
-
-## OKX (former OKEX)
+## OKX

 OKX 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:

@ -242,31 +199,11 @@ OKX requires a passphrase for each api key, you will therefore need to add this
 !!! Warning
    OKX only provides 100 candles per api call. Therefore, the strategy will only have a pretty low amount of data available in backtesting mode.

-!!! Warning "Futures"
-    OKX Futures has the concept of "position mode" - which can be "Buy/Sell" or long/short (hedge mode).
-    Freqtrade supports both modes (we recommend to use Buy/Sell mode) - but changing the mode mid-trading is not supported and will lead to exceptions and failures to place trades.
-    OKX also only provides MARK candles for the past ~3 months. Backtesting futures prior to that date will therefore lead to slight deviations, as funding-fees cannot be calculated correctly without this data.
-
 ## Gate.io

-!!! Tip "Stoploss on Exchange"
-    Gate.io supports `stoploss_on_exchange` and uses `stop-loss-limit` orders. It provides great advantages, so we recommend to benefit from it by enabling stoploss on exchange..
-
 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.

-## Bybit
-
-Futures trading on bybit is currently supported for USDT markets, and will use isolated futures mode.
-Users with unified accounts (there's no way back) can create a Sub-account which will start as "non-unified", and can therefore use isolated futures.
-On startup, freqtrade will set the position mode to "One-way Mode" for the whole (sub)account. This avoids making this call over and over again (slowing down bot operations), but means that changes to this setting may result in exceptions and errors.
-
-As bybit doesn't provide funding rate history, the dry-run calculation is used for live trades as well.
-
-!!! Tip "Stoploss on Exchange"
-    Bybit (futures only) supports `stoploss_on_exchange` and uses `stop-loss-limit` orders. It provides great advantages, so we recommend to benefit from it by enabling stoploss on exchange.
-    On futures, Bybit supports both `stop-limit` as well as `stop-market` orders. You can use either `"limit"` or `"market"` in the `order_types.stoploss` configuration setting to decide which type to use.
-
 ## 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.
@ -302,7 +239,7 @@ For example, to test the order type `FOK` with Kraken, and modify candle limit t
 "exchange": {
    "name": "kraken",
    "_ft_has_params": {
-        "order_time_in_force": ["GTC", "FOK"],
+        "order_time_in_force": ["gtc", "fok"],
        "ohlcv_candle_limit": 200
        }
    //...
--- a/docs/faq.md
+++ b/docs/faq.md
@ -2,19 +2,17 @@

 ## Supported Markets

-Freqtrade supports spot trading, as well as (isolated) futures trading for some selected exchanges. Please refer to the [documentation start page](index.md#supported-futures-exchanges-experimental) for an uptodate list of supported exchanges.
+Freqtrade supports spot trading only.

-### Can my bot open short positions?
+### Can I open short positions?

-Freqtrade can open short positions in futures markets.
-This requires the strategy to be made for this - and `"trading_mode": "futures"` in the configuration.
-Please make sure to read the [relevant documentation page](leverage.md) first.
+No, Freqtrade does not support trading with margin / leverage, and cannot open short positions.

-In spot markets, you can in some cases use leveraged spot tokens, which reflect an inverted pair (eg. BTCUP/USD, BTCDOWN/USD, ETHBULL/USD, ETHBEAR/USD,...) which can be traded with Freqtrade.
+In some cases, your exchange may provide leveraged spot tokens which can be traded with Freqtrade eg. BTCUP/USD, BTCDOWN/USD, ETHBULL/USD, ETHBEAR/USD, etc...

-### Can my bot trade options or futures?
+### Can I trade options or futures?

-Futures trading is supported for selected exchanges. Please refer to the [documentation start page](index.md#supported-futures-exchanges-experimental) for an uptodate list of supported exchanges.
+No, options and futures trading are not supported.

 ## Beginner Tips & Tricks

@ -22,13 +20,6 @@ Futures trading is supported for selected exchanges. Please refer to the [docume

 ## Freqtrade common issues

-### Can freqtrade open multiple positions on the same pair in parallel?
-
-No. Freqtrade will only open one position per pair at a time.
-You can however use the [`adjust_trade_position()` callback](strategy-callbacks.md#adjust-trade-position) to adjust an open position.
-
-Backtesting provides an option for this in `--eps` - however this is only there to highlight "hidden" signals, and will not work in live.
-
 ### The bot does not start

 Running the bot with `freqtrade trade --config config.json` shows the output `freqtrade: command not found`.
@ -37,7 +28,7 @@ This could be caused by the following reasons:

 * The virtual environment is not active.
  * Run `source .env/bin/activate` to activate the virtual environment.
-* The installation did not complete successfully.
+* The installation did not work correctly.
  * Please check the [Installation documentation](installation.md).

 ### I have waited 5 minutes, why hasn't the bot made any trades yet?
@ -74,7 +65,7 @@ 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.
+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.

@ -84,9 +75,9 @@ Freqtrade will not provide incomplete candles to strategies. Using incomplete ca

 You can use "current" market data by using the [dataprovider](strategy-customization.md#orderbookpair-maximum)'s orderbook or ticker methods - which however cannot be used during backtesting.

-### Is there a setting to only Exit the trades being held and not perform any new Entries?
+### Is there a setting to only SELL the coins being held and not perform anymore BUYS?

-You can use the `/stopentry` command in Telegram to prevent future trade entry, followed by `/forceexit all` (sell all open trades).
+You can use the `/stopbuy` command in Telegram to prevent future buys, followed by `/forcesell all` (sell all open trades).

 ### I want to run multiple bots on the same machine

@ -102,12 +93,6 @@ 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 "Price jump between 2 candles detected"
-
-This message is a warning that the candles had a price jump of > 30%.
-This might be a sign that the pair stopped trading, and some token exchange took place (e.g. COCOS in 2021 - where price jumped from 0.0000154 to 0.01621).
-This message is often accompanied by ["Missing data fillup"](#im-getting-missing-data-fillup-messages-in-the-log) - as trading on such pairs is often stopped for some time.
-
 ### 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).
@ -122,7 +107,7 @@ This warning can point to one of the below problems:

 ### I'm getting the "RESTRICTED_MARKET" message in the log

-Currently known to happen for US Bittrex users.
+Currently known to happen for US Bittrex users.  

 Read [the Bittrex section about restricted markets](exchanges.md#restricted-markets) for more information.

@ -132,10 +117,10 @@ As the message says, your exchange does not support market orders and you have o

 To fix this, redefine order types in the strategy to use "limit" instead of "market":

-``` python
+```
    order_types = {
        ...
-        "stoploss": "limit",
+        'stoploss': 'limit',
        ...
    }
 ```
@ -190,8 +175,8 @@ The GPU improvements would only apply to pandas-native calculations - or ones wr
 For hyperopt, freqtrade is using scikit-optimize, which is built on top of scikit-learn.
 Their statement about GPU support is [pretty clear](https://scikit-learn.org/stable/faq.html#will-you-add-gpu-support).

-GPU's also are only good at crunching numbers (floating point operations).
-For hyperopt, we need both number-crunching (find next parameters) and running python code (running backtesting).
+GPU's also are only good at crunching numbers (floating point operations). 
+For hyperopt, we need both number-crunching (find next parameters) and running python code (running backtesting). 
 As such, GPU's are not too well suited for most parts of hyperopt.

 The benefit of using GPU would therefore be pretty slim - and will not justify the complexity introduced by trying to add GPU support.
@ -232,9 +217,9 @@ already 8\*10^9\*10 evaluations. A roughly total of 80 billion evaluations.
 Did you run 100 000 evaluations? Congrats, you've done roughly 1 / 100 000 th
 of the search space, assuming that the bot never tests the same parameters more than once.

-* The time it takes to run 1000 hyperopt epochs depends on things like: The available cpu, hard-disk, ram, timeframe, timerange, indicator settings, indicator count, amount of coins that hyperopt test strategies on and the resulting trade count - which can be 650 trades in a year or 100000 trades depending if the strategy aims for big profits by trading rarely or for many low profit trades.
+* The time it takes to run 1000 hyperopt epochs depends on things like: The available cpu, hard-disk, ram, timeframe, timerange, indicator settings, indicator count, amount of coins that hyperopt test strategies on and the resulting trade count - which can be 650 trades in a year or 100000 trades depending if the strategy aims for big profits by trading rarely or for many low profit trades. 

-Example: 4% profit 650 times vs 0,3% profit a trade 10000 times in a year. If we assume you set the --timerange to 365 days.
+Example: 4% profit 650 times vs 0,3% profit a trade 10000 times in a year. If we assume you set the --timerange to 365 days. 

 Example:
 `freqtrade --config config.json --strategy SampleStrategy --hyperopt SampleHyperopt -e 1000 --timerange 20190601-20200601`
@ -248,26 +233,8 @@ The Edge module is mostly a result of brainstorming of [@mishaker](https://githu
 You can find further info on expectancy, win rate, risk management and position size in the following sources:

 - https://www.tradeciety.com/ultimate-math-guide-for-traders/
+- http://www.vantharp.com/tharp-concepts/expectancy.asp
 - https://samuraitradingacademy.com/trading-expectancy/
 - https://www.learningmarkets.com/determining-expectancy-in-your-trading/
- https://www.lonestocktrader.com/make-money-trading-positive-expectancy/
+- http://www.lonestocktrader.com/make-money-trading-positive-expectancy/
 - https://www.babypips.com/trading/trade-expectancy-matter
-
-## Official channels
-
-Freqtrade is using exclusively the following official channels:
-
-* [Freqtrade discord server](https://discord.gg/p7nuUNVfP7)
-* [Freqtrade documentation (https://freqtrade.io)](https://freqtrade.io)
-* [Freqtrade github organization](https://github.com/freqtrade)
-
-Nobody affiliated with the freqtrade project will ask you about your exchange keys or anything else exposing your funds to exploitation.
-Should you be asked to expose your exchange keys or send funds to some random wallet, then please don't follow these instructions.
-
-Failing to follow these guidelines will not be responsibility of freqtrade.
-
-## "Freqtrade token"
-
-Freqtrade does not have a Crypto token offering.
-
-Token offerings you find on the internet referring Freqtrade, FreqAI or freqUI must be considered to be a scam, trying to exploit freqtrade's popularity for their own, nefarious gains.
--- a/docs/freqai-configuration.md
+++ b/docs/freqai-configuration.md
@ -1,396 +0,0 @@
-# Configuration
-
-FreqAI is configured through the typical [Freqtrade config file](configuration.md) and the standard [Freqtrade strategy](strategy-customization.md). Examples of FreqAI config and strategy files can be found in `config_examples/config_freqai.example.json` and `freqtrade/templates/FreqaiExampleStrategy.py`, respectively.
-
-## Setting up the configuration file
-
- Although there are plenty of additional parameters to choose from, as highlighted in the [parameter table](freqai-parameter-table.md#parameter-table), a FreqAI config must at minimum include the following parameters (the parameter values are only examples):
-
-```json
-    "freqai": {
-        "enabled": true,
-        "purge_old_models": 2,
-        "train_period_days": 30,
-        "backtest_period_days": 7,
-        "identifier" : "unique-id",
-        "feature_parameters" : {
-            "include_timeframes": ["5m","15m","4h"],
-            "include_corr_pairlist": [
-                "ETH/USD",
-                "LINK/USD",
-                "BNB/USD"
-            ],
-            "label_period_candles": 24,
-            "include_shifted_candles": 2,
-            "indicator_periods_candles": [10, 20]
-        },
-        "data_split_parameters" : {
-            "test_size": 0.25
-        }
-    }
-```
-
-A full example config is available in `config_examples/config_freqai.example.json`.
-
-## Building a FreqAI strategy
-
-The FreqAI strategy requires including the following lines of code in the standard [Freqtrade strategy](strategy-customization.md):
-
-```python
-    # user should define the maximum startup candle count (the largest number of candles
-    # passed to any single indicator)
-    startup_candle_count: int = 20
-
-    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
-
-        # the model will return all labels created by user in `set_freqai_labels()`
-        # (& appended targets), an indication of whether or not the prediction should be accepted,
-        # the target mean/std values for each of the labels created by user in
-        # `feature_engineering_*` for each training period.
-
-        dataframe = self.freqai.start(dataframe, metadata, self)
-
-        return dataframe
-
-    def feature_engineering_expand_all(self, dataframe, period, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        This function will automatically expand the defined features on the config defined
-        `indicator_periods_candles`, `include_timeframes`, `include_shifted_candles`, and
-        `include_corr_pairs`. In other words, a single feature defined in this function
-        will automatically expand to a total of
-        `indicator_periods_candles` * `include_timeframes` * `include_shifted_candles` *
-        `include_corr_pairs` numbers of features added to the model.
-
-        All features must be prepended with `%` to be recognized by FreqAI internals.
-
-        :param df: strategy dataframe which will receive the features
-        :param period: period of the indicator - usage example:
-        dataframe["%-ema-period"] = ta.EMA(dataframe, timeperiod=period)
-        """
-
-        dataframe["%-rsi-period"] = ta.RSI(dataframe, timeperiod=period)
-        dataframe["%-mfi-period"] = ta.MFI(dataframe, timeperiod=period)
-        dataframe["%-adx-period"] = ta.ADX(dataframe, timeperiod=period)
-        dataframe["%-sma-period"] = ta.SMA(dataframe, timeperiod=period)
-        dataframe["%-ema-period"] = ta.EMA(dataframe, timeperiod=period)
-
-        return dataframe
-
-    def feature_engineering_expand_basic(self, dataframe, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        This function will automatically expand the defined features on the config defined
-        `include_timeframes`, `include_shifted_candles`, and `include_corr_pairs`.
-        In other words, a single feature defined in this function
-        will automatically expand to a total of
-        `include_timeframes` * `include_shifted_candles` * `include_corr_pairs`
-        numbers of features added to the model.
-
-        Features defined here will *not* be automatically duplicated on user defined
-        `indicator_periods_candles`
-
-        All features must be prepended with `%` to be recognized by FreqAI internals.
-
-        :param df: strategy dataframe which will receive the features
-        dataframe["%-pct-change"] = dataframe["close"].pct_change()
-        dataframe["%-ema-200"] = ta.EMA(dataframe, timeperiod=200)
-        """
-        dataframe["%-pct-change"] = dataframe["close"].pct_change()
-        dataframe["%-raw_volume"] = dataframe["volume"]
-        dataframe["%-raw_price"] = dataframe["close"]
-        return dataframe
-
-    def feature_engineering_standard(self, dataframe, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        This optional function will be called once with the dataframe of the base timeframe.
-        This is the final function to be called, which means that the dataframe entering this
-        function will contain all the features and columns created by all other
-        freqai_feature_engineering_* functions.
-
-        This function is a good place to do custom exotic feature extractions (e.g. tsfresh).
-        This function is a good place for any feature that should not be auto-expanded upon
-        (e.g. day of the week).
-
-        All features must be prepended with `%` to be recognized by FreqAI internals.
-
-        :param df: strategy dataframe which will receive the features
-        usage example: dataframe["%-day_of_week"] = (dataframe["date"].dt.dayofweek + 1) / 7
-        """
-        dataframe["%-day_of_week"] = (dataframe["date"].dt.dayofweek + 1) / 7
-        dataframe["%-hour_of_day"] = (dataframe["date"].dt.hour + 1) / 25
-        return dataframe
-
-    def set_freqai_targets(self, dataframe, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        Required function to set the targets for the model.
-        All targets must be prepended with `&` to be recognized by the FreqAI internals.
-
-        :param df: strategy dataframe which will receive the targets
-        usage example: dataframe["&-target"] = dataframe["close"].shift(-1) / dataframe["close"]
-        """
-        dataframe["&-s_close"] = (
-            dataframe["close"]
-            .shift(-self.freqai_info["feature_parameters"]["label_period_candles"])
-            .rolling(self.freqai_info["feature_parameters"]["label_period_candles"])
-            .mean()
-            / dataframe["close"]
-            - 1
-            )
-```
-
-Notice how the `feature_engineering_*()` is where [features](freqai-feature-engineering.md#feature-engineering) are added. Meanwhile `set_freqai_targets()` adds the labels/targets. A full example strategy is available in `templates/FreqaiExampleStrategy.py`.
-
-!!! Note
-    The `self.freqai.start()` function cannot be called outside the `populate_indicators()`.
-
-!!! Note
-    Features **must** be defined in `feature_engineering_*()`. Defining FreqAI features in `populate_indicators()`
-    will cause the algorithm to fail in live/dry mode. In order to add generalized features that are not associated with a specific pair or timeframe, you should use `feature_engineering_standard()`
-    (as exemplified in `freqtrade/templates/FreqaiExampleStrategy.py`).
-
-## Important dataframe key patterns
-
-Below are the values you can expect to include/use inside a typical strategy dataframe (`df[]`):
-
-|  DataFrame Key | Description |
-|------------|-------------|
-| `df['&*']` | Any dataframe column prepended with `&` in `set_freqai_targets()` is treated as a training target (label) inside FreqAI (typically following the naming convention `&-s*`). For example, to predict the close price 40 candles into the future, you would set `df['&-s_close'] = df['close'].shift(-self.freqai_info["feature_parameters"]["label_period_candles"])` with `"label_period_candles": 40` in the config. FreqAI makes the predictions and gives them back under the same key (`df['&-s_close']`) to be used in `populate_entry/exit_trend()`. <br> **Datatype:** Depends on the output of the model.
-| `df['&*_std/mean']` | Standard deviation and mean values of the defined labels during training (or live tracking with `fit_live_predictions_candles`). Commonly used to understand the rarity of a prediction (use the z-score as shown in `templates/FreqaiExampleStrategy.py` and explained [here](#creating-a-dynamic-target-threshold) to evaluate how often a particular prediction was observed during training or historically with `fit_live_predictions_candles`). <br> **Datatype:** Float.
-| `df['do_predict']` | Indication of an outlier data point. The return value is integer between -2 and 2, which lets you know if the prediction is trustworthy or not. `do_predict==1` means that the prediction is trustworthy. If the Dissimilarity Index (DI, see details [here](freqai-feature-engineering.md#identifying-outliers-with-the-dissimilarity-index-di)) of the input data point is above the threshold defined in the config, FreqAI will subtract 1 from `do_predict`, resulting in `do_predict==0`. If `use_SVM_to_remove_outliers()` is active, the Support Vector Machine (SVM, see details [here](freqai-feature-engineering.md#identifying-outliers-using-a-support-vector-machine-svm)) may also detect outliers in training and prediction data. In this case, the SVM will also subtract 1 from `do_predict`. If the input data point was considered an outlier by the SVM but not by the DI, or vice versa, the result will be `do_predict==0`. If both the DI and the SVM considers the input data point to be an outlier, the result will be `do_predict==-1`. As with the SVM, if `use_DBSCAN_to_remove_outliers` is active, DBSCAN (see details [here](freqai-feature-engineering.md#identifying-outliers-with-dbscan)) may also detect outliers and subtract 1 from `do_predict`. Hence, if both the SVM and DBSCAN are active and identify a datapoint that was above the DI threshold as an outlier, the result will be `do_predict==-2`. A particular case is when `do_predict == 2`, which means that the model has expired due to exceeding `expired_hours`. <br> **Datatype:** Integer between -2 and 2.
-| `df['DI_values']` | Dissimilarity Index (DI) values are proxies for the level of confidence FreqAI has in the prediction. A lower DI means the prediction is close to the training data, i.e., higher prediction confidence. See details about the DI [here](freqai-feature-engineering.md#identifying-outliers-with-the-dissimilarity-index-di). <br> **Datatype:** Float.
-| `df['%*']` | Any dataframe column prepended with `%` in `feature_engineering_*()` is treated as a training feature. For example, you can include the RSI in the training feature set (similar to in `templates/FreqaiExampleStrategy.py`) by setting `df['%-rsi']`. See more details on how this is done [here](freqai-feature-engineering.md). <br> **Note:** Since the number of features prepended with `%` can multiply very quickly (10s of thousands of features are easily engineered using the multiplictative functionality of, e.g., `include_shifted_candles` and `include_timeframes` as described in the [parameter table](freqai-parameter-table.md)), these features are removed from the dataframe that is returned from FreqAI to the strategy. To keep a particular type of feature for plotting purposes, you would prepend it with `%%`. <br> **Datatype:** Depends on the output of the model.
-
-## Setting the `startup_candle_count`
-
-The `startup_candle_count` in the FreqAI strategy needs to be set up in the same way as in the standard Freqtrade strategy (see details [here](strategy-customization.md#strategy-startup-period)). This value is used by Freqtrade to ensure that a sufficient amount of data is provided when calling the `dataprovider`, to avoid any NaNs at the beginning of the first training. You can easily set this value by identifying the longest period (in candle units) which is passed to the indicator creation functions (e.g., TA-Lib functions). In the presented example, `startup_candle_count` is 20 since this is the maximum value in `indicators_periods_candles`.
-
-!!! Note
-    There are instances where the TA-Lib functions actually require more data than just the passed `period` or else the feature dataset gets populated with NaNs. Anecdotally, multiplying the `startup_candle_count` by 2 always leads to a fully NaN free training dataset. Hence, it is typically safest to multiply the expected `startup_candle_count` by 2. Look out for this log message to confirm that the data is clean:
-
-    ```
-    2022-08-31 15:14:04 - freqtrade.freqai.data_kitchen - INFO - dropped 0 training points due to NaNs in populated dataset 4319.
-    ```
-
-## Creating a dynamic target threshold
-
-Deciding when to enter or exit a trade can be done in a dynamic way to reflect current market conditions. FreqAI allows you to return additional information from the training of a model (more info [here](freqai-feature-engineering.md#returning-additional-info-from-training)). For example, the `&*_std/mean` return values describe the statistical distribution of the target/label *during the most recent training*. Comparing a given prediction to these values allows you to know the rarity of the prediction. In `templates/FreqaiExampleStrategy.py`, the `target_roi` and  `sell_roi` are defined to be 1.25 z-scores away from the mean which causes predictions that are closer to the mean to be filtered out.
-
-```python
-dataframe["target_roi"] = dataframe["&-s_close_mean"] + dataframe["&-s_close_std"] * 1.25
-dataframe["sell_roi"] = dataframe["&-s_close_mean"] - dataframe["&-s_close_std"] * 1.25
-```
-
-To consider the population of *historical predictions* for creating the dynamic target instead of information from the training as discussed above, you would set `fit_live_predictions_candles` in the config to the number of historical prediction candles you wish to use to generate target statistics.
-
-```json
-    "freqai": {
-        "fit_live_predictions_candles": 300,
-    }
-```
-
-If this value is set, FreqAI will initially use the predictions from the training data and subsequently begin introducing real prediction data as it is generated. FreqAI will save this historical data to be reloaded if you stop and restart a model with the same `identifier`.
-
-## Using different prediction models
-
-FreqAI has multiple example prediction model libraries that are ready to be used as is via the flag `--freqaimodel`. These libraries include `CatBoost`, `LightGBM`, and `XGBoost` regression, classification, and multi-target models, and can be found in `freqai/prediction_models/`.
-
-Regression and classification models differ in what targets they predict - a regression model will predict a target of continuous values, for example what price BTC will be at tomorrow, whilst a classifier will predict a target of discrete values, for example if the price of BTC will go up tomorrow or not. This means that you have to specify your targets differently depending on which model type you are using (see details [below](#setting-model-targets)).
-
-All of the aforementioned model libraries implement gradient boosted decision tree algorithms. They all work on the principle of ensemble learning, where predictions from multiple simple learners are combined to get a final prediction that is more stable and generalized. The simple learners in this case are decision trees. Gradient boosting refers to the method of learning, where each simple learner is built in sequence - the subsequent learner is used to improve on the error from the previous learner. If you want to learn more about the different model libraries you can find the information in their respective docs:
-
-* CatBoost: https://catboost.ai/en/docs/
-* LightGBM: https://lightgbm.readthedocs.io/en/v3.3.2/#
-* XGBoost: https://xgboost.readthedocs.io/en/stable/#
-
-There are also numerous online articles describing and comparing the algorithms. Some relatively lightweight examples would be [CatBoost vs. LightGBM vs. XGBoost — Which is the best algorithm?](https://towardsdatascience.com/catboost-vs-lightgbm-vs-xgboost-c80f40662924#:~:text=In%20CatBoost%2C%20symmetric%20trees%2C%20or,the%20same%20depth%20can%20differ.) and [XGBoost, LightGBM or CatBoost — which boosting algorithm should I use?](https://medium.com/riskified-technology/xgboost-lightgbm-or-catboost-which-boosting-algorithm-should-i-use-e7fda7bb36bc). Keep in mind that the performance of each model is highly dependent on the application and so any reported metrics might not be true for your particular use of the model.
-
-Apart from the models already available in FreqAI, it is also possible to customize and create your own prediction models using the `IFreqaiModel` class. You are encouraged to inherit `fit()`, `train()`, and `predict()` to customize various aspects of the training procedures. You can place custom FreqAI models in `user_data/freqaimodels` - and freqtrade will pick them up from there based on the provided `--freqaimodel` name - which has to correspond to the class name of your custom model.
-Make sure to use unique names to avoid overriding built-in models.
-
-### Setting model targets
-
-#### Regressors
-
-If you are using a regressor, you need to specify a target that has continuous values. FreqAI includes a variety of regressors, such as the `CatboostRegressor`via the flag `--freqaimodel CatboostRegressor`. An example of how you could set a regression target for predicting the price 100 candles into the future would be
-
-```python
-df['&s-close_price'] = df['close'].shift(-100)
-```
-
-If you want to predict multiple targets, you need to define multiple labels using the same syntax as shown above.
-
-#### Classifiers
-
-If you are using a classifier, you need to specify a target that has discrete values. FreqAI includes a variety of classifiers, such as the `CatboostClassifier` via the flag `--freqaimodel CatboostClassifier`. If you elects to use a classifier, the classes need to be set using strings. For example, if you want to predict if the price 100 candles into the future goes up or down you would set
-
-```python
-df['&s-up_or_down'] = np.where( df["close"].shift(-100) > df["close"], 'up', 'down')
-```
-
-If you want to predict multiple targets you must specify all labels in the same label column. You could, for example, add the label `same` to define where the price was unchanged by setting
-
-```python
-df['&s-up_or_down'] = np.where( df["close"].shift(-100) > df["close"], 'up', 'down')
-df['&s-up_or_down'] = np.where( df["close"].shift(-100) == df["close"], 'same', df['&s-up_or_down'])
-```
-
-## PyTorch Module
-
-### Quick start
-
-The easiest way to quickly run a pytorch model is with the following command (for regression task):
-
-```bash
-freqtrade trade --config config_examples/config_freqai.example.json --strategy FreqaiExampleStrategy --freqaimodel PyTorchMLPRegressor --strategy-path freqtrade/templates 
-```
-
-!!! note "Installation/docker"
-    The PyTorch module requires large packages such as `torch`, which should be explicitly requested during `./setup.sh -i` by answering "y" to the question "Do you also want dependencies for freqai-rl or PyTorch (~700mb additional space required) [y/N]?".
-    Users who prefer docker should ensure they use the docker image appended with `_freqaitorch`.
-
-### Structure
-
-#### Model
-
-You can construct your own Neural Network architecture in PyTorch by simply defining your `nn.Module` class inside your custom [`IFreqaiModel` file](#using-different-prediction-models) and then using that class in your `def train()` function. Here is an example of logistic regression model implementation using PyTorch (should be used with nn.BCELoss criterion) for classification tasks.
-
-```python
-
-class LogisticRegression(nn.Module):
-    def __init__(self, input_size: int):
-        super().__init__()
-        # Define your layers
-        self.linear = nn.Linear(input_size, 1)
-        self.activation = nn.Sigmoid()
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        # Define the forward pass
-        out = self.linear(x)
-        out = self.activation(out)
-        return out
-
-class MyCoolPyTorchClassifier(BasePyTorchClassifier):
-    """
-    This is a custom IFreqaiModel showing how a user might setup their own 
-    custom Neural Network architecture for their training.
-    """
-
-    @property
-    def data_convertor(self) -> PyTorchDataConvertor:
-        return DefaultPyTorchDataConvertor(target_tensor_type=torch.float)
-
-    def __init__(self, **kwargs) -> None:
-        super().__init__(**kwargs)
-        config = self.freqai_info.get("model_training_parameters", {})
-        self.learning_rate: float = config.get("learning_rate",  3e-4)
-        self.model_kwargs: Dict[str, Any] = config.get("model_kwargs",  {})
-        self.trainer_kwargs: Dict[str, Any] = config.get("trainer_kwargs",  {})
-
-    def fit(self, data_dictionary: Dict, dk: FreqaiDataKitchen, **kwargs) -> Any:
-        """
-        User sets up the training and test data to fit their desired model here
-        :param data_dictionary: the dictionary holding all data for train, test,
-            labels, weights
-        :param dk: The datakitchen object for the current coin/model
-        """
-
-        class_names = self.get_class_names()
-        self.convert_label_column_to_int(data_dictionary, dk, class_names)
-        n_features = data_dictionary["train_features"].shape[-1]
-        model = LogisticRegression(
-            input_dim=n_features
-        )
-        model.to(self.device)
-        optimizer = torch.optim.AdamW(model.parameters(), lr=self.learning_rate)
-        criterion = torch.nn.CrossEntropyLoss()
-        init_model = self.get_init_model(dk.pair)
-        trainer = PyTorchModelTrainer(
-            model=model,
-            optimizer=optimizer,
-            criterion=criterion,
-            model_meta_data={"class_names": class_names},
-            device=self.device,
-            init_model=init_model,
-            data_convertor=self.data_convertor,
-            **self.trainer_kwargs,
-        )
-        trainer.fit(data_dictionary, self.splits)
-        return trainer
-
-```
-
-#### Trainer
-
-The `PyTorchModelTrainer` performs the idiomatic PyTorch train loop:
-Define our model, loss function, and optimizer, and then move them to the appropriate device (GPU or CPU). Inside the loop, we iterate through the batches in the dataloader, move the data to the device, compute the prediction and loss, backpropagate, and update the model parameters using the optimizer. 
-
-In addition, the trainer is responsible for the following:
- - saving and loading the model
- - converting the data from `pandas.DataFrame` to `torch.Tensor`. 
-
-#### Integration with Freqai module 
-
-Like all freqai models, PyTorch models inherit `IFreqaiModel`. `IFreqaiModel` declares three abstract methods: `train`, `fit`, and `predict`. we implement these methods in three levels of hierarchy.
-From top to bottom:
-
-1. `BasePyTorchModel` - Implements the `train` method. all `BasePyTorch*` inherit it. responsible for general data preparation (e.g., data normalization) and calling the `fit` method. Sets `device` attribute used by children classes. Sets `model_type` attribute used by the parent class.
-2. `BasePyTorch*` -  Implements the `predict` method. Here, the `*` represents a group of algorithms, such as classifiers or regressors. responsible for data preprocessing, predicting, and postprocessing if needed.
-3. `PyTorch*Classifier` / `PyTorch*Regressor` - implements the `fit` method. responsible for the main train flaw, where we initialize the trainer and model objects.
-
-![image](assets/freqai_pytorch-diagram.png)
-
-#### Full example
-
-Building a PyTorch regressor using MLP (multilayer perceptron) model, MSELoss criterion, and AdamW optimizer.
-
-```python
-class PyTorchMLPRegressor(BasePyTorchRegressor):
-    def __init__(self, **kwargs) -> None:
-        super().__init__(**kwargs)
-        config = self.freqai_info.get("model_training_parameters", {})
-        self.learning_rate: float = config.get("learning_rate",  3e-4)
-        self.model_kwargs: Dict[str, Any] = config.get("model_kwargs",  {})
-        self.trainer_kwargs: Dict[str, Any] = config.get("trainer_kwargs",  {})
-
-    def fit(self, data_dictionary: Dict, dk: FreqaiDataKitchen, **kwargs) -> Any:
-        n_features = data_dictionary["train_features"].shape[-1]
-        model = PyTorchMLPModel(
-            input_dim=n_features,
-            output_dim=1,
-            **self.model_kwargs
-        )
-        model.to(self.device)
-        optimizer = torch.optim.AdamW(model.parameters(), lr=self.learning_rate)
-        criterion = torch.nn.MSELoss()
-        init_model = self.get_init_model(dk.pair)
-        trainer = PyTorchModelTrainer(
-            model=model,
-            optimizer=optimizer,
-            criterion=criterion,
-            device=self.device,
-            init_model=init_model,
-            target_tensor_type=torch.float,
-            **self.trainer_kwargs,
-        )
-        trainer.fit(data_dictionary)
-        return trainer
-```
-
-Here we create a `PyTorchMLPRegressor` class that implements the `fit` method. The `fit` method specifies the training building blocks: model, optimizer, criterion, and trainer. We inherit both `BasePyTorchRegressor` and `BasePyTorchModel`, where the former implements the `predict` method that is suitable for our regression task, and the latter implements the train method.
-
-??? Note "Setting Class Names for Classifiers"
-    When using classifiers, the user must declare the class names (or targets) by overriding the `IFreqaiModel.class_names` attribute. This is achieved by setting `self.freqai.class_names` in the FreqAI strategy inside the `set_freqai_targets` method.
-    
-    For example, if you are using a binary classifier to predict price movements as up or down, you can set the class names as follows:
-    ```python
-    def set_freqai_targets(self, dataframe: DataFrame, metadata: Dict, **kwargs):
-        self.freqai.class_names = ["down", "up"]
-        dataframe['&s-up_or_down'] = np.where(dataframe["close"].shift(-100) >
-                                                  dataframe["close"], 'up', 'down')
-    
-        return dataframe
-    ```
-    To see a full example, you can refer to the [classifier test strategy class](https://github.com/freqtrade/freqtrade/blob/develop/tests/strategy/strats/freqai_test_classifier.py).
--- a/docs/freqai-developers.md
+++ b/docs/freqai-developers.md
@ -1,78 +0,0 @@
-# Development
-
-## Project architecture
-
-The architecture and functions of FreqAI are generalized to encourages development of unique features, functions, models, etc.
-
-The class structure and a detailed algorithmic overview is depicted in the following diagram:
-
-![image](assets/freqai_algorithm-diagram.jpg)
-
-As shown, there are three distinct objects comprising FreqAI:
-
-* **IFreqaiModel** - A singular persistent object containing all the necessary logic to collect, store, and process data, engineer features, run training, and inference models.
-* **FreqaiDataKitchen** - A non-persistent object which is created uniquely for each unique asset/model. Beyond metadata, it also contains a variety of data processing tools.
-* **FreqaiDataDrawer** - A singular persistent object containing all the historical predictions, models, and save/load methods.
-
-There are a variety of built-in [prediction models](freqai-configuration.md#using-different-prediction-models) which inherit directly from `IFreqaiModel`. Each of these models have full access to all methods in `IFreqaiModel` and can therefore override any of those functions at will. However, advanced users will likely stick to overriding `fit()`, `train()`, `predict()`, and `data_cleaning_train/predict()`.
-
-## Data handling
-
-FreqAI aims to organize model files, prediction data, and meta data in a way that simplifies post-processing and enhances crash resilience by automatic data reloading. The data is saved in a file structure,`user_data_dir/models/`, which contains all the data associated with the trainings and backtests. The `FreqaiDataKitchen()` relies heavily on the file structure for proper training and inferencing and should therefore not be manually modified.
-
-### File structure
-
-The file structure is automatically generated based on the model `identifier` set in the [config](freqai-configuration.md#setting-up-the-configuration-file). The following structure shows where the data is stored for post processing:
-
-| Structure | Description |
-|-----------|-------------|
-| `config_*.json` | A copy of the model specific configuration file. |
-| `historic_predictions.pkl` | A file containing all historic predictions generated during the lifetime of the `identifier` model during live deployment. `historic_predictions.pkl` is used to reload the model after a crash or a config change. A backup file is always held in case of corruption on the main file. FreqAI **automatically** detects corruption and replaces the corrupted file with the backup. |
-| `pair_dictionary.json` | A file containing the training queue as well as the on disk location of the most recently trained model. |
-| `sub-train-*_TIMESTAMP` | A folder containing all the files associated with a single model, such as: <br>
-|| `*_metadata.json` - Metadata for the model, such as normalization max/min, expected training feature list, etc. <br>
-|| `*_model.*` - The model file saved to disk for reloading from a crash. Can be `joblib` (typical boosting libs), `zip` (stable_baselines), `hd5` (keras type), etc. <br>
-|| `*_pca_object.pkl` - The [Principal component analysis (PCA)](freqai-feature-engineering.md#data-dimensionality-reduction-with-principal-component-analysis) transform (if `principal_component_analysis: True` is set in the config) which will be used to transform unseen prediction features. <br>
-|| `*_svm_model.pkl` - The [Support Vector Machine (SVM)](freqai-feature-engineering.md#identifying-outliers-using-a-support-vector-machine-svm) model (if `use_SVM_to_remove_outliers: True` is set in the config) which is used to detect outliers in unseen prediction features. <br>
-|| `*_trained_df.pkl` - The dataframe containing all the training features used to train the `identifier` model. This is used for computing the [Dissimilarity Index (DI)](freqai-feature-engineering.md#identifying-outliers-with-the-dissimilarity-index-di) and can also be used for post-processing. <br>
-|| `*_trained_dates.df.pkl` - The dates associated with the `trained_df.pkl`, which is useful for post-processing. |
-
-The example file structure would look like this:
-
-```
-├── models
-│   └── unique-id
-│       ├── config_freqai.example.json
-│       ├── historic_predictions.backup.pkl
-│       ├── historic_predictions.pkl
-│       ├── pair_dictionary.json
-│       ├── sub-train-1INCH_1662821319
-│       │   ├── cb_1inch_1662821319_metadata.json
-│       │   ├── cb_1inch_1662821319_model.joblib
-│       │   ├── cb_1inch_1662821319_pca_object.pkl
-│       │   ├── cb_1inch_1662821319_svm_model.joblib
-│       │   ├── cb_1inch_1662821319_trained_dates_df.pkl
-│       │   └── cb_1inch_1662821319_trained_df.pkl
-│       ├── sub-train-1INCH_1662821371
-│       │   ├── cb_1inch_1662821371_metadata.json
-│       │   ├── cb_1inch_1662821371_model.joblib
-│       │   ├── cb_1inch_1662821371_pca_object.pkl
-│       │   ├── cb_1inch_1662821371_svm_model.joblib
-│       │   ├── cb_1inch_1662821371_trained_dates_df.pkl
-│       │   └── cb_1inch_1662821371_trained_df.pkl
-│       ├── sub-train-ADA_1662821344
-│       │   ├── cb_ada_1662821344_metadata.json
-│       │   ├── cb_ada_1662821344_model.joblib
-│       │   ├── cb_ada_1662821344_pca_object.pkl
-│       │   ├── cb_ada_1662821344_svm_model.joblib
-│       │   ├── cb_ada_1662821344_trained_dates_df.pkl
-│       │   └── cb_ada_1662821344_trained_df.pkl
-│       └── sub-train-ADA_1662821399
-│           ├── cb_ada_1662821399_metadata.json
-│           ├── cb_ada_1662821399_model.joblib
-│           ├── cb_ada_1662821399_pca_object.pkl
-│           ├── cb_ada_1662821399_svm_model.joblib
-│           ├── cb_ada_1662821399_trained_dates_df.pkl
-│           └── cb_ada_1662821399_trained_df.pkl
-
-```
--- a/docs/freqai-feature-engineering.md
+++ b/docs/freqai-feature-engineering.md
@ -1,335 +0,0 @@
-# Feature engineering
-
-## Defining the features
-
-Low level feature engineering is performed in the user strategy within a set of functions called `feature_engineering_*`. These function set the `base features` such as, `RSI`, `MFI`, `EMA`, `SMA`, time of day, volume, etc. The `base features` can be custom indicators or they can be imported from any technical-analysis library that you can find. FreqAI is equipped with a set of functions to simplify rapid large-scale feature engineering:
-
-|  Function | Description |
-|---------------|-------------|
-| `feature_engineering_expand_all()` | This optional function will automatically expand the defined features on the config defined `indicator_periods_candles`, `include_timeframes`, `include_shifted_candles`, and `include_corr_pairs`.
-| `feature_engineering_expand_basic()` | This optional function will automatically expand the defined features on the config defined `include_timeframes`, `include_shifted_candles`, and `include_corr_pairs`. Note: this function does *not* expand across `include_periods_candles`.
-| `feature_engineering_standard()` | This optional function will be called once with the dataframe of the base timeframe. This is the final function to be called, which means that the dataframe entering this function will contain all the features and columns from the base asset created by the other `feature_engineering_expand` functions. This function is a good place to do custom exotic feature extractions (e.g. tsfresh). This function is also a good place for any feature that should not be auto-expanded upon (e.g., day of the week).
-| `set_freqai_targets()` | Required function to set the targets for the model. All targets must be prepended with `&` to be recognized by the FreqAI internals.
-
-Meanwhile, high level feature engineering is handled within `"feature_parameters":{}` in the FreqAI config. Within this file, it is possible to decide large scale feature expansions on top of the `base_features` such as "including correlated pairs" or "including informative timeframes" or even "including recent candles."
-
-It is advisable to start from the template `feature_engineering_*` functions in the source provided example strategy (found in `templates/FreqaiExampleStrategy.py`) to ensure that the feature definitions are following the correct conventions. Here is an example of how to set the indicators and labels in the strategy:
-
-```python
-    def feature_engineering_expand_all(self, dataframe, period, metadata, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        This function will automatically expand the defined features on the config defined
-        `indicator_periods_candles`, `include_timeframes`, `include_shifted_candles`, and
-        `include_corr_pairs`. In other words, a single feature defined in this function
-        will automatically expand to a total of
-        `indicator_periods_candles` * `include_timeframes` * `include_shifted_candles` *
-        `include_corr_pairs` numbers of features added to the model.
-
-        All features must be prepended with `%` to be recognized by FreqAI internals.
-
-        Access metadata such as the current pair/timeframe/period with:
-
-        `metadata["pair"]` `metadata["tf"]`  `metadata["period"]`
-
-        :param df: strategy dataframe which will receive the features
-        :param period: period of the indicator - usage example:
-        :param metadata: metadata of current pair
-        dataframe["%-ema-period"] = ta.EMA(dataframe, timeperiod=period)
-        """
-
-        dataframe["%-rsi-period"] = ta.RSI(dataframe, timeperiod=period)
-        dataframe["%-mfi-period"] = ta.MFI(dataframe, timeperiod=period)
-        dataframe["%-adx-period"] = ta.ADX(dataframe, timeperiod=period)
-        dataframe["%-sma-period"] = ta.SMA(dataframe, timeperiod=period)
-        dataframe["%-ema-period"] = ta.EMA(dataframe, timeperiod=period)
-
-        bollinger = qtpylib.bollinger_bands(
-            qtpylib.typical_price(dataframe), window=period, stds=2.2
-        )
-        dataframe["bb_lowerband-period"] = bollinger["lower"]
-        dataframe["bb_middleband-period"] = bollinger["mid"]
-        dataframe["bb_upperband-period"] = bollinger["upper"]
-
-        dataframe["%-bb_width-period"] = (
-            dataframe["bb_upperband-period"]
-            - dataframe["bb_lowerband-period"]
-        ) / dataframe["bb_middleband-period"]
-        dataframe["%-close-bb_lower-period"] = (
-            dataframe["close"] / dataframe["bb_lowerband-period"]
-        )
-
-        dataframe["%-roc-period"] = ta.ROC(dataframe, timeperiod=period)
-
-        dataframe["%-relative_volume-period"] = (
-            dataframe["volume"] / dataframe["volume"].rolling(period).mean()
-        )
-
-        return dataframe
-
-    def feature_engineering_expand_basic(self, dataframe, metadata, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        This function will automatically expand the defined features on the config defined
-        `include_timeframes`, `include_shifted_candles`, and `include_corr_pairs`.
-        In other words, a single feature defined in this function
-        will automatically expand to a total of
-        `include_timeframes` * `include_shifted_candles` * `include_corr_pairs`
-        numbers of features added to the model.
-
-        Features defined here will *not* be automatically duplicated on user defined
-        `indicator_periods_candles`
-
-        Access metadata such as the current pair/timeframe with:
-
-        `metadata["pair"]` `metadata["tf"]`
-
-        All features must be prepended with `%` to be recognized by FreqAI internals.
-
-        :param df: strategy dataframe which will receive the features
-        :param metadata: metadata of current pair
-        dataframe["%-pct-change"] = dataframe["close"].pct_change()
-        dataframe["%-ema-200"] = ta.EMA(dataframe, timeperiod=200)
-        """
-        dataframe["%-pct-change"] = dataframe["close"].pct_change()
-        dataframe["%-raw_volume"] = dataframe["volume"]
-        dataframe["%-raw_price"] = dataframe["close"]
-        return dataframe
-
-    def feature_engineering_standard(self, dataframe, metadata, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        This optional function will be called once with the dataframe of the base timeframe.
-        This is the final function to be called, which means that the dataframe entering this
-        function will contain all the features and columns created by all other
-        freqai_feature_engineering_* functions.
-
-        This function is a good place to do custom exotic feature extractions (e.g. tsfresh).
-        This function is a good place for any feature that should not be auto-expanded upon
-        (e.g. day of the week).
-
-        Access metadata such as the current pair with:
-
-        `metadata["pair"]`
-
-        All features must be prepended with `%` to be recognized by FreqAI internals.
-
-        :param df: strategy dataframe which will receive the features
-        :param metadata: metadata of current pair
-        usage example: dataframe["%-day_of_week"] = (dataframe["date"].dt.dayofweek + 1) / 7
-        """
-        dataframe["%-day_of_week"] = (dataframe["date"].dt.dayofweek + 1) / 7
-        dataframe["%-hour_of_day"] = (dataframe["date"].dt.hour + 1) / 25
-        return dataframe
-
-    def set_freqai_targets(self, dataframe, metadata, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        Required function to set the targets for the model.
-        All targets must be prepended with `&` to be recognized by the FreqAI internals.
-
-        Access metadata such as the current pair with:
-
-        `metadata["pair"]`
-
-        :param df: strategy dataframe which will receive the targets
-        :param metadata: metadata of current pair
-        usage example: dataframe["&-target"] = dataframe["close"].shift(-1) / dataframe["close"]
-        """
-        dataframe["&-s_close"] = (
-            dataframe["close"]
-            .shift(-self.freqai_info["feature_parameters"]["label_period_candles"])
-            .rolling(self.freqai_info["feature_parameters"]["label_period_candles"])
-            .mean()
-            / dataframe["close"]
-            - 1
-            )
-        
-        return dataframe
-```
-
-In the presented example, the user does not wish to pass the `bb_lowerband` as a feature to the model,
-and has therefore not prepended it with `%`. The user does, however, wish to pass `bb_width` to the
-model for training/prediction and has therefore prepended it with `%`.
-
-After having defined the `base features`, the next step is to expand upon them using the powerful `feature_parameters` in the configuration file:
-
-```json
-    "freqai": {
-        //...
-        "feature_parameters" : {
-            "include_timeframes": ["5m","15m","4h"],
-            "include_corr_pairlist": [
-                "ETH/USD",
-                "LINK/USD",
-                "BNB/USD"
-            ],
-            "label_period_candles": 24,
-            "include_shifted_candles": 2,
-            "indicator_periods_candles": [10, 20]
-        },
-        //...
-    }
-```
-
-The `include_timeframes` in the config above are the timeframes (`tf`) of each call to `feature_engineering_expand_*()` in the strategy. In the presented case, the user is asking for the `5m`, `15m`, and `4h` timeframes of the `rsi`, `mfi`, `roc`, and `bb_width` to be included in the feature set.
-
-You can ask for each of the defined features to be included also for informative pairs using the `include_corr_pairlist`. This means that the feature set will include all the features from `feature_engineering_expand_*()` on all the `include_timeframes` for each of the correlated pairs defined in the config (`ETH/USD`, `LINK/USD`, and `BNB/USD` in the presented example).
-
-`include_shifted_candles` indicates the number of previous candles to include in the feature set. For example, `include_shifted_candles: 2` tells FreqAI to include the past 2 candles for each of the features in the feature set.
-
-In total, the number of features the user of the presented example strat has created is: length of `include_timeframes` * no. features in `feature_engineering_expand_*()` * length of `include_corr_pairlist` * no. `include_shifted_candles` * length of `indicator_periods_candles`
- $= 3 * 3 * 3 * 2 * 2 = 108$.
-
-
-### Gain finer control over `feature_engineering_*` functions with `metadata`
-
- All `feature_engineering_*` and `set_freqai_targets()` functions are passed a `metadata` dictionary which contains information about the `pair`, `tf` (timeframe), and `period` that FreqAI is automating for feature building. As such, a user can use `metadata` inside `feature_engineering_*` functions as criteria for blocking/reserving features for certain timeframes, periods, pairs etc.
-
- ```python
-def feature_engineering_expand_all(self, dataframe, period, metadata, **kwargs):
- if metadata["tf"] == "1h":
-    dataframe["%-roc-period"] = ta.ROC(dataframe, timeperiod=period)
-```
-
-This will block `ta.ROC()` from being added to any timeframes other than `"1h"`.
-
-### Returning additional info from training
-
-Important metrics can be returned to the strategy at the end of each model training by assigning them to `dk.data['extra_returns_per_train']['my_new_value'] = XYZ` inside the custom prediction model class. 
-
-FreqAI takes the `my_new_value` assigned in this dictionary and expands it to fit the dataframe that is returned to the strategy. You can then use the returned metrics in your strategy through `dataframe['my_new_value']`. An example of how return values can be used in FreqAI are the `&*_mean` and `&*_std` values that are used to [created a dynamic target threshold](freqai-configuration.md#creating-a-dynamic-target-threshold).
-
-Another example, where the user wants to use live metrics from the trade database, is shown below:
-
-```json
-    "freqai": {
-        "extra_returns_per_train": {"total_profit": 4}
-    }
-```
-
-You need to set the standard dictionary in the config so that FreqAI can return proper dataframe shapes. These values will likely be overridden by the prediction model, but in the case where the model has yet to set them, or needs a default initial value, the pre-set values are what will be returned.
-
-## Feature normalization
-
-FreqAI is strict when it comes to data normalization. The train features, $X^{train}$, are always normalized to [-1, 1] using a shifted min-max normalization:
-
-$$X^{train}_{norm} = 2 * \frac{X^{train} - X^{train}.min()}{X^{train}.max() - X^{train}.min()} - 1$$
-
-All other data (test data and unseen prediction data in dry/live/backtest) is always automatically normalized to the training feature space according to industry standards. FreqAI stores all the metadata required to ensure that test and prediction features will be properly normalized and that predictions are properly denormalized. For this reason, it is not recommended to eschew industry standards and modify FreqAI internals - however - advanced users can do so by inheriting `train()` in their custom `IFreqaiModel` and using their own normalization functions.
-
-## Data dimensionality reduction with Principal Component Analysis
-
-You can reduce the dimensionality of your features by activating the `principal_component_analysis` in the config:
-
-```json
-    "freqai": {
-        "feature_parameters" : {
-            "principal_component_analysis": true
-        }
-    }
-```
-
-This will perform PCA on the features and reduce their dimensionality so that the explained variance of the data set is >= 0.999. Reducing data dimensionality makes training the model faster and hence allows for more up-to-date models. 
-
-## Inlier metric
-
-The `inlier_metric` is a metric aimed at quantifying how similar the features of a data point are to the most recent historical data points. 
-
-You define the lookback window by setting `inlier_metric_window` and FreqAI computes the distance between the present time point and each of the previous `inlier_metric_window` lookback points. A Weibull function is fit to each of the lookback distributions and its cumulative distribution function (CDF) is used to produce a quantile for each lookback point. The `inlier_metric` is then computed for each time point as the average of the corresponding lookback quantiles. The figure below explains the concept for an `inlier_metric_window` of 5.
-
-![inlier-metric](assets/freqai_inlier-metric.jpg)
-
-FreqAI adds the `inlier_metric` to the training features and hence gives the model access to a novel type of temporal information. 
-
-This function does **not** remove outliers from the data set.
-
-## Weighting features for temporal importance
-
-FreqAI allows you to set a `weight_factor` to weight recent data more strongly than past data via an exponential function:
-
-$$ W_i = \exp(\frac{-i}{\alpha*n}) $$
-
-where $W_i$ is the weight of data point $i$ in a total set of $n$ data points. Below is a figure showing the effect of different weight factors on the data points in a feature set.
-
-![weight-factor](assets/freqai_weight-factor.jpg)
-
-## Outlier detection
-
-Equity and crypto markets suffer from a high level of non-patterned noise in the form of outlier data points. FreqAI implements a variety of methods to identify such outliers and hence mitigate risk.
-
-### Identifying outliers with the Dissimilarity Index (DI)
-
- The Dissimilarity Index (DI) aims to quantify the uncertainty associated with each prediction made by the model. 
-
-You can tell FreqAI to remove outlier data points from the training/test data sets using the DI by including the following statement in the config:
-
-```json
-    "freqai": {
-        "feature_parameters" : {
-            "DI_threshold": 1
-        }
-    }
-```
-
- The DI allows predictions which are outliers (not existent in the model feature space) to be thrown out due to low levels of certainty. To do so, FreqAI measures the distance between each training data point (feature vector), $X_{a}$, and all other training data points:
-
-$$ d_{ab} = \sqrt{\sum_{j=1}^p(X_{a,j}-X_{b,j})^2} $$
-
-where $d_{ab}$ is the distance between the normalized points $a$ and $b$, and $p$ is the number of features, i.e., the length of the vector $X$. The characteristic distance, $\overline{d}$, for a set of training data points is simply the mean of the average distances:
-
-$$ \overline{d} = \sum_{a=1}^n(\sum_{b=1}^n(d_{ab}/n)/n) $$
-
-$\overline{d}$ quantifies the spread of the training data, which is compared to the distance between a new prediction feature vectors, $X_k$ and all the training data:
-
-$$ d_k = \arg \min d_{k,i} $$
-
-This enables the estimation of the Dissimilarity Index as:
-
-$$ DI_k = d_k/\overline{d} $$
-
-You can tweak the DI through the `DI_threshold` to increase or decrease the extrapolation of the trained model. A higher `DI_threshold` means that the DI is more lenient and allows predictions further away from the training data to be used whilst a lower `DI_threshold` has the opposite effect and hence discards more predictions.
-
-Below is a figure that describes the DI for a 3D data set.
-
-![DI](assets/freqai_DI.jpg)
-
-### Identifying outliers using a Support Vector Machine (SVM)
-
-You can tell FreqAI to remove outlier data points from the training/test data sets using a Support Vector Machine (SVM) by including the following statement in the config:
-
-```json
-    "freqai": {
-        "feature_parameters" : {
-            "use_SVM_to_remove_outliers": true
-        }
-    }
-```
-
-The SVM will be trained on the training data and any data point that the SVM deems to be beyond the feature space will be removed.
-
-FreqAI uses `sklearn.linear_model.SGDOneClassSVM` (details are available on scikit-learn's webpage [here](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.SGDOneClassSVM.html) (external website)) and you can elect to provide additional parameters for the SVM, such as `shuffle`, and `nu`.
-
-The parameter `shuffle` is by default set to `False` to ensure consistent results. If it is set to `True`, running the SVM multiple times on the same data set might result in different outcomes due to `max_iter` being to low for the algorithm to reach the demanded `tol`. Increasing `max_iter` solves this issue but causes the procedure to take longer time.
-
-The parameter `nu`, *very* broadly, is the amount of data points that should be considered outliers and should be between 0 and 1.
-
-### Identifying outliers with DBSCAN
-
-You can configure FreqAI to use DBSCAN to cluster and remove outliers from the training/test data set or incoming outliers from predictions, by activating `use_DBSCAN_to_remove_outliers` in the config:
-
-```json
-    "freqai": {
-        "feature_parameters" : {
-            "use_DBSCAN_to_remove_outliers": true
-        }
-    }
-```
-
-DBSCAN is an unsupervised machine learning algorithm that clusters data without needing to know how many clusters there should be.
-
-Given a number of data points $N$, and a distance $\varepsilon$, DBSCAN clusters the data set by setting all data points that have $N-1$ other data points within a distance of $\varepsilon$ as *core points*. A data point that is within a distance of $\varepsilon$ from a *core point* but that does not have $N-1$ other data points within a distance of $\varepsilon$ from itself is considered an *edge point*. A cluster is then the collection of *core points* and *edge points*. Data points that have no other data points at a distance $<\varepsilon$ are considered outliers. The figure below shows a cluster with $N = 3$.
-
-![dbscan](assets/freqai_dbscan.jpg)
-
-FreqAI uses `sklearn.cluster.DBSCAN` (details are available on scikit-learn's webpage [here](https://scikit-learn.org/stable/modules/generated/sklearn.cluster.DBSCAN.html) (external website)) with `min_samples` ($N$) taken as 1/4 of the no. of time points (candles) in the feature set. `eps` ($\varepsilon$) is computed automatically as the elbow point in the *k-distance graph* computed from the nearest neighbors in the pairwise distances of all data points in the feature set.
--- a/docs/freqai-parameter-table.md
+++ b/docs/freqai-parameter-table.md
@ -1,117 +0,0 @@
-# Parameter table
-
-The table below will list all configuration parameters available for FreqAI. Some of the parameters are exemplified in `config_examples/config_freqai.example.json`.
-
-Mandatory parameters are marked as **Required** and have to be set in one of the suggested ways.
-
-### General configuration parameters
-
-|  Parameter | Description |
-|------------|-------------|
-|  |  **General configuration parameters within the `config.freqai` tree**
-| `freqai` | **Required.** <br> The parent dictionary containing all the parameters for controlling FreqAI. <br> **Datatype:** Dictionary.
-| `train_period_days` | **Required.** <br> Number of days to use for the training data (width of the sliding window). <br> **Datatype:** Positive integer.
-| `backtest_period_days` | **Required.** <br> Number of days to inference from the trained model before sliding the `train_period_days` window defined above, and retraining the model during backtesting (more info [here](freqai-running.md#backtesting)). This can be fractional days, but beware that the provided `timerange` will be divided by this number to yield the number of trainings necessary to complete the backtest. <br> **Datatype:** Float.
-| `identifier` | **Required.** <br> A unique ID for the current model. If models are saved to disk, the `identifier` allows for reloading specific pre-trained models/data. <br> **Datatype:** String.
-| `live_retrain_hours` | Frequency of retraining during dry/live runs. <br> **Datatype:** Float > 0. <br> Default: `0` (models retrain as often as possible).
-| `expiration_hours` | Avoid making predictions if a model is more than `expiration_hours` old. <br> **Datatype:** Positive integer. <br> Default: `0` (models never expire).
-| `purge_old_models` | Number of models to keep on disk (not relevant to backtesting). Default is 2, which means that dry/live runs will keep the latest 2 models on disk. Setting to 0 keeps all models. This parameter also accepts a boolean to maintain backwards compatibility. <br> **Datatype:** Integer. <br> Default: `2`.
-| `save_backtest_models` | Save models to disk when running backtesting. Backtesting operates most efficiently by saving the prediction data and reusing them directly for subsequent runs (when you wish to tune entry/exit parameters). Saving backtesting models to disk also allows to use the same model files for starting a dry/live instance with the same model `identifier`. <br> **Datatype:** Boolean. <br> Default: `False` (no models are saved).
-| `fit_live_predictions_candles` | Number of historical candles to use for computing target (label) statistics from prediction data, instead of from the training dataset (more information can be found [here](freqai-configuration.md#creating-a-dynamic-target-threshold)). <br> **Datatype:** Positive integer.
-| `continual_learning` | Use the final state of the most recently trained model as starting point for the new model, allowing for incremental learning (more information can be found [here](freqai-running.md#continual-learning)). <br> **Datatype:** Boolean. <br> Default: `False`.
-| `write_metrics_to_disk` | Collect train timings, inference timings and cpu usage in json file. <br> **Datatype:** Boolean. <br> Default: `False`
-| `data_kitchen_thread_count` | <br> Designate the number of threads you want to use for data processing (outlier methods, normalization, etc.). This has no impact on the number of threads used for training. If user does not set it (default), FreqAI will use max number of threads - 2 (leaving 1 physical core available for Freqtrade bot and FreqUI) <br> **Datatype:** Positive integer.
-
-### Feature parameters
-
-|  Parameter | Description |
-|------------|-------------|
-|  |  **Feature parameters within the `freqai.feature_parameters` sub dictionary**
-| `feature_parameters` | A dictionary containing the parameters used to engineer the feature set. Details and examples are shown [here](freqai-feature-engineering.md). <br> **Datatype:** Dictionary.
-| `include_timeframes` | A list of timeframes that all indicators in `feature_engineering_expand_*()` will be created for. The list is added as features to the base indicators dataset. <br> **Datatype:** List of timeframes (strings).
-| `include_corr_pairlist` | A list of correlated coins that FreqAI will add as additional features to all `pair_whitelist` coins. All indicators set in `feature_engineering_expand_*()` during feature engineering (see details [here](freqai-feature-engineering.md)) will be created for each correlated coin. The correlated coins features are added to the base indicators dataset. <br> **Datatype:** List of assets (strings).
-| `label_period_candles` | Number of candles into the future that the labels are created for. This is used in `feature_engineering_expand_all()` (see `templates/FreqaiExampleStrategy.py` for detailed usage). You can create custom labels and choose whether to make use of this parameter or not. <br> **Datatype:** Positive integer.
-| `include_shifted_candles` | Add features from previous candles to subsequent candles with the intent of adding historical information. If used, FreqAI will duplicate and shift all features from the `include_shifted_candles` previous candles so that the information is available for the subsequent candle. <br> **Datatype:** Positive integer.
-| `weight_factor` | Weight training data points according to their recency (see details [here](freqai-feature-engineering.md#weighting-features-for-temporal-importance)). <br> **Datatype:** Positive float (typically < 1).
-| `indicator_max_period_candles` | **No longer used (#7325)**. Replaced by `startup_candle_count` which is set in the [strategy](freqai-configuration.md#building-a-freqai-strategy). `startup_candle_count` is timeframe independent and defines the maximum *period* used in `feature_engineering_*()` for indicator creation. FreqAI uses this parameter together with the maximum timeframe in `include_time_frames` to calculate how many data points to download such that the first data point does not include a NaN. <br> **Datatype:** Positive integer.
-| `indicator_periods_candles` | Time periods to calculate indicators for. The indicators are added to the base indicator dataset. <br> **Datatype:** List of positive integers.
-| `principal_component_analysis` | Automatically reduce the dimensionality of the data set using Principal Component Analysis. See details about how it works [here](#reducing-data-dimensionality-with-principal-component-analysis) <br> **Datatype:** Boolean. <br> Default: `False`.
-| `plot_feature_importances` | Create a feature importance plot for each model for the top/bottom `plot_feature_importances` number of features. Plot is stored in `user_data/models/<identifier>/sub-train-<COIN>_<timestamp>.html`. <br> **Datatype:** Integer. <br> Default: `0`.
-| `DI_threshold` | Activates the use of the Dissimilarity Index for outlier detection when set to > 0. See details about how it works [here](freqai-feature-engineering.md#identifying-outliers-with-the-dissimilarity-index-di). <br> **Datatype:** Positive float (typically < 1).
-| `use_SVM_to_remove_outliers` | Train a support vector machine to detect and remove outliers from the training dataset, as well as from incoming data points. See details about how it works [here](freqai-feature-engineering.md#identifying-outliers-using-a-support-vector-machine-svm). <br> **Datatype:** Boolean.
-| `svm_params` | All parameters available in Sklearn's `SGDOneClassSVM()`. See details about some select parameters [here](freqai-feature-engineering.md#identifying-outliers-using-a-support-vector-machine-svm). <br> **Datatype:** Dictionary.
-| `use_DBSCAN_to_remove_outliers` | Cluster data using the DBSCAN algorithm to identify and remove outliers from training and prediction data. See details about how it works [here](freqai-feature-engineering.md#identifying-outliers-with-dbscan). <br> **Datatype:** Boolean. 
-| `inlier_metric_window` | If set, FreqAI adds an `inlier_metric` to the training feature set and set the lookback to be the `inlier_metric_window`, i.e., the number of previous time points to compare the current candle to. Details of how the `inlier_metric` is computed can be found [here](freqai-feature-engineering.md#inlier-metric). <br> **Datatype:** Integer. <br> Default: `0`.
-| `noise_standard_deviation` | If set, FreqAI adds noise to the training features with the aim of preventing overfitting. FreqAI generates random deviates from a gaussian distribution with a standard deviation of `noise_standard_deviation` and adds them to all data points. `noise_standard_deviation` should be kept relative to the normalized space, i.e., between -1 and 1. In other words, since data in FreqAI is always normalized to be between -1 and 1, `noise_standard_deviation: 0.05` would result in 32% of the data being randomly increased/decreased by more than 2.5% (i.e., the percent of data falling within the first standard deviation). <br> **Datatype:** Integer. <br> Default: `0`.
-| `outlier_protection_percentage` | Enable to prevent outlier detection methods from discarding too much data. If more than `outlier_protection_percentage` % of points are detected as outliers by the SVM or DBSCAN, FreqAI will log a warning message and ignore outlier detection, i.e., the original dataset will be kept intact. If the outlier protection is triggered, no predictions will be made based on the training dataset. <br> **Datatype:** Float. <br> Default: `30`.
-| `reverse_train_test_order` | Split the feature dataset (see below) and use the latest data split for training and test on historical split of the data. This allows the model to be trained up to the most recent data point, while avoiding overfitting. However, you should be careful to understand the unorthodox nature of this parameter before employing it. <br> **Datatype:** Boolean. <br> Default: `False` (no reversal).
-| `shuffle_after_split` | Split the data into train and test sets, and then shuffle both sets individually. <br> **Datatype:** Boolean. <br> Default: `False`.
-| `buffer_train_data_candles` | Cut `buffer_train_data_candles` off the beginning and end of the training data *after* the indicators were populated. The main example use is when predicting maxima and minima, the argrelextrema function  cannot know the maxima/minima at the edges of the timerange. To improve model accuracy, it is best to compute argrelextrema on the full timerange and then use this function to cut off the edges (buffer) by the kernel. In another case, if the targets are set to a shifted price movement, this buffer is unnecessary because the shifted candles at the end of the timerange will be NaN and FreqAI will automatically cut those off of the training dataset.<br> **Datatype:** Integer. <br> Default: `0`.
-
-### Data split parameters
-
-|  Parameter | Description |
-|------------|-------------|
-|  |  **Data split parameters within the `freqai.data_split_parameters` sub dictionary**
-| `data_split_parameters` | Include any additional parameters available from scikit-learn `test_train_split()`, which are shown [here](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html) (external website). <br> **Datatype:** Dictionary.
-| `test_size` | The fraction of data that should be used for testing instead of training. <br> **Datatype:** Positive float < 1.
-| `shuffle` | Shuffle the training data points during training. Typically, to not remove the chronological order of data in time-series forecasting, this is set to `False`. <br> **Datatype:** Boolean. <br> Defaut: `False`.
-
-### Model training parameters
-
-|  Parameter | Description |
-|------------|-------------|
-|  |  **Model training parameters within the `freqai.model_training_parameters` sub dictionary**
-| `model_training_parameters` | A flexible dictionary that includes all parameters available by the selected model library. For example, if you use `LightGBMRegressor`, this dictionary can contain any parameter available by the `LightGBMRegressor` [here](https://lightgbm.readthedocs.io/en/latest/pythonapi/lightgbm.LGBMRegressor.html) (external website). If you select a different model, this dictionary can contain any parameter from that model. A list of the currently available models can be found [here](freqai-configuration.md#using-different-prediction-models).  <br> **Datatype:** Dictionary.
-| `n_estimators` | The number of boosted trees to fit in the training of the model. <br> **Datatype:** Integer.
-| `learning_rate` | Boosting learning rate during training of the model. <br> **Datatype:** Float.
-| `n_jobs`, `thread_count`, `task_type` | Set the number of threads for parallel processing and the `task_type` (`gpu` or `cpu`). Different model libraries use different parameter names. <br> **Datatype:** Float.
-
-### Reinforcement Learning parameters
-
-|  Parameter | Description |
-|------------|-------------|
-|  |  **Reinforcement Learning Parameters within the `freqai.rl_config` sub dictionary**
-| `rl_config` | A dictionary containing the control parameters for a Reinforcement Learning model. <br> **Datatype:** Dictionary.
-| `train_cycles` | Training time steps will be set based on the `train_cycles * number of training data points. <br> **Datatype:** Integer.
-| `cpu_count` | Number of processors to dedicate to the Reinforcement Learning training process. <br> **Datatype:** int.
-| `max_trade_duration_candles`| Guides the agent training to keep trades below desired length. Example usage shown in `prediction_models/ReinforcementLearner.py` within the customizable `calculate_reward()` function. <br> **Datatype:** int.
-| `model_type` | Model string from stable_baselines3 or SBcontrib. Available strings include: `'TRPO', 'ARS', 'RecurrentPPO', 'MaskablePPO', 'PPO', 'A2C', 'DQN'`. User should ensure that `model_training_parameters` match those available to the corresponding stable_baselines3 model by visiting their documentaiton. [PPO doc](https://stable-baselines3.readthedocs.io/en/master/modules/ppo.html) (external website) <br> **Datatype:** string.
-| `policy_type` | One of the available policy types from stable_baselines3 <br> **Datatype:** string.
-| `max_training_drawdown_pct` | The maximum drawdown that the agent is allowed to experience during training. <br> **Datatype:** float. <br> Default: 0.8
-| `cpu_count` | Number of threads/cpus to dedicate to the Reinforcement Learning training process (depending on if `ReinforcementLearning_multiproc` is selected or not). Recommended to leave this untouched, by default, this value is set to the total number of physical cores minus 1. <br> **Datatype:** int. 
-| `model_reward_parameters` | Parameters used inside the customizable `calculate_reward()` function in `ReinforcementLearner.py` <br> **Datatype:** int.
-| `add_state_info` | Tell FreqAI to include state information in the feature set for training and inferencing. The current state variables include trade duration, current profit, trade position. This is only available in dry/live runs, and is automatically switched to false for backtesting. <br> **Datatype:** bool. <br> Default: `False`.
-| `net_arch` | Network architecture which is well described in [`stable_baselines3` doc](https://stable-baselines3.readthedocs.io/en/master/guide/custom_policy.html#examples). In summary: `[<shared layers>, dict(vf=[<non-shared value network layers>], pi=[<non-shared policy network layers>])]`. By default this is set to `[128, 128]`, which defines 2 shared hidden layers with 128 units each.
-| `randomize_starting_position` | Randomize the starting point of each episode to avoid overfitting. <br> **Datatype:** bool. <br> Default: `False`.
-| `drop_ohlc_from_features` | Do not include the normalized ohlc data in the feature set passed to the agent during training (ohlc will still be used for driving the environment in all cases) <br> **Datatype:** Boolean. <br> **Default:** `False`
-
-### PyTorch parameters
-
-#### general
-
-|  Parameter | Description |
-|------------|-------------|
-|  |  **Model training parameters within the `freqai.model_training_parameters` sub dictionary**
-| `learning_rate` | Learning rate to be passed to the optimizer. <br> **Datatype:** float. <br> Default: `3e-4`.
-| `model_kwargs` | Parameters to be passed to the model class. <br> **Datatype:** dict. <br> Default: `{}`.
-| `trainer_kwargs` | Parameters to be passed to the trainer class. <br> **Datatype:** dict. <br> Default: `{}`.
-
-#### trainer_kwargs
-
-|  Parameter | Description |
-|------------|-------------|
-|  |  **Model training parameters within the `freqai.model_training_parameters.model_kwargs` sub dictionary**
-| `max_iters` | The number of training iterations to run. iteration here refers to the number of times we call self.optimizer.step(). used to calculate n_epochs. <br> **Datatype:** int. <br> Default: `100`.
-| `batch_size` | The size of the batches to use during training.. <br> **Datatype:** int. <br> Default: `64`.
-| `max_n_eval_batches` | The maximum number batches to use for evaluation.. <br> **Datatype:** int, optional. <br> Default: `None`.
-
-
-### Additional parameters
-
-|  Parameter | Description |
-|------------|-------------|
-|  |  **Extraneous parameters**
-| `freqai.keras` | If the selected model makes use of Keras (typical for TensorFlow-based prediction models), this flag needs to be activated so that the model save/loading follows Keras standards. <br> **Datatype:** Boolean. <br> Default: `False`.
-| `freqai.conv_width` | The width of a convolutional neural network input tensor. This replaces the need for shifting candles (`include_shifted_candles`) by feeding in historical data points as the second dimension of the tensor. Technically, this parameter can also be used for regressors, but it only adds computational overhead and does not change the model training/prediction. <br> **Datatype:** Integer. <br> Default: `2`.
-| `freqai.reduce_df_footprint` | Recast all numeric columns to float32/int32, with the objective of reducing ram/disk usage and decreasing train/inference timing. This parameter is set in the main level of the Freqtrade configuration file (not inside FreqAI). <br> **Datatype:** Boolean. <br> Default: `False`.
--- a/docs/freqai-reinforcement-learning.md
+++ b/docs/freqai-reinforcement-learning.md
@ -1,269 +0,0 @@
-# Reinforcement Learning
-
-!!! Note "Installation size"
-    Reinforcement learning dependencies include large packages such as `torch`, which should be explicitly requested during `./setup.sh -i` by answering "y" to the question "Do you also want dependencies for freqai-rl (~700mb additional space required) [y/N]?".
-    Users who prefer docker should ensure they use the docker image appended with `_freqairl`.
-
-## Background and terminology
-
-### What is RL and why does FreqAI need it?
-
-Reinforcement learning involves two important components, the *agent* and the training *environment*. During agent training, the agent moves through historical data candle by candle, always making 1 of a set of actions: Long entry, long exit, short entry, short exit, neutral). During this training process, the environment tracks the performance of these actions and rewards the agent according to a custom user made `calculate_reward()` (here we offer a default reward for users to build on if they wish [details here](#creating-a-custom-reward-function)). The reward is used to train weights in a neural network.
-
-A second important component of the FreqAI RL implementation is the use of *state* information. State information is fed into the network at each step, including current profit, current position, and current trade duration. These are used to train the agent in the training environment, and to reinforce the agent in dry/live (this functionality is not available in backtesting). *FreqAI + Freqtrade is a perfect match for this reinforcing mechanism since this information is readily available in live deployments.*
-
-Reinforcement learning is a natural progression for FreqAI, since it adds a new layer of adaptivity and market reactivity that Classifiers and Regressors cannot match. However, Classifiers and Regressors have strengths that RL does not have such as robust predictions. Improperly trained RL agents may find "cheats" and "tricks" to maximize reward without actually winning any trades. For this reason, RL is more complex and demands a higher level of understanding than typical Classifiers and Regressors.
-
-### The RL interface
-
-With the current framework, we aim to expose the training environment via the common "prediction model" file, which is a user inherited `BaseReinforcementLearner` object (e.g. `freqai/prediction_models/ReinforcementLearner`). Inside this user class, the RL environment is available and customized via `MyRLEnv` as [shown below](#creating-a-custom-reward-function).
-
-We envision the majority of users focusing their effort on creative design of the `calculate_reward()` function [details here](#creating-a-custom-reward-function), while leaving the rest of the environment untouched. Other users may not touch the environment at all, and they will only play with the configuration settings and the powerful feature engineering that already exists in FreqAI. Meanwhile, we enable advanced users to create their own model classes entirely.
-
-The framework is built on stable_baselines3 (torch) and OpenAI gym for the base environment class. But generally speaking, the model class is well isolated. Thus, the addition of competing libraries can be easily integrated into the existing framework. For the environment, it is inheriting from `gym.env` which means that it is necessary to write an entirely new environment in order to switch to a different library.
-
-### Important considerations
-
-As explained above, the agent is "trained" in an artificial trading "environment". In our case, that environment may seem quite similar to a real Freqtrade backtesting environment, but it is *NOT*. In fact, the RL training environment is much more simplified. It does not incorporate any of the complicated strategy logic, such as callbacks like `custom_exit`, `custom_stoploss`, leverage controls, etc. The RL environment is instead a very "raw" representation of the true market, where the agent has free will to learn the policy (read: stoploss, take profit, etc.) which is enforced by the `calculate_reward()`. Thus, it is important to consider that the agent training environment is not identical to the real world.
-
-## Running Reinforcement Learning
-
-Setting up and running a Reinforcement Learning model is the same as running a Regressor or Classifier. The same two flags, `--freqaimodel` and `--strategy`, must be defined on the command line:
-
-```bash
-freqtrade trade --freqaimodel ReinforcementLearner --strategy MyRLStrategy --config config.json
-```
-
-where `ReinforcementLearner` will use the templated `ReinforcementLearner` from `freqai/prediction_models/ReinforcementLearner` (or a custom user defined one located in `user_data/freqaimodels`). The strategy, on the other hand, follows the same base [feature engineering](freqai-feature-engineering.md) with `feature_engineering_*` as a typical Regressor. The difference lies in the creation of the targets, Reinforcement Learning doesn't require them. However, FreqAI requires a default (neutral) value to be set in the action column:
-
-```python
-    def set_freqai_targets(self, dataframe, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        Required function to set the targets for the model.
-        All targets must be prepended with `&` to be recognized by the FreqAI internals.
-
-        More details about feature engineering available:
-
-        https://www.freqtrade.io/en/latest/freqai-feature-engineering
-
-        :param df: strategy dataframe which will receive the targets
-        usage example: dataframe["&-target"] = dataframe["close"].shift(-1) / dataframe["close"]
-        """
-        # For RL, there are no direct targets to set. This is filler (neutral)
-        # until the agent sends an action.
-        dataframe["&-action"] = 0
-```
-
-Most of the function remains the same as for typical Regressors, however, the function below shows how the strategy must pass the raw price data to the agent so that it has access to raw OHLCV in the training environment:
-
-```python
-    def feature_engineering_standard(self, dataframe, **kwargs):
-        # The following features are necessary for RL models
-        dataframe[f"%-raw_close"] = dataframe["close"]
-        dataframe[f"%-raw_open"] = dataframe["open"]
-        dataframe[f"%-raw_high"] = dataframe["high"]
-        dataframe[f"%-raw_low"] = dataframe["low"]
-```
-
-Finally, there is no explicit "label" to make - instead it is necessary to assign the `&-action` column which will contain the agent's actions when accessed in `populate_entry/exit_trends()`. In the present example, the neutral action to 0. This value should align with the environment used. FreqAI provides two environments, both use 0 as the neutral action.
-
-After users realize there are no labels to set, they will soon understand that the agent is making its "own" entry and exit decisions. This makes strategy construction rather simple. The entry and exit signals come from the agent in the form of an integer - which are used directly to decide entries and exits in the strategy:
-
-```python
-    def populate_entry_trend(self, df: DataFrame, metadata: dict) -> DataFrame:
-
-        enter_long_conditions = [df["do_predict"] == 1, df["&-action"] == 1]
-
-        if enter_long_conditions:
-            df.loc[
-                reduce(lambda x, y: x & y, enter_long_conditions), ["enter_long", "enter_tag"]
-            ] = (1, "long")
-
-        enter_short_conditions = [df["do_predict"] == 1, df["&-action"] == 3]
-
-        if enter_short_conditions:
-            df.loc[
-                reduce(lambda x, y: x & y, enter_short_conditions), ["enter_short", "enter_tag"]
-            ] = (1, "short")
-
-        return df
-
-    def populate_exit_trend(self, df: DataFrame, metadata: dict) -> DataFrame:
-        exit_long_conditions = [df["do_predict"] == 1, df["&-action"] == 2]
-        if exit_long_conditions:
-            df.loc[reduce(lambda x, y: x & y, exit_long_conditions), "exit_long"] = 1
-
-        exit_short_conditions = [df["do_predict"] == 1, df["&-action"] == 4]
-        if exit_short_conditions:
-            df.loc[reduce(lambda x, y: x & y, exit_short_conditions), "exit_short"] = 1
-
-        return df
-```
-
-It is important to consider that `&-action` depends on which environment they choose to use. The example above shows 5 actions, where 0 is neutral, 1 is enter long, 2 is exit long, 3 is enter short and 4 is exit short.
-
-## Configuring the Reinforcement Learner
-
-In order to configure the `Reinforcement Learner` the following dictionary must exist in the `freqai` config:
-
-```json
-        "rl_config": {
-            "train_cycles": 25,
-            "add_state_info": true,
-            "max_trade_duration_candles": 300,
-            "max_training_drawdown_pct": 0.02,
-            "cpu_count": 8,
-            "model_type": "PPO",
-            "policy_type": "MlpPolicy",
-            "model_reward_parameters": {
-                "rr": 1,
-                "profit_aim": 0.025
-            }
-        }
-```
-
-Parameter details can be found [here](freqai-parameter-table.md), but in general the `train_cycles` decides how many times the agent should cycle through the candle data in its artificial environment to train weights in the model. `model_type` is a string which selects one of the available models in [stable_baselines](https://stable-baselines3.readthedocs.io/en/master/)(external link).
-
-!!! Note
-    If you would like to experiment with `continual_learning`, then you should set that value to `true` in the main `freqai` configuration dictionary. This will tell the Reinforcement Learning library to continue training new models from the final state of previous models, instead of retraining new models from scratch each time a retrain is initiated.
-
-!!! Note
-    Remember that the general `model_training_parameters` dictionary should contain all the model hyperparameter customizations for the particular `model_type`. For example, `PPO` parameters can be found [here](https://stable-baselines3.readthedocs.io/en/master/modules/ppo.html).
-
-## Creating a custom reward function
-
-As you begin to modify the strategy and the prediction model, you will quickly realize some important differences between the Reinforcement Learner and the Regressors/Classifiers. Firstly, the strategy does not set a target value (no labels!). Instead, you set the `calculate_reward()` function inside the `MyRLEnv` class (see below). A default `calculate_reward()` is provided inside `prediction_models/ReinforcementLearner.py` to demonstrate the necessary building blocks for creating rewards, but users are encouraged to create their own custom reinforcement learning model class (see below) and save it to `user_data/freqaimodels`. It is inside the `calculate_reward()` where creative theories about the market can be expressed. For example, you can reward your agent when it makes a winning trade, and penalize the agent when it makes a losing trade. Or perhaps, you wish to reward the agent for entering trades, and penalize the agent for sitting in trades too long. Below we show examples of how these rewards are all calculated:
-
-```python
-    from freqtrade.freqai.prediction_models.ReinforcementLearner import ReinforcementLearner
-    from freqtrade.freqai.RL.Base5ActionRLEnv import Actions, Base5ActionRLEnv, Positions
-
-
-    class MyCoolRLModel(ReinforcementLearner):
-        """
-        User created RL prediction model.
-
-        Save this file to `freqtrade/user_data/freqaimodels`
-
-        then use it with:
-
-        freqtrade trade --freqaimodel MyCoolRLModel --config config.json --strategy SomeCoolStrat
-
-        Here the users can override any of the functions
-        available in the `IFreqaiModel` inheritance tree. Most importantly for RL, this
-        is where the user overrides `MyRLEnv` (see below), to define custom
-        `calculate_reward()` function, or to override any other parts of the environment.
-
-        This class also allows users to override any other part of the IFreqaiModel tree.
-        For example, the user can override `def fit()` or `def train()` or `def predict()`
-        to take fine-tuned control over these processes.
-
-        Another common override may be `def data_cleaning_predict()` where the user can
-        take fine-tuned control over the data handling pipeline.
-        """
-        class MyRLEnv(Base5ActionRLEnv):
-            """
-            User made custom environment. This class inherits from BaseEnvironment and gym.env.
-            Users can override any functions from those parent classes. Here is an example
-            of a user customized `calculate_reward()` function.
-            """
-            def calculate_reward(self, action: int) -> float:
-                # first, penalize if the action is not valid
-                if not self._is_valid(action):
-                    return -2
-                pnl = self.get_unrealized_profit()
-
-                factor = 100
-
-                pair = self.pair.replace(':', '')
-
-                # you can use feature values from dataframe
-                # Assumes the shifted RSI indicator has been generated in the strategy.
-                rsi_now = self.raw_features[f"%-rsi-period_10_shift-1_{pair}_"
-                                f"{self.config['timeframe']}"].iloc[self._current_tick]
-
-                # reward agent for entering trades
-                if (action in (Actions.Long_enter.value, Actions.Short_enter.value)
-                        and self._position == Positions.Neutral):
-                    if rsi_now < 40:
-                        factor = 40 / rsi_now
-                    else:
-                        factor = 1
-                    return 25 * factor
-
-                # discourage agent from not entering trades
-                if action == Actions.Neutral.value and self._position == Positions.Neutral:
-                    return -1
-                max_trade_duration = self.rl_config.get('max_trade_duration_candles', 300)
-                trade_duration = self._current_tick - self._last_trade_tick
-                if trade_duration <= max_trade_duration:
-                    factor *= 1.5
-                elif trade_duration > max_trade_duration:
-                    factor *= 0.5
-                # discourage sitting in position
-                if self._position in (Positions.Short, Positions.Long) and \
-                action == Actions.Neutral.value:
-                    return -1 * trade_duration / max_trade_duration
-                # close long
-                if action == Actions.Long_exit.value and self._position == Positions.Long:
-                    if pnl > self.profit_aim * self.rr:
-                        factor *= self.rl_config['model_reward_parameters'].get('win_reward_factor', 2)
-                    return float(pnl * factor)
-                # close short
-                if action == Actions.Short_exit.value and self._position == Positions.Short:
-                    if pnl > self.profit_aim * self.rr:
-                        factor *= self.rl_config['model_reward_parameters'].get('win_reward_factor', 2)
-                    return float(pnl * factor)
-                return 0.
-```
-
-### Using Tensorboard
-
-Reinforcement Learning models benefit from tracking training metrics. FreqAI has integrated Tensorboard to allow users to track training and evaluation performance across all coins and across all retrainings. Tensorboard is activated via the following command:
-
-```bash
-cd freqtrade
-tensorboard --logdir user_data/models/unique-id
-```
-
-where `unique-id` is the `identifier` set in the `freqai` configuration file. This command must be run in a separate shell to view the output in their browser at 127.0.0.1:6006 (6006 is the default port used by Tensorboard).
-
-![tensorboard](assets/tensorboard.jpg)
-
-
-### Custom logging
-
-FreqAI also provides a built in episodic summary logger called `self.tensorboard_log` for adding custom information to the Tensorboard log. By default, this function is already called once per step inside the environment to record the agent actions. All values accumulated for all steps in a single episode are reported at the conclusion of each episode, followed by a full reset of all metrics to 0 in preparation for the subsequent episode.
-
-
-`self.tensorboard_log` can also be used anywhere inside the environment, for example, it can be added to the `calculate_reward` function to collect more detailed information about how often various parts of the reward were called:
-
-```py
-        class MyRLEnv(Base5ActionRLEnv):
-            """
-            User made custom environment. This class inherits from BaseEnvironment and gym.env.
-            Users can override any functions from those parent classes. Here is an example
-            of a user customized `calculate_reward()` function.
-            """
-            def calculate_reward(self, action: int) -> float:
-                if not self._is_valid(action):
-                    self.tensorboard_log("invalid")
-                    return -2
-
-```
-
-!!! Note
-    The `self.tensorboard_log()` function is designed for tracking incremented objects only i.e. events, actions inside the training environment. If the event of interest is a float, the float can be passed as the second argument e.g. `self.tensorboard_log("float_metric1", 0.23)`. In this case the metric values are not incremented.
-
-### Choosing a base environment
-
-FreqAI provides three base environments, `Base3ActionRLEnvironment`, `Base4ActionEnvironment` and `Base5ActionEnvironment`. As the names imply, the environments are customized for agents that can select from 3, 4 or 5 actions. The `Base3ActionEnvironment` is the simplest, the agent can select from hold, long, or short. This environment can also be used for long-only bots (it automatically follows the `can_short` flag from the strategy), where long is the enter condition and short is the exit condition. Meanwhile, in the `Base4ActionEnvironment`, the agent can enter long, enter short, hold neutral, or exit position. Finally, in the `Base5ActionEnvironment`, the agent has the same actions as Base4, but instead of a single exit action, it separates exit long and exit short. The main changes stemming from the environment selection include:
-
-* the actions available in the `calculate_reward`
-* the actions consumed by the user strategy
-
-All of the FreqAI provided environments inherit from an action/position agnostic environment object called the `BaseEnvironment`, which contains all shared logic. The architecture is designed to be easily customized. The simplest customization is the `calculate_reward()` (see details [here](#creating-a-custom-reward-function)). However, the customizations can be further extended into any of the functions inside the environment. You can do this by simply overriding those functions inside your `MyRLEnv` in the prediction model file. Or for more advanced customizations, it is encouraged to create an entirely new environment inherited from `BaseEnvironment`.
-
-!!! Note
-    Only the `Base3ActionRLEnv` can do long-only training/trading (set the user strategy attribute `can_short = False`).
--- a/docs/freqai-running.md
+++ b/docs/freqai-running.md
@ -1,170 +0,0 @@
-# Running FreqAI
-
-There are two ways to train and deploy an adaptive machine learning model - live deployment and historical backtesting. In both cases, FreqAI runs/simulates periodic retraining of models as shown in the following figure:
-
-![freqai-window](assets/freqai_moving-window.jpg)
-
-## Live deployments
-
-FreqAI can be run dry/live using the following command:
-
-```bash
-freqtrade trade --strategy FreqaiExampleStrategy --config config_freqai.example.json --freqaimodel LightGBMRegressor
-```
-
-When launched, FreqAI will start training a new model, with a new `identifier`, based on the config settings. Following training, the model will be used to make predictions on incoming candles until a new model is available. New models are typically generated as often as possible, with FreqAI managing an internal queue of the coin pairs to try to keep all models equally up to date. FreqAI will always use the most recently trained model to make predictions on incoming live data. If you do not want FreqAI to retrain new models as often as possible, you can set `live_retrain_hours` to tell FreqAI to wait at least that number of hours before training a new model. Additionally, you can set `expired_hours` to tell FreqAI to avoid making predictions on models that are older than that number of hours.
-
-Trained models are by default saved to disk to allow for reuse during backtesting or after a crash. You can opt to [purge old models](#purging-old-model-data) to save disk space by setting `"purge_old_models": true` in the config.
-
-To start a dry/live run from a saved backtest model (or from a previously crashed dry/live session), you only need to specify the `identifier` of the specific model:
-
-```json
-    "freqai": {
-        "identifier": "example",
-        "live_retrain_hours": 0.5
-    }
-```
-
-In this case, although FreqAI will initiate with a pre-trained model, it will still check to see how much time has elapsed since the model was trained. If a full `live_retrain_hours` has elapsed since the end of the loaded model, FreqAI will start training a new model.
-
-### Automatic data download
-
-FreqAI automatically downloads the proper amount of data needed to ensure training of a model through the defined `train_period_days` and `startup_candle_count` (see the [parameter table](freqai-parameter-table.md) for detailed descriptions of these parameters). 
-
-### Saving prediction data
-
-All predictions made during the lifetime of a specific `identifier` model are stored in `historic_predictions.pkl` to allow for reloading after a crash or changes made to the config.
-
-### Purging old model data
-
-FreqAI stores new model files after each successful training. These files become obsolete as new models are generated to adapt to new market conditions. If you are planning to leave FreqAI running for extended periods of time with high frequency retraining, you should enable `purge_old_models` in the config:
-
-```json
-    "freqai": {
-        "purge_old_models": true,
-    }
-```
-
-This will automatically purge all models older than the two most recently trained ones to save disk space.
-
-## Backtesting
-
-The FreqAI backtesting module can be executed with the following command:
-
-```bash
-freqtrade backtesting --strategy FreqaiExampleStrategy --strategy-path freqtrade/templates --config config_examples/config_freqai.example.json --freqaimodel LightGBMRegressor --timerange 20210501-20210701
-```
-
-If this command has never been executed with the existing config file, FreqAI will train a new model
-for each pair, for each backtesting window within the expanded `--timerange`.
-
-Backtesting mode requires [downloading the necessary data](#downloading-data-to-cover-the-full-backtest-period) before deployment (unlike in dry/live mode where FreqAI handles the data downloading automatically). You should be careful to consider that the time range of the downloaded data is more than the backtesting time range. This is because FreqAI needs data prior to the desired backtesting time range in order to train a model to be ready to make predictions on the first candle of the set backtesting time range. More details on how to calculate the data to download can be found [here](#deciding-the-size-of-the-sliding-training-window-and-backtesting-duration).
-
-!!! Note "Model reuse"
-    Once the training is completed, you can execute the backtesting again with the same config file and
-    FreqAI will find the trained models and load them instead of spending time training. This is useful
-    if you want to tweak (or even hyperopt) buy and sell criteria inside the strategy. If you
-    *want* to retrain a new model with the same config file, you should simply change the `identifier`.
-    This way, you can return to using any model you wish by simply specifying the `identifier`.
-
-!!! Note
-    Backtesting calls `set_freqai_targets()` one time for each backtest window (where the number of windows is the full backtest timerange divided by the `backtest_period_days` parameter). Doing this means that the targets simulate dry/live behavior without look ahead bias. However, the definition of the features in `feature_engineering_*()` is performed once on the entire backtest timerange. This means that you should be sure that features do look-ahead into the future.
-    More details about look-ahead bias can be found in [Common Mistakes](strategy-customization.md#common-mistakes-when-developing-strategies).
-
---
-
-### Saving prediction data
-
-To allow for tweaking your strategy (**not** the features!), FreqAI will automatically save the predictions during backtesting so that they can be reused for future backtests and live runs using the same `identifier` model. This provides a performance enhancement geared towards enabling **high-level hyperopting** of entry/exit criteria.
-
-An additional directory called `backtesting_predictions`, which contains all the predictions stored in `hdf` format, will be created in the `unique-id` folder.
-
-To change your **features**, you **must** set a new `identifier` in the config to signal to FreqAI to train new models.
-
-To save the models generated during a particular backtest so that you can start a live deployment from one of them instead of training a new model, you must set `save_backtest_models` to `True` in the config.
-
-### Backtest live collected predictions
-
-FreqAI allow you to reuse live historic predictions through the backtest parameter `--freqai-backtest-live-models`. This can be useful when you want to reuse predictions generated in dry/run for comparison or other study.
-
-The `--timerange` parameter must not be informed, as it will be automatically calculated through the data in the historic predictions file.
-
-
-### Downloading data to cover the full backtest period
-
-For live/dry deployments, FreqAI will download the necessary data automatically. However, to use backtesting functionality, you need to download the necessary data using `download-data` (details [here](data-download.md#data-downloading)). You need to pay careful attention to understanding how much *additional* data needs to be downloaded to ensure that there is a sufficient amount of training data *before* the start of the backtesting time range. The amount of additional data can be roughly estimated by moving the start date of the time range backwards by `train_period_days` and the `startup_candle_count` (see the [parameter table](freqai-parameter-table.md) for detailed descriptions of these parameters) from the beginning of the desired backtesting time range. 
-
-As an example, to backtest the `--timerange 20210501-20210701` using the [example config](freqai-configuration.md#setting-up-the-configuration-file) which sets `train_period_days` to 30, together with `startup_candle_count: 40` on a maximum `include_timeframes` of 1h, the start date for the downloaded data needs to be `20210501` - 30 days - 40 * 1h / 24 hours = 20210330 (31.7 days earlier than the start of the desired training time range).
-
-### Deciding the size of the sliding training window and backtesting duration
-
-The backtesting time range is defined with the typical `--timerange` parameter in the configuration file. The duration of the sliding training window is set by `train_period_days`, whilst `backtest_period_days` is the sliding backtesting window, both in number of days (`backtest_period_days` can be
-a float to indicate sub-daily retraining in live/dry mode). In the presented [example config](freqai-configuration.md#setting-up-the-configuration-file) (found in `config_examples/config_freqai.example.json`), the user is asking FreqAI to use a training period of 30 days and backtest on the subsequent 7 days. After the training of the model, FreqAI will backtest the subsequent 7 days. The "sliding window" then moves one week forward (emulating FreqAI retraining once per week in live mode) and the new model uses the previous 30 days (including the 7 days used for backtesting by the previous model) to train. This is repeated until the end of `--timerange`.  This means that if you set `--timerange 20210501-20210701`, FreqAI will have trained 8 separate models at the end of `--timerange` (because the full range comprises 8 weeks).
-
-!!! Note
-    Although fractional `backtest_period_days` is allowed, you should be aware that the `--timerange` is divided by this value to determine the number of models that FreqAI will need to train in order to backtest the full range. For example, by setting a `--timerange` of 10 days, and a `backtest_period_days` of 0.1, FreqAI will need to train 100 models per pair to complete the full backtest. Because of this, a true backtest of FreqAI adaptive training would take a *very* long time. The best way to fully test a model is to run it dry and let it train constantly. In this case, backtesting would take the exact same amount of time as a dry run.
-
-## Defining model expirations
-
-During dry/live mode, FreqAI trains each coin pair sequentially (on separate threads/GPU from the main Freqtrade bot). This means that there is always an age discrepancy between models. If you are training on 50 pairs, and each pair requires 5 minutes to train, the oldest model will be over 4 hours old. This may be undesirable if the characteristic time scale (the trade duration target) for a strategy is less than 4 hours. You can decide to only make trade entries if the model is less than a certain number of hours old by setting the `expiration_hours` in the config file:
-
-```json
-    "freqai": {
-        "expiration_hours": 0.5,
-    }
-```
-
-In the presented example config, the user will only allow predictions on models that are less than 1/2 hours old.
-
-## Controlling the model learning process
-
-Model training parameters are unique to the selected machine learning library. FreqAI allows you to set any parameter for any library using the `model_training_parameters` dictionary in the config. The example config (found in `config_examples/config_freqai.example.json`) shows some of the example parameters associated with `Catboost` and `LightGBM`, but you can add any parameters available in those libraries or any other machine learning library you choose to implement.
-
-Data split parameters are defined in `data_split_parameters` which can be any parameters associated with scikit-learn's `train_test_split()` function. `train_test_split()` has a parameters called `shuffle` which allows to shuffle the data or keep it unshuffled. This is particularly useful to avoid biasing training with temporally auto-correlated data. More details about these parameters can be found the [scikit-learn website](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html) (external website).
-
-The FreqAI specific parameter `label_period_candles` defines the offset (number of candles into the future) used for the `labels`. In the presented [example config](freqai-configuration.md#setting-up-the-configuration-file), the user is asking for `labels` that are 24 candles in the future.
-
-## Continual learning
-
-You can choose to adopt a continual learning scheme by setting `"continual_learning": true` in the config. By enabling `continual_learning`, after training an initial model from scratch, subsequent trainings will start from the final model state of the preceding training. This gives the new model a "memory" of the previous state. By default, this is set to `False` which means that all new models are trained from scratch, without input from previous models.
-
-???+ danger "Continual learning enforces a constant parameter space"
-    Since `continual_learning` means that the model parameter space *cannot* change between trainings, `principal_component_analysis` is automatically disabled when `continual_learning` is enabled. Hint: PCA changes the parameter space and the number of features, learn more about PCA [here](freqai-feature-engineering.md#data-dimensionality-reduction-with-principal-component-analysis).
-
-## Hyperopt
-
-You can hyperopt using the same command as for [typical Freqtrade hyperopt](hyperopt.md):
-
-```bash
-freqtrade hyperopt --hyperopt-loss SharpeHyperOptLoss --strategy FreqaiExampleStrategy --freqaimodel LightGBMRegressor --strategy-path freqtrade/templates --config config_examples/config_freqai.example.json --timerange 20220428-20220507
-```
-
-`hyperopt` requires you to have the data pre-downloaded in the same fashion as if you were doing [backtesting](#backtesting). In addition, you must consider some restrictions when trying to hyperopt FreqAI strategies:
-
- The `--analyze-per-epoch` hyperopt parameter is not compatible with FreqAI.
- It's not possible to hyperopt indicators in the `feature_engineering_*()` and `set_freqai_targets()` functions. This means that you cannot optimize model parameters using hyperopt. Apart from this exception, it is possible to optimize all other [spaces](hyperopt.md#running-hyperopt-with-smaller-search-space).
- The backtesting instructions also apply to hyperopt.
-
-The best method for combining hyperopt and FreqAI is to focus on hyperopting entry/exit thresholds/criteria. You need to focus on hyperopting parameters that are not used in your features. For example, you should not try to hyperopt rolling window lengths in the feature creation, or any part of the FreqAI config which changes predictions. In order to efficiently hyperopt the FreqAI strategy, FreqAI stores predictions as dataframes and reuses them. Hence the requirement to hyperopt entry/exit thresholds/criteria only.
-
-A good example of a hyperoptable parameter in FreqAI is a threshold for the [Dissimilarity Index (DI)](freqai-feature-engineering.md#identifying-outliers-with-the-dissimilarity-index-di) `DI_values` beyond which we consider data points as outliers:
-
-```python
-di_max = IntParameter(low=1, high=20, default=10, space='buy', optimize=True, load=True)
-dataframe['outlier'] = np.where(dataframe['DI_values'] > self.di_max.value/10, 1, 0)
-```
-
-This specific hyperopt would help you understand the appropriate `DI_values` for your particular parameter space.
-
-## Using Tensorboard
-
-CatBoost models benefit from tracking training metrics via Tensorboard. You can take advantage of the FreqAI integration to track training and evaluation performance across all coins and across all retrainings. Tensorboard is activated via the following command:
-
-```bash
-cd freqtrade
-tensorboard --logdir user_data/models/unique-id
-```
-
-where `unique-id` is the `identifier` set in the `freqai` configuration file. This command must be run in a separate shell if you wish to view the output in your browser at 127.0.0.1:6060 (6060 is the default port used by Tensorboard).
-
-![tensorboard](assets/tensorboard.jpg)
--- a/docs/freqai.md
+++ b/docs/freqai.md
@ -1,127 +0,0 @@
-![freqai-logo](assets/freqai_doc_logo.svg)
-
-# FreqAI
-
-## Introduction
-
-FreqAI is a software designed to automate a variety of tasks associated with training a predictive machine learning model to generate market forecasts given a set of input signals. In general, FreqAI aims to be a sandbox for easily deploying robust machine learning libraries on real-time data ([details](#freqai-position-in-open-source-machine-learning-landscape)).
-
-!!! Note
-    FreqAI is, and always will be, a not-for-profit, open-source project. FreqAI does *not* have a crypto token, FreqAI does *not* sell signals, and FreqAI does not have a domain besides the present [freqtrade documentation](https://www.freqtrade.io/en/latest/freqai/).
-
-Features include:
-
-* **Self-adaptive retraining** - Retrain models during [live deployments](freqai-running.md#live-deployments) to self-adapt to the market in a supervised manner
-* **Rapid feature engineering** - Create large rich [feature sets](freqai-feature-engineering.md#feature-engineering) (10k+ features) based on simple user-created strategies
-* **High performance** - Threading allows for adaptive model retraining on a separate thread (or on GPU if available) from model inferencing (prediction) and bot trade operations. Newest models and data are kept in RAM for rapid inferencing
-* **Realistic backtesting** - Emulate self-adaptive training on historic data with a [backtesting module](freqai-running.md#backtesting) that automates retraining
-* **Extensibility** - The generalized and robust architecture allows for incorporating any [machine learning library/method](freqai-configuration.md#using-different-prediction-models) available in Python. Eight examples are currently available, including classifiers, regressors, and a convolutional neural network
-* **Smart outlier removal** - Remove outliers from training and prediction data sets using a variety of [outlier detection techniques](freqai-feature-engineering.md#outlier-detection)
-* **Crash resilience** - Store trained models to disk to make reloading from a crash fast and easy, and [purge obsolete files](freqai-running.md#purging-old-model-data) for sustained dry/live runs
-* **Automatic data normalization** - [Normalize the data](freqai-feature-engineering.md#feature-normalization) in a smart and statistically safe way
-* **Automatic data download** - Compute timeranges for data downloads and update historic data (in live deployments)
-* **Cleaning of incoming data** - Handle NaNs safely before training and model inferencing
-* **Dimensionality reduction** - Reduce the size of the training data via [Principal Component Analysis](freqai-feature-engineering.md#data-dimensionality-reduction-with-principal-component-analysis)
-* **Deploying bot fleets** - Set one bot to train models while a fleet of [consumers](producer-consumer.md) use signals.
-
-## Quick start
-
-The easiest way to quickly test FreqAI is to run it in dry mode with the following command:
-
-```bash
-freqtrade trade --config config_examples/config_freqai.example.json --strategy FreqaiExampleStrategy --freqaimodel LightGBMRegressor --strategy-path freqtrade/templates
-```
-
-You will see the boot-up process of automatic data downloading, followed by simultaneous training and trading.
-
-An example strategy, prediction model, and config to use as a starting points can be found in
-`freqtrade/templates/FreqaiExampleStrategy.py`, `freqtrade/freqai/prediction_models/LightGBMRegressor.py`, and
-`config_examples/config_freqai.example.json`, respectively.
-
-## General approach
-
-You provide FreqAI with a set of custom *base indicators* (the same way as in a [typical Freqtrade strategy](strategy-customization.md)) as well as target values (*labels*). For each pair in the whitelist, FreqAI trains a model to predict the target values based on the input of custom indicators. The models are then consistently retrained, with a predetermined frequency, to adapt to market conditions. FreqAI offers the ability to both backtest strategies (emulating reality with periodic retraining on historic data) and deploy dry/live runs. In dry/live conditions, FreqAI can be set to constant retraining in a background thread to keep models as up to date as possible.
-
-An overview of the algorithm, explaining the data processing pipeline and model usage, is shown below.
-
-![freqai-algo](assets/freqai_algo.jpg)
-
-### Important machine learning vocabulary
-
-**Features** - the parameters, based on historic data, on which a model is trained. All features for a single candle are stored as a vector. In FreqAI, you build a feature data set from anything you can construct in the strategy.
-
-**Labels** - the target values that the model is trained toward. Each feature vector is associated with a single label that is defined by you within the strategy. These labels intentionally look into the future and are what you are training the model to be able to predict.
-
-**Training** - the process of "teaching" the model to match the feature sets to the associated labels. Different types of models "learn" in different ways which means that one might be better than another for a specific application. More information about the different models that are already implemented in FreqAI can be found [here](freqai-configuration.md#using-different-prediction-models).
-
-**Train data** - a subset of the feature data set that is fed to the model during training to "teach" the model how to predict the targets. This data directly influences weight connections in the model.
-
-**Test data** - a subset of the feature data set that is used to evaluate the performance of the model after training. This data does not influence nodal weights within the model.
-
-**Inferencing** - the process of feeding a trained model new unseen data on which it will make a prediction. 
-
-## Install prerequisites
-
-The normal Freqtrade install process will ask if you wish to install FreqAI dependencies. You should reply "yes" to this question if you wish to use FreqAI. If you did not reply yes, you can manually install these dependencies after the install with:
-
-``` bash
-pip install -r requirements-freqai.txt
-```
-
-!!! Note
-    Catboost will not be installed on arm devices (raspberry, Mac M1, ARM based VPS, ...), since it does not provide wheels for this platform.
-
-!!! Note "python 3.11"
-    Some dependencies (Catboost, Torch) currently don't support python 3.11. Freqtrade therefore only supports python 3.10 for these models/dependencies.
-    Tests involving these dependencies are skipped on 3.11.
-
-### Usage with docker
-
-If you are using docker, a dedicated tag with FreqAI dependencies is available as `:freqai`. As such - you can replace the image line in your docker compose file with `image: freqtradeorg/freqtrade:develop_freqai`. This image contains the regular FreqAI dependencies. Similar to native installs, Catboost will not be available on ARM based devices.
-
-### FreqAI position in open-source machine learning landscape
-
-Forecasting chaotic time-series based systems, such as equity/cryptocurrency markets, requires a broad set of tools geared toward testing a wide range of hypotheses. Fortunately, a recent maturation of robust machine learning libraries (e.g. `scikit-learn`) has opened up a wide range of research possibilities. Scientists from a diverse range of fields can now easily prototype their studies on an abundance of established machine learning algorithms. Similarly, these user-friendly libraries enable "citzen scientists" to use their basic Python skills for data exploration. However, leveraging these machine learning libraries on historical and live chaotic data sources can be logistically difficult and expensive. Additionally, robust data collection, storage, and handling presents a disparate challenge. [`FreqAI`](#freqai) aims to provide a generalized and extensible open-sourced framework geared toward live deployments of adaptive modeling for market forecasting. The `FreqAI` framework is effectively a sandbox for the rich world of open-source machine learning libraries. Inside the `FreqAI` sandbox, users find they can combine a wide variety of third-party libraries to test creative hypotheses on a free live 24/7 chaotic data source - cryptocurrency exchange data. 
-
-### Citing FreqAI
-
-FreqAI is [published in the Journal of Open Source Software](https://joss.theoj.org/papers/10.21105/joss.04864). If you find FreqAI useful in your research, please use the following citation:
-
-```bibtex
-@article{Caulk2022, 
-    doi = {10.21105/joss.04864},
-    url = {https://doi.org/10.21105/joss.04864},
-    year = {2022}, publisher = {The Open Journal},
-    volume = {7}, number = {80}, pages = {4864},
-    author = {Robert A. Caulk and Elin Törnquist and Matthias Voppichler and Andrew R. Lawless and Ryan McMullan and Wagner Costa Santos and Timothy C. Pogue and Johan van der Vlugt and Stefan P. Gehring and Pascal Schmidt},
-    title = {FreqAI: generalizing adaptive modeling for chaotic time-series market forecasts},
-    journal = {Journal of Open Source Software} } 
-```
-
-## Common pitfalls
-
-FreqAI cannot be combined with dynamic `VolumePairlists` (or any pairlist filter that adds and removes pairs dynamically).
-This is for performance reasons - FreqAI relies on making quick predictions/retrains. To do this effectively,
-it needs to download all the training data at the beginning of a dry/live instance. FreqAI stores and appends
-new candles automatically for future retrains. This means that if new pairs arrive later in the dry run due to a volume pairlist, it will not have the data ready. However, FreqAI does work with the `ShufflePairlist` or a `VolumePairlist` which keeps the total pairlist constant (but reorders the pairs according to volume).
-
-## Credits
-
-FreqAI is developed by a group of individuals who all contribute specific skillsets to the project.
-
-Conception and software development:
-Robert Caulk @robcaulk
-
-Theoretical brainstorming and data analysis:
-Elin Törnquist @th0rntwig
-
-Code review and software architecture brainstorming:
-@xmatthias
-
-Software development:
-Wagner Costa @wagnercosta
-Emre Suzen @aemr3
-Timothy Pogue @wizrds
-
-Beta testing and bug reporting:
-Stefan Gehring @bloodhunter4rc, @longyu, Andrew Lawless @paranoidandy, Pascal Schmidt @smidelis, Ryan McMullan @smarmau, Juha Nykänen @suikula, Johan van der Vlugt @jooopiert, Richárd Józsa @richardjosza
--- a/docs/hyperopt.md
+++ b/docs/hyperopt.md
@ -40,25 +40,22 @@ pip install -r requirements-hyperopt.txt
 ```
 usage: freqtrade hyperopt [-h] [-v] [--logfile FILE] [-V] [-c PATH] [-d PATH]
                          [--userdir PATH] [-s NAME] [--strategy-path PATH]
-                          [--recursive-strategy-search] [--freqaimodel NAME]
-                          [--freqaimodel-path PATH] [-i TIMEFRAME]
-                          [--timerange TIMERANGE]
+                          [-i TIMEFRAME] [--timerange TIMERANGE]
                          [--data-format-ohlcv {json,jsongz,hdf5}]
                          [--max-open-trades INT]
                          [--stake-amount STAKE_AMOUNT] [--fee FLOAT]
                          [-p PAIRS [PAIRS ...]] [--hyperopt-path PATH]
                          [--eps] [--dmmp] [--enable-protections]
-                          [--dry-run-wallet DRY_RUN_WALLET]
-                          [--timeframe-detail TIMEFRAME_DETAIL] [-e INT]
-                          [--spaces {all,buy,sell,roi,stoploss,trailing,protection,trades,default} [{all,buy,sell,roi,stoploss,trailing,protection,trades,default} ...]]
+                          [--dry-run-wallet DRY_RUN_WALLET] [-e INT]
+                          [--spaces {all,buy,sell,roi,stoploss,trailing,protection,default} [{all,buy,sell,roi,stoploss,trailing,protection,default} ...]]
                          [--print-all] [--no-color] [--print-json] [-j JOBS]
                          [--random-state INT] [--min-trades INT]
                          [--hyperopt-loss NAME] [--disable-param-export]
-                          [--ignore-missing-spaces] [--analyze-per-epoch]
+                          [--ignore-missing-spaces]

 optional arguments:
  -h, --help            show this help message and exit
-  -i TIMEFRAME, --timeframe TIMEFRAME
+  -i TIMEFRAME, --timeframe TIMEFRAME, --ticker-interval TIMEFRAME
                        Specify timeframe (`1m`, `5m`, `30m`, `1h`, `1d`).
  --timerange TIMERANGE
                        Specify what timerange of data to use.
@ -92,11 +89,8 @@ optional arguments:
  --dry-run-wallet DRY_RUN_WALLET, --starting-balance DRY_RUN_WALLET
                        Starting balance, used for backtesting / hyperopt and
                        dry-runs.
-  --timeframe-detail TIMEFRAME_DETAIL
-                        Specify detail timeframe for backtesting (`1m`, `5m`,
-                        `30m`, `1h`, `1d`).
  -e INT, --epochs INT  Specify number of epochs (default: 100).
-  --spaces {all,buy,sell,roi,stoploss,trailing,protection,trades,default} [{all,buy,sell,roi,stoploss,trailing,protection,trades,default} ...]
+  --spaces {all,buy,sell,roi,stoploss,trailing,protection,default} [{all,buy,sell,roi,stoploss,trailing,protection,default} ...]
                        Specify which parameters to hyperopt. Space-separated
                        list.
  --print-all           Print all results, not only the best ones.
@ -122,15 +116,12 @@ optional arguments:
                        ShortTradeDurHyperOptLoss, OnlyProfitHyperOptLoss,
                        SharpeHyperOptLoss, SharpeHyperOptLossDaily,
                        SortinoHyperOptLoss, SortinoHyperOptLossDaily,
-                        CalmarHyperOptLoss, MaxDrawDownHyperOptLoss,
-                        MaxDrawDownRelativeHyperOptLoss,
-                        ProfitDrawDownHyperOptLoss
+                        CalmarHyperOptLoss, MaxDrawDownHyperOptLoss, ProfitDrawDownHyperOptLoss
  --disable-param-export
                        Disable automatic hyperopt parameter export.
  --ignore-missing-spaces, --ignore-unparameterized-spaces
                        Suppress errors for any requested Hyperopt spaces that
                        do not contain any parameters.
-  --analyze-per-epoch   Run populate_indicators once per epoch.

 Common arguments:
  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
@ -153,12 +144,6 @@ Strategy arguments:
                        Specify strategy class name which will be used by the
                        bot.
  --strategy-path PATH  Specify additional strategy lookup path.
-  --recursive-strategy-search
-                        Recursively search for a strategy in the strategies
-                        folder.
-  --freqaimodel NAME    Specify a custom freqaimodels.
-  --freqaimodel-path PATH
-                        Specify additional lookup path for freqaimodels.

 ```

@ -168,8 +153,8 @@ Checklist on all tasks / possibilities in hyperopt

 Depending on the space you want to optimize, only some of the below are required:

-* define parameters with `space='buy'` - for entry signal optimization
-* define parameters with `space='sell'` - for exit signal optimization
+* define parameters with `space='buy'` - for buy signal optimization
+* define parameters with `space='sell'` - for sell signal optimization

 !!! Note
    `populate_indicators` needs to create all indicators any of the spaces may use, otherwise hyperopt will not work.
@ -180,7 +165,6 @@ Rarely you may also need to create a [nested class](advanced-hyperopt.md#overrid
 * `generate_roi_table` - for custom ROI optimization (if you need the ranges for the values in the ROI table that differ from default or the number of entries (steps) in the ROI table which differs from the default 4 steps)
 * `stoploss_space` - for custom stoploss optimization (if you need the range for the stoploss parameter in the optimization hyperspace that differs from default)
 * `trailing_space` - for custom trailing stop optimization (if you need the ranges for the trailing stop parameters in the optimization hyperspace that differ from default)
-* `max_open_trades_space` - for custom max_open_trades optimization (if you need the ranges for the max_open_trades parameter in the optimization hyperspace that differ from default)

 !!! Tip "Quickly optimize ROI, stoploss and trailing stoploss"
    You can quickly optimize the spaces `roi`, `stoploss` and `trailing` without changing anything in your strategy.
@ -192,11 +176,11 @@ Rarely you may also need to create a [nested class](advanced-hyperopt.md#overrid

 ### Hyperopt execution logic

-Hyperopt will first load your data into memory and will then run `populate_indicators()` once per Pair to generate all indicators, unless `--analyze-per-epoch` is specified.
+Hyperopt will first load your data into memory and will then run `populate_indicators()` once per Pair to generate all indicators.

 Hyperopt will then spawn into different processes (number of processors, or `-j <n>`), and run backtesting over and over again, changing the parameters that are part of the `--spaces` defined.

-For every new set of parameters, freqtrade will run first `populate_entry_trend()` followed by `populate_exit_trend()`, and then run the regular backtesting process to simulate trades.
+For every new set of parameters, freqtrade will run first `populate_buy_trend()` followed by `populate_sell_trend()`, and then run the regular backtesting process to simulate trades.

 After backtesting, the results are passed into the [loss function](#loss-functions), which will evaluate if this result was better or worse than previous results.  
 Based on the loss function result, hyperopt will determine the next set of parameters to try in the next round of backtesting.
@ -206,7 +190,7 @@ Based on the loss function result, hyperopt will determine the next set of param
 There are two places you need to change in your strategy file to add a new buy hyperopt for testing:

 * Define the parameters at the class level hyperopt shall be optimizing.
-* Within `populate_entry_trend()` - use defined parameter values instead of raw constants.
+* Within `populate_buy_trend()` - use defined parameter values instead of raw constants.

 There you have two different types of indicators: 1. `guards` and 2. `triggers`.

@ -216,25 +200,25 @@ There you have two different types of indicators: 1. `guards` and 2. `triggers`.
 !!! Hint "Guards and Triggers"
    Technically, there is no difference between Guards and Triggers.  
    However, this guide will make this distinction to make it clear that signals should not be "sticking".
-    Sticking signals are signals that are active for multiple candles. This can lead into entering a signal late (right before the signal disappears - which means that the chance of success is a lot lower than right at the beginning).
+    Sticking signals are signals that are active for multiple candles. This can lead into buying a signal late (right before the signal disappears - which means that the chance of success is a lot lower than right at the beginning).

 Hyper-optimization will, for each epoch round, pick one trigger and possibly multiple guards.

-#### Exit signal optimization
+#### Sell optimization

-Similar to the entry-signal above, exit-signals can also be optimized.
+Similar to the buy-signal above, sell-signals can also be optimized.
 Place the corresponding settings into the following methods

 * Define the parameters at the class level hyperopt shall be optimizing, either naming them `sell_*`, or by explicitly defining `space='sell'`.
-* Within `populate_exit_trend()` - use defined parameter values instead of raw constants.
+* Within `populate_sell_trend()` - use defined parameter values instead of raw constants.

 The configuration and rules are the same than for buy signals.

 ## Solving a Mystery

-Let's say you are curious: should you use MACD crossings or lower Bollinger Bands to trigger your long entries.
-And you also wonder should you use RSI or ADX to help with those decisions.
-If you decide to use RSI or ADX, which values should I use for them?
+Let's say you are curious: should you use MACD crossings or lower Bollinger Bands to trigger your buys. 
+And you also wonder should you use RSI or ADX to help with those buy decisions. 
+If you decide to use RSI or ADX, which values should I use for them? 

 So let's use hyperparameter optimization to solve this mystery.

@ -285,13 +269,12 @@ The last one we call `trigger` and use it to decide which buy trigger we want to

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

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

 ```python
-    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        conditions = []
        # GUARDS AND TRENDS
        if self.buy_adx_enabled.value:
@ -313,12 +296,12 @@ So let's write the buy strategy using these values:
        if conditions:
            dataframe.loc[
                reduce(lambda x, y: x & y, conditions),
-                'enter_long'] = 1
+                'buy'] = 1

        return dataframe
 ```

-Hyperopt will now call `populate_entry_trend()` many times (`epochs`) with different value combinations.  
+Hyperopt will now call `populate_buy_trend()` many times (`epochs`) with different value combinations.  
 It will use the given historical data and simulate buys based on the buy signals generated with the above function.  
 Based on the results, hyperopt will tell you which parameter combination produced the best results (based on the configured [loss function](#loss-functions)).

@ -349,7 +332,6 @@ There are four parameter types each suited for different purposes.
 ## Optimizing an indicator parameter

 Assuming you have a simple strategy in mind - a EMA cross strategy (2 Moving averages crossing) - and you'd like to find the ideal parameters for this strategy.
-By default, we assume a stoploss of 5% - and a take-profit (`minimal_roi`) of 10% - which means freqtrade will sell the trade once 10% profit has been reached.

 ``` python
 from pandas import DataFrame
@ -364,9 +346,6 @@ import freqtrade.vendor.qtpylib.indicators as qtpylib
 class MyAwesomeStrategy(IStrategy):
    stoploss = -0.05
    timeframe = '15m'
-    minimal_roi = {
-        "0":  0.10
-    }
    # Define the parameter spaces
    buy_ema_short = IntParameter(3, 50, default=5)
    buy_ema_long = IntParameter(15, 200, default=50)
@ -385,7 +364,7 @@ class MyAwesomeStrategy(IStrategy):
        
        return dataframe

-    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        conditions = []
        conditions.append(qtpylib.crossed_above(
                dataframe[f'ema_short_{self.buy_ema_short.value}'], dataframe[f'ema_long_{self.buy_ema_long.value}']
@ -397,10 +376,10 @@ class MyAwesomeStrategy(IStrategy):
        if conditions:
            dataframe.loc[
                reduce(lambda x, y: x & y, conditions),
-                'enter_long'] = 1
+                'buy'] = 1
        return dataframe

-    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+    def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        conditions = []
        conditions.append(qtpylib.crossed_above(
                dataframe[f'ema_long_{self.buy_ema_long.value}'], dataframe[f'ema_short_{self.buy_ema_short.value}']
@ -412,7 +391,7 @@ class MyAwesomeStrategy(IStrategy):
        if conditions:
            dataframe.loc[
                reduce(lambda x, y: x & y, conditions),
-                'exit_long'] = 1
+                'sell'] = 1
        return dataframe
 ```

@ -422,7 +401,7 @@ Using `self.buy_ema_short.range` will return a range object containing all entri
 In this case (`IntParameter(3, 50, default=5)`), the loop would run for all numbers between 3 and 50 (`[3, 4, 5, ... 49, 50]`).
 By using this in a loop, hyperopt will generate 48 new columns (`['buy_ema_3', 'buy_ema_4', ... , 'buy_ema_50']`).

-Hyperopt itself will then use the selected value to create the buy and sell signals.
+Hyperopt itself will then use the selected value to create the buy and sell signals

 While this strategy is most likely too simple to provide consistent profit, it should serve as an example how optimize indicator parameters.

@ -433,10 +412,9 @@ While this strategy is most likely too simple to provide consistent profit, it s
    `range` property may also be used with `DecimalParameter` and `CategoricalParameter`. `RealParameter` does not provide this property due to infinite search space.

 ??? Hint "Performance tip"
-    During normal hyperopting, indicators are calculated once and supplied to each epoch, linearly increasing RAM usage as a factor of increasing cores. As this also has performance implications, hyperopt provides `--analyze-per-epoch` which will move the execution of `populate_indicators()` to the epoch process, calculating a single value per parameter per epoch instead of using the `.range` functionality. In this case, `.range` functionality will only return the actually used value. This will reduce RAM usage, but increase CPU usage. However, your hyperopting run will be less likely to fail due to Out Of Memory (OOM) issues.
-
-    In either case, you should try to use space ranges as small as possible this will improve CPU/RAM usage in both scenarios.
-
+    By doing the calculation of all possible indicators in `populate_indicators()`, the calculation of the indicator happens only once for every parameter.  
+    While this may slow down the hyperopt startup speed, the overall performance will increase as the Hyperopt execution itself may pick the same value for multiple epochs (changing other values).
+    You should however try to use space ranges as small as possible. Every new column will require more memory, and every possibility hyperopt can try will increase the search space.

 ## Optimizing protections

@ -585,8 +563,7 @@ Currently, the following loss functions are builtin:
 * `SharpeHyperOptLossDaily` - optimizes Sharpe Ratio calculated on **daily** trade returns relative to standard deviation.
 * `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 absolute drawdown.
-* `MaxDrawDownRelativeHyperOptLoss` -  Optimizes both maximum absolute drawdown while also adjusting for maximum relative drawdown.
+* `MaxDrawDownHyperOptLoss` - Optimizes Maximum drawdown.
 * `CalmarHyperOptLoss` - Optimizes Calmar Ratio calculated on trade returns relative to max drawdown.
 * `ProfitDrawDownHyperOptLoss` - Optimizes by max Profit & min Drawdown objective. `DRAWDOWN_MULT` variable within the hyperoptloss file can be adjusted to be stricter or more flexible on drawdown purposes.

@ -644,7 +621,6 @@ Legal values are:
 * `roi`: just optimize the minimal profit table for your strategy
 * `stoploss`: search for the best stoploss value
 * `trailing`: search for the best trailing stop values
-* `trades`: search for the best max open trades values
 * `protection`: search for the best protection parameters (read the [protections section](#optimizing-protections) on how to properly define these)
 * `default`: `all` except `trailing` and `protection`
 * space-separated list of any of the above values for example `--spaces roi stoploss`
@ -701,7 +677,7 @@ class MyAwesomeStrategy(IStrategy):

 !!! Note
    Values in the configuration file will overwrite Parameter-file level parameters - and both will overwrite parameters within the strategy.
-    The prevalence is therefore: config > parameter file > strategy `*_params` > parameter default
+    The prevalence is therefore: config > parameter file > strategy

 ### Understand Hyperopt ROI results

@ -883,29 +859,10 @@ You can also enable position stacking in the configuration file by explicitly se
 As hyperopt consumes a lot of memory (the complete data needs to be in memory once per parallel backtesting process), it's likely that you run into "out of memory" errors.
 To combat these, you have multiple options:

-* Reduce the amount of pairs.
-* Reduce the timerange used (`--timerange <timerange>`).
-* Avoid using `--timeframe-detail` (this loads a lot of additional data into memory).
-* Reduce the number of parallel processes (`-j <n>`).
-* Increase the memory of your machine.
-* Use `--analyze-per-epoch` if you're using a lot of parameters with `.range` functionality.
-
-
-## The objective has been evaluated at this point before.
-
-If you see `The objective has been evaluated at this point before.` - then this is a sign that your space has been exhausted, or is close to that.
-Basically all points in your space have been hit (or a local minima has been hit) - and hyperopt does no longer find points in the multi-dimensional space it did not try yet.
-Freqtrade tries to counter the "local minima" problem by using new, randomized points in this case.
-
-Example:
-
-``` python
-buy_ema_short = IntParameter(5, 20, default=10, space="buy", optimize=True)
-# This is the only parameter in the buy space
-```
-
-The `buy_ema_short` space has 15 possible values (`5, 6, ... 19, 20`). If you now run hyperopt for the buy space, hyperopt will only have 15 values to try before running out of options.
-Your epochs should therefore be aligned to the possible values - or you should be ready to interrupt a run if you norice a lot of `The objective has been evaluated at this point before.` warnings.
+* reduce the amount of pairs
+* reduce the timerange used (`--timerange <timerange>`)
+* reduce the number of parallel processes (`-j <n>`)
+* Increase the memory of your machine

 ## Show details of Hyperopt results

@ -918,5 +875,5 @@ Once the optimized strategy has been implemented into your strategy, you should
 To achieve same the results (number of trades, their durations, profit, etc.) as during Hyperopt, please use the same configuration and parameters (timerange, timeframe, ...) used for hyperopt `--dmmp`/`--disable-max-market-positions` and `--eps`/`--enable-position-stacking` for Backtesting.

 Should results not match, please double-check to make sure you transferred all conditions correctly.
-Pay special care to the stoploss, max_open_trades and trailing stoploss parameters, as these are often set in configuration files, which override changes to the strategy.
-You should also carefully review the log of your backtest to ensure that there were no parameters inadvertently set by the configuration (like `stoploss`, `max_open_trades` or `trailing_stop`).
+Pay special care to the stoploss (and trailing stoploss) parameters, as these are often set in configuration files, which override changes to the strategy.
+You should also carefully review the log of your backtest to ensure that there were no parameters inadvertently set by the configuration (like `stoploss` or `trailing_stop`).
--- a/docs/includes/pairlists.md
+++ b/docs/includes/pairlists.md
@ -22,8 +22,6 @@ You may also use something like `.*DOWN/BTC` or `.*UP/BTC` to exclude leveraged

 * [`StaticPairList`](#static-pair-list) (default, if not configured differently)
 * [`VolumePairList`](#volume-pair-list)
-* [`ProducerPairList`](#producerpairlist)
-* [`RemotePairList`](#remotepairlist)
 * [`AgeFilter`](#agefilter)
 * [`OffsetFilter`](#offsetfilter)
 * [`PerformanceFilter`](#performancefilter)
@ -46,7 +44,7 @@ It uses configuration from `exchange.pair_whitelist` and `exchange.pair_blacklis
 ```json
 "pairlists": [
    {"method": "StaticPairList"}
-],
+    ],
 ```

 By default, only currently enabled pairs are allowed.
@ -86,7 +84,7 @@ Filtering instances (not the first position in the list) will not apply any cach

 You can define a minimum volume with `min_value` - which will filter out pairs with a volume lower than the specified value in the specified timerange.

-##### VolumePairList Advanced mode
+### VolumePairList Advanced mode

 `VolumePairList` can also operate in an advanced mode to build volume over a given timerange of specified candle size. It utilizes exchange historical candle data, builds a typical price (calculated by (open+high+low)/3) and multiplies the typical price with every candle's volume. The sum is the `quoteVolume` over the given range. This allows different scenarios, for a  more smoothened volume, when using longer ranges with larger candle sizes, or the opposite when using a short range with small candles.

@ -148,74 +146,6 @@ More sophisticated approach can be used, by using `lookback_timeframe` for candl
 !!! Note
    `VolumePairList` does not support backtesting mode.

-#### ProducerPairList
-
-With `ProducerPairList`, you can reuse the pairlist from a [Producer](producer-consumer.md) without explicitly defining the pairlist on each consumer.
-
-[Consumer mode](producer-consumer.md) is required for this pairlist to work.
-
-The pairlist will perform a check on active pairs against the current exchange configuration to avoid attempting to trade on invalid markets.
-
-You can limit the length of the pairlist with the optional parameter `number_assets`. Using `"number_assets"=0` or omitting this key will result in the reuse of all producer pairs valid for the current setup.
-
-```json
-"pairlists": [
-    {
-        "method": "ProducerPairList",
-        "number_assets": 5,
-        "producer_name": "default",
-    }
-],
-```
-
-
-!!! Tip "Combining pairlists"
-    This pairlist can be combined with all other pairlists and filters for further pairlist reduction, and can also act as an "additional" pairlist, on top of already defined pairs.
-    `ProducerPairList` can also be used multiple times in sequence, combining the pairs from multiple producers.
-    Obviously in complex such configurations, the Producer may not provide data for all pairs, so the strategy must be fit for this.
-
-#### RemotePairList
-
-It allows the user to fetch a pairlist from a remote server or a locally stored json file within the freqtrade directory, enabling dynamic updates and customization of the trading pairlist.
-
-The RemotePairList is defined in the pairlists section of the configuration settings. It uses the following configuration options:
-
-```json
-"pairlists": [
-    {
-        "method": "RemotePairList",
-        "pairlist_url": "https://example.com/pairlist",
-        "number_assets": 10,
-        "refresh_period": 1800,
-        "keep_pairlist_on_failure": true,
-        "read_timeout": 60,
-        "bearer_token": "my-bearer-token"
-    }
-]
-```
-
-The `pairlist_url` option specifies the URL of the remote server where the pairlist is located, or the path to a local file (if file:/// is prepended). This allows the user to use either a remote server or a local file as the source for the pairlist.
-
-The user is responsible for providing a server or local file that returns a JSON object with the following structure:
-
-```json
-{
-    "pairs": ["XRP/USDT", "ETH/USDT", "LTC/USDT"],
-    "refresh_period": 1800,
-}
-```
-
-The `pairs` property should contain a list of strings with the trading pairs to be used by the bot. The `refresh_period` property is optional and specifies the number of seconds that the pairlist should be cached before being refreshed.
-
-The optional `keep_pairlist_on_failure` specifies whether the previous received pairlist should be used if the remote server is not reachable or returns an error. The default value is true.
-
-The optional `read_timeout` specifies the maximum amount of time (in seconds) to wait for a response from the remote source, The default value is 60.
-
-The optional `bearer_token` will be included in the requests Authorization Header.
-
-!!! Note
-    In case of a server error the last received pairlist will be kept if `keep_pairlist_on_failure` is set to true, when set to false a empty pairlist is returned.
-
 #### AgeFilter

 Removes pairs that have been listed on the exchange for less than `min_days_listed` days (defaults to `10`) or more than `max_days_listed` days (defaults `None` mean infinity).
@ -230,17 +160,17 @@ This filter allows freqtrade to ignore pairs until they have been listed for at

 Offsets an incoming pairlist by a given `offset` value.

-As an example it can be used in conjunction with `VolumeFilter` to remove the top X volume pairs. Or to split a larger pairlist on two bot instances.
+As an example it can be used in conjunction with `VolumeFilter` to remove the top X volume pairs. Or to split
+a larger pairlist on two bot instances.

-Example to remove the first 10 pairs from the pairlist, and takes the next 20 (taking items 10-30 of the initial list):
+Example to remove the first 10 pairs from the pairlist:

 ```json
 "pairlists": [
    // ...
    {
        "method": "OffsetFilter",
-        "offset": 10,
-        "number_assets": 20
+        "offset": 10
    }
 ],
 ```
@ -251,7 +181,7 @@ Example to remove the first 10 pairs from the pairlist, and takes the next 20 (t
    `VolumeFilter`.

 !!! Note
-    An offset larger than the total length of the incoming pairlist will result in an empty pairlist.
+    An offset larger then the total length of the incoming pairlist will result in an empty pairlist.

 #### PerformanceFilter

@ -311,7 +241,7 @@ This option is disabled by default, and will only apply if set to > 0.
 The `max_value` setting removes pairs where the minimum value change is above a specified value.
 This is useful when an exchange has unbalanced limits. For example, if step-size = 1 (so you can only buy 1, or 2, or 3, but not 1.1 Coins) - and the price is pretty high (like 20\$) as the coin has risen sharply since the last limit adaption.
 As a result of the above, you can only buy for 20\$, or 40\$ - but not for 25\$.
-On exchanges that deduct fees from the receiving currency (e.g. binance) - this can result in high value coins / amounts that are unsellable as the amount is slightly below the limit.
+On exchanges that deduct fees from the receiving currency (e.g. FTX) - this can result in high value coins / amounts that are unsellable as the amount is slightly below the limit.

 The `low_price_ratio` setting removes pairs where a raise of 1 price unit (pip) is above the `low_price_ratio` ratio.
 This option is disabled by default, and will only apply if set to > 0.
@ -329,18 +259,6 @@ 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.

-By default, ShuffleFilter will shuffle pairs once per candle.
-To shuffle on every iteration, set `"shuffle_frequency"` to `"iteration"` instead of  the default of `"candle"`.
-
-``` json
-    {
-        "method": "ShuffleFilter", 
-        "shuffle_frequency": "candle",
-        "seed": 42
-    }
-
-```
-
 !!! 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. ShuffleFilter will automatically detect runmodes and apply the `seed` only for backtesting modes - if a `seed` value is set.

--- a/docs/includes/pricing.md
+++ b/docs/includes/pricing.md
@ -1,6 +1,6 @@
 ## Prices used for orders

-Prices for regular orders can be controlled via the parameter structures `entry_pricing` for trade entries and `exit_pricing` for trade exits.
+Prices for regular orders can be controlled via the parameter structures `bid_strategy` for buying and `ask_strategy` for selling.
 Prices are always retrieved right before an order is placed, either by querying the exchange tickers or by using the orderbook data.

 !!! Note
@ -9,11 +9,20 @@ Prices are always retrieved right before an order is placed, either by querying
 !!! Warning "Using market orders"
    Please read the section [Market order pricing](#market-order-pricing) section when using market orders.

-### Entry price
+### Buy price

-#### Enter price side
+#### Check depth of market

-The configuration setting `entry_pricing.price_side` defines the side of the orderbook the bot looks for when buying.
+When check depth of market is enabled (`bid_strategy.check_depth_of_market.enabled=True`), the buy signals are filtered based on the orderbook depth (sum of all amounts) for each orderbook side.
+
+Orderbook `bid` (buy) side depth is then divided by the orderbook `ask` (sell) side depth and the resulting delta is compared to the value of the `bid_strategy.check_depth_of_market.bids_to_ask_delta` parameter. The buy order is only executed if the orderbook delta is greater than or equal to the configured delta value.
+
+!!! Note
+    A delta value below 1 means that `ask` (sell) orderbook side depth is greater than the depth of the `bid` (buy) orderbook side, while a value greater than 1 means opposite (depth of the buy side is higher than the depth of the sell side).
+
+#### Buy price side
+
+The configuration setting `bid_strategy.price_side` defines the side of the spread the bot looks for when buying.

 The following displays an orderbook.

@ -29,53 +38,30 @@ The following displays an orderbook.
 ...
 ```

-If `entry_pricing.price_side` is set to `"bid"`, then the bot will use 99 as entry price.  
-In line with that, if `entry_pricing.price_side` is set to `"ask"`, then the bot will use 101 as entry price.
+If `bid_strategy.price_side` is set to `"bid"`, then the bot will use 99 as buying price.  
+In line with that, if `bid_strategy.price_side` is set to `"ask"`, then the bot will use 101 as buying price.

-Depending on the order direction (_long_/_short_), this will lead to different results. Therefore we recommend to use `"same"` or `"other"` for this configuration instead.
-This would result in the following pricing matrix:
-
-| direction | Order | setting | price | crosses spread |
-|------ |--------|-----|-----|-----|
-| long  | buy  | ask   | 101 | yes |
-| long  | buy  | bid   | 99  | no  |
-| long  | buy  | same  | 99  | no  |
-| long  | buy  | other | 101 | yes |
-| short | sell | ask   | 101 | no  |
-| short | sell | bid   | 99  | yes |
-| short | sell | same  | 101 | no  |
-| short | sell | other | 99  | yes |
-
-Using the other side of the orderbook often guarantees quicker filled orders, but the bot can also end up paying more than what would have been necessary.
+Using `ask` price often guarantees quicker filled orders, but the bot can also end up paying more than what would have been necessary.
 Taker fees instead of maker fees will most likely apply even when using limit buy orders.
-Also, prices at the "other" side of the spread are higher than prices at the "bid" side in the orderbook, so the order behaves similar to a market order (however with a maximum price).
+Also, prices at the "ask" side of the spread are higher than prices at the "bid" side in the orderbook, so the order behaves similar to a market order (however with a maximum price).

-#### Entry price with Orderbook enabled
+#### Buy price with Orderbook enabled

-When entering a trade with the orderbook enabled (`entry_pricing.use_order_book=True`), Freqtrade fetches the `entry_pricing.order_book_top` entries from the orderbook and uses the entry specified as `entry_pricing.order_book_top` on the configured side (`entry_pricing.price_side`) of the orderbook. 1 specifies the topmost entry in the orderbook, while 2 would use the 2nd entry in the orderbook, and so on.
+When buying with the orderbook enabled (`bid_strategy.use_order_book=True`), Freqtrade fetches the `bid_strategy.order_book_top` entries from the orderbook and uses the entry specified as `bid_strategy.order_book_top` on the configured side (`bid_strategy.price_side`) of the orderbook. 1 specifies the topmost entry in the orderbook, while 2 would use the 2nd entry in the orderbook, and so on.

-#### Entry price without Orderbook enabled
+#### Buy price without Orderbook enabled

-The following section uses `side` as the configured `entry_pricing.price_side` (defaults to `"same"`).
+The following section uses `side` as the configured `bid_strategy.price_side`.

-When not using orderbook (`entry_pricing.use_order_book=False`), Freqtrade uses the best `side` price from the ticker if it's below the `last` traded price from the ticker. Otherwise (when the `side` price is above the `last` price), it calculates a rate between `side` and `last` price based on `entry_pricing.price_last_balance`.
+When not using orderbook (`bid_strategy.use_order_book=False`), Freqtrade uses the best `side` price from the ticker if it's below the `last` traded price from the ticker. Otherwise (when the `side` price is above the `last` price), it calculates a rate between `side` and `last` price.

-The `entry_pricing.price_last_balance` configuration parameter controls this. A value of `0.0` will use `side` price, while `1.0` will use the `last` price and values between those interpolate between ask and last price.
+The `bid_strategy.ask_last_balance` configuration parameter controls this. A value of `0.0` will use `side` price, while `1.0` will use the `last` price and values between those interpolate between ask and last price.

-#### Check depth of market
+### Sell price

-When check depth of market is enabled (`entry_pricing.check_depth_of_market.enabled=True`), the entry signals are filtered based on the orderbook depth (sum of all amounts) for each orderbook side.
+#### Sell price side

-Orderbook `bid` (buy) side depth is then divided by the orderbook `ask` (sell) side depth and the resulting delta is compared to the value of the `entry_pricing.check_depth_of_market.bids_to_ask_delta` parameter. The entry order is only executed if the orderbook delta is greater than or equal to the configured delta value.
-
-!!! Note
-    A delta value below 1 means that `ask` (sell) orderbook side depth is greater than the depth of the `bid` (buy) orderbook side, while a value greater than 1 means opposite (depth of the buy side is higher than the depth of the sell side).
-
-### Exit price
-
-#### Exit price side
-
-The configuration setting `exit_pricing.price_side` defines the side of the spread the bot looks for when exiting a trade.
+The configuration setting `ask_strategy.price_side` defines the side of the spread the bot looks for when selling.

 The following displays an orderbook:

@ -91,54 +77,40 @@ The following displays an orderbook:
 ...
 ```

-If `exit_pricing.price_side` is set to `"ask"`, then the bot will use 101 as exiting price.  
-In line with that, if `exit_pricing.price_side` is set to `"bid"`, then the bot will use 99 as exiting price.
+If `ask_strategy.price_side` is set to `"ask"`, then the bot will use 101 as selling price.  
+In line with that, if `ask_strategy.price_side` is set to `"bid"`, then the bot will use 99 as selling price.

-Depending on the order direction (_long_/_short_), this will lead to different results. Therefore we recommend to use `"same"` or `"other"` for this configuration instead.
-This would result in the following pricing matrix:
+#### Sell price with Orderbook enabled

-| Direction | Order | setting | price | crosses spread |
-|------ |--------|-----|-----|-----|
-| long  | sell | ask   | 101 | no  |
-| long  | sell | bid   | 99  | yes |
-| long  | sell | same  | 101 | no  |
-| long  | sell | other | 99  | yes |
-| short | buy  | ask   | 101 | yes |
-| short | buy  | bid   | 99  | no  |
-| short | buy  | same  | 99  | no  |
-| short | buy  | other | 101 | yes |
-
-#### Exit price with Orderbook enabled
-
-When exiting with the orderbook enabled (`exit_pricing.use_order_book=True`), Freqtrade fetches the `exit_pricing.order_book_top` entries in the orderbook and uses the entry specified as `exit_pricing.order_book_top` from the configured side (`exit_pricing.price_side`) as trade exit price.
+When selling with the orderbook enabled (`ask_strategy.use_order_book=True`), Freqtrade fetches the `ask_strategy.order_book_top` entries in the orderbook and uses the entry specified as `ask_strategy.order_book_top` from the configured side (`ask_strategy.price_side`) as selling price.

 1 specifies the topmost entry in the orderbook, while 2 would use the 2nd entry in the orderbook, and so on.

-#### Exit price without Orderbook enabled
+#### Sell price without Orderbook enabled

-The following section uses `side` as the configured `exit_pricing.price_side` (defaults to `"ask"`).
+When not using orderbook (`ask_strategy.use_order_book=False`), the price at the `ask_strategy.price_side` side (defaults to `"ask"`) from the ticker will be used as the sell price.

-When not using orderbook (`exit_pricing.use_order_book=False`), Freqtrade uses the best `side` price from the ticker if it's above the `last` traded price from the ticker. Otherwise (when the `side` price is below the `last` price), it calculates a rate between `side` and `last` price based on `exit_pricing.price_last_balance`.
+When not using orderbook (`ask_strategy.use_order_book=False`), Freqtrade uses the best `side` price from the ticker if it's below the `last` traded price from the ticker. Otherwise (when the `side` price is above the `last` price), it calculates a rate between `side` and `last` price.

-The `exit_pricing.price_last_balance` configuration parameter controls this. A value of `0.0` will use `side` price, while `1.0` will use the last price and values between those interpolate between `side` and last price.
+The `ask_strategy.bid_last_balance` configuration parameter controls this. A value of `0.0` will use `side` price, while `1.0` will use the last price and values between those interpolate between `side` and last price.

 ### Market order pricing

 When using market orders, prices should be configured to use the "correct" side of the orderbook to allow realistic pricing detection.
-Assuming both entry and exits are using market orders, a configuration similar to the following must be used
+Assuming both buy and sell are using market orders, a configuration similar to the following might be used

 ``` jsonc
  "order_types": {
-    "entry": "market",
-    "exit": "market"
+    "buy": "market",
+    "sell": "market"
    // ...
  },
-  "entry_pricing": {
-    "price_side": "other",
+  "bid_strategy": {
+    "price_side": "ask",
    // ...
  },
-  "exit_pricing":{
-    "price_side": "other",
+  "ask_strategy":{
+    "price_side": "bid",
    // ...
  },
 ```
--- a/docs/includes/protections.md
+++ b/docs/includes/protections.md
@ -48,10 +48,6 @@ If `trade_limit` or more trades resulted in stoploss, trading will stop for `sto

 This applies across all pairs, unless `only_per_pair` is set to true, which will then only look at one pair at a time.

-Similarly, this protection will by default look at all trades (long and short). For futures bots, setting `only_per_side` will make the bot only consider one side, and will then only lock this one side, allowing for example shorts to continue after a series of long stoplosses.
-
-`required_profit` will determine the required relative profit (or loss) for stoplosses to consider. This should normally not be set and defaults to 0.0 - which means all losing stoplosses will be triggering a block.
-
 The below example stops trading for all pairs for 4 candles after the last trade if the bot hit stoploss 4 times within the last 24 candles.

 ``` python
@ -63,9 +59,7 @@ def protections(self):
            "lookback_period_candles": 24,
            "trade_limit": 4,
            "stop_duration_candles": 4,
-            "required_profit": 0.0,
-            "only_per_pair": False,
-            "only_per_side": False
+            "only_per_pair": False
        }
    ]
 ```
@ -99,8 +93,6 @@ def protections(self):
 `LowProfitPairs` uses all trades for a pair within `lookback_period` in minutes (or in candles when using `lookback_period_candles`) to determine the overall profit ratio.
 If that ratio is below `required_profit`, that pair will be locked for `stop_duration` in minutes (or in candles when using `stop_duration_candles`).

-For futures bots, setting `only_per_side` will make the bot only consider one side, and will then only lock this one side, allowing for example shorts to continue after a series of long losses.
-
 The below example will stop trading a pair for 60 minutes if the pair does not have a required profit of 2% (and a minimum of 2 trades) within the last 6 candles.

 ``` python
@ -112,8 +104,7 @@ def protections(self):
            "lookback_period_candles": 6,
            "trade_limit": 2,
            "stop_duration": 60,
-            "required_profit": 0.02,
-            "only_per_pair": False,
+            "required_profit": 0.02
        }
    ]
 ```
@ -149,7 +140,7 @@ The below example assumes a timeframe of 1 hour:
 * Locks each pair after selling for an additional 5 candles (`CooldownPeriod`), giving other pairs a chance to get filled.
 * Stops trading for 4 hours (`4 * 1h candles`) if the last 2 days (`48 * 1h candles`) had 20 trades, which caused a max-drawdown of more than 20%. (`MaxDrawdown`).
 * Stops trading if more than 4 stoploss occur for all pairs within a 1 day (`24 * 1h candles`) limit (`StoplossGuard`).
-* Locks all pairs that had 2 Trades within the last 6 hours (`6 * 1h candles`) with a combined profit ratio of below 0.02 (<2%) (`LowProfitPairs`).
+* Locks all pairs that had 4 Trades within the last 6 hours (`6 * 1h candles`) with a combined profit ratio of below 0.02 (<2%) (`LowProfitPairs`).
 * Locks all pairs for 2 candles that had a profit of below 0.01 (<1%) within the last 24h (`24 * 1h candles`), a minimum of 4 trades.

 ``` python
--- a/docs/index.md
+++ b/docs/index.md
@ -1,7 +1,6 @@
 ![freqtrade](assets/freqtrade_poweredby.svg)

 [![Freqtrade CI](https://github.com/freqtrade/freqtrade/workflows/Freqtrade%20CI/badge.svg)](https://github.com/freqtrade/freqtrade/actions/)
-[![DOI](https://joss.theoj.org/papers/10.21105/joss.04864/status.svg)](https://doi.org/10.21105/joss.04864)
 [![Coverage Status](https://coveralls.io/repos/github/freqtrade/freqtrade/badge.svg?branch=develop&service=github)](https://coveralls.io/github/freqtrade/freqtrade?branch=develop)
 [![Maintainability](https://api.codeclimate.com/v1/badges/5737e6d668200b7518ff/maintainability)](https://codeclimate.com/github/freqtrade/freqtrade/maintainability)

@ -23,6 +22,10 @@ Freqtrade is a free and open source crypto trading bot written in Python. It is

 ![freqtrade screenshot](assets/freqtrade-screenshot.png)

+## Sponsored promotion
+
+[![tokenbot-promo](assets/TokenBot-Freqtrade-banner.png)](https://tokenbot.com/?utm_source=github&utm_medium=freqtrade&utm_campaign=algodevs)
+
 ## Features

 - Develop your Strategy: Write your strategy in python, using [pandas](https://pandas.pydata.org/). Example strategies to inspire you are available in the [strategy repository](https://github.com/freqtrade/freqtrade-strategies).
@ -33,29 +36,20 @@ Freqtrade is a free and open source crypto trading bot written in Python. It is
 - Run: Test your strategy with simulated money (Dry-Run mode) or deploy it with real money (Live-Trade mode).
 - Run using Edge (optional module): The concept is to find the best historical [trade expectancy](edge.md#expectancy) by markets based on variation of the stop-loss and then allow/reject markets to trade. The sizing of the trade is based on a risk of a percentage of your capital.
 - Control/Monitor: Use Telegram or a WebUI (start/stop the bot, show profit/loss, daily summary, current open trades results, etc.).
- Analyze: Further analysis can be performed on either Backtesting data or Freqtrade trading history (SQL database), including automated standard plots, and methods to load the data into [interactive environments](data-analysis.md).
+- Analyse: Further analysis can be performed on either Backtesting data or Freqtrade trading history (SQL database), including automated standard plots, and methods to load the data into [interactive environments](data-analysis.md).

 ## Supported exchange marketplaces

 Please read the [exchange specific notes](exchanges.md) to learn about eventual, special configurations needed for each exchange.

- [X] [Binance](https://www.binance.com/)
+- [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] [Gate.io](https://www.gate.io/ref/6266643)
- [X] [Huobi](http://huobi.com/)
 - [X] [Kraken](https://kraken.com/)
- [X] [OKX](https://okx.com/) (Former OKEX)
+- [X] [OKX](https://www.okx.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)_

-### Supported Futures Exchanges (experimental)
-
- [X] [Binance](https://www.binance.com/)
- [X] [Gate.io](https://www.gate.io/ref/6266643)
- [X] [OKX](https://okx.com/)
- [X] [Bybit](https://bybit.com/)
-
-Please make sure to read the [exchange specific notes](exchanges.md), as well as the [trading with leverage](leverage.md) documentation before diving in.
-
 ### Community tested

 Exchanges confirmed working by the community:
--- a/docs/installation.md
+++ b/docs/installation.md
@ -30,12 +30,6 @@ The easiest way to install and run Freqtrade is to clone the bot Github reposito
 !!! Warning "Up-to-date clock"
    The clock on the system running the bot must be accurate, synchronized to a NTP server frequently enough to avoid problems with communication to the exchanges.

-!!! Error "Running setup.py install for gym did not run successfully."
-    If you get an error related with gym we suggest you to downgrade setuptools it to version 65.5.0 you can do it with the following command:
-    ```bash
-    pip install setuptools==65.5.0
-    ```
-
 ------

 ## Requirements
@ -290,8 +284,10 @@ cd freqtrade

 #### Freqtrade install: Conda Environment

+Prepare conda-freqtrade environment, using file `environment.yml`, which exist in main freqtrade directory
+
 ```bash
-conda create --name freqtrade python=3.10
+conda env create -n freqtrade-conda -f environment.yml
 ```

 !!! Note "Creating Conda Environment"
@ -300,9 +296,12 @@ conda create --name freqtrade python=3.10
    ```bash
    # choose your own packages
    conda env create -n [name of the environment] [python version] [packages]
+
+    # point to file with packages
+    conda env create -n [name of the environment] -f [file]
    ```

-#### Enter/exit freqtrade environment
+#### Enter/exit freqtrade-conda environment

 To check available environments, type

@ -314,7 +313,7 @@ Enter installed environment

 ```bash
 # enter conda environment
-conda activate freqtrade
+conda activate freqtrade-conda

 # exit conda environment - don't do it now
 conda deactivate
@ -324,20 +323,9 @@ Install last python dependencies with pip

 ```bash
 python3 -m pip install --upgrade pip
-python3 -m pip install -r requirements.txt
 python3 -m pip install -e .
 ```

-Patch conda libta-lib (Linux only)
-
-```bash
-# Ensure that the environment is active!
-conda activate freqtrade
-
-cd build_helpers
-bash install_ta-lib.sh ${CONDA_PREFIX} nosudo
-```
-
 ### Congratulations

 [You are ready](#you-are-ready), and run the bot
@ -351,8 +339,8 @@ conda env list
 # activate base environment
 conda activate

-# activate freqtrade environment
-conda activate freqtrade
+# activate freqtrade-conda environment
+conda activate freqtrade-conda

 #deactivate any conda environments
 conda deactivate                              
--- a/docs/javascripts/config.js
+++ b/docs/javascripts/config.js
@ -9,4 +9,4 @@ window.MathJax = {
    ignoreHtmlClass: ".*|",
    processHtmlClass: "arithmatex"
  }
-};
+};
--- a/docs/leverage.md
+++ b/docs/leverage.md
@ -1,143 +0,0 @@
-# Trading with Leverage
-
-!!! Warning "Beta feature"
-    This feature is still in it's testing phase. Should you notice something you think is wrong please let us know via Discord or via Github Issue.
-
-!!! Note "Multiple bots on one account"
-    You can't run 2 bots on the same account with leverage. For leveraged / margin trading, freqtrade assumes it's the only user of the account, and all liquidation levels are calculated based on this assumption.
-
-!!! Danger "Trading with leverage is very risky"
-    Do not trade with a leverage > 1 using a strategy that hasn't shown positive results in a live run using the spot market. Check the stoploss of your strategy. With a leverage of 2, a stoploss of 0.5 (50%) would be too low, and these trades would be liquidated before reaching that stoploss.
-    We do not assume any responsibility for eventual losses that occur from using this software or this mode.
-
-    Please only use advanced trading modes when you know how freqtrade (and your strategy) works.
-    Also, never risk more than what you can afford to lose.
-
-If you already have an existing strategy, please read the [strategy migration guide](strategy_migration.md#strategy-migration-between-v2-and-v3) to migrate your strategy from a freqtrade v2 strategy, to strategy of version 3 which can short and trade futures.
-
-## Shorting
-
-Shorting is not possible when trading with [`trading_mode`](#understand-tradingmode) set to `spot`. To short trade, `trading_mode` must be set to `margin`(currently unavailable) or [`futures`](#futures), with [`margin_mode`](#margin-mode) set to `cross`(currently unavailable) or [`isolated`](#isolated-margin-mode)
-
-For a strategy to short, the strategy class must set the class variable `can_short = True`
-
-Please read [strategy customization](strategy-customization.md#entry-signal-rules) for instructions on how to set signals to enter and exit short trades.
-
-## Understand `trading_mode`
-
-The possible values are: `spot` (default), `margin`(*Currently unavailable*) or `futures`.
-
-### Spot
-
-Regular trading mode (low risk)
-
- Long trades only (No short trades).
- No leverage.
- No Liquidation.
- Profits gained/lost are equal to the change in value of the assets (minus trading fees).
-
-### Leverage trading modes
-
-With leverage, a trader borrows capital from the exchange. The capital must be re-payed fully to the exchange (potentially with interest), and the trader keeps any profits, or pays any losses, from any trades made using the borrowed capital.
-
-Because the capital must always be re-payed, exchanges will **liquidate** (forcefully sell the traders assets) a trade made using borrowed capital when the total value of assets in the leverage account drops to a certain point (a point where the total value of losses is less than the value of the collateral that the trader actually owns in the leverage account), in order to ensure that the trader has enough capital to pay the borrowed assets back to the exchange. The exchange will also charge a **liquidation fee**, adding to the traders losses.
-
-For this reason, **DO NOT TRADE WITH LEVERAGE IF YOU DON'T KNOW EXACTLY WHAT YOUR DOING. LEVERAGE TRADING IS HIGH RISK, AND CAN RESULT IN THE VALUE OF YOUR ASSETS DROPPING TO 0 VERY QUICKLY, WITH NO CHANCE OF INCREASING IN VALUE AGAIN.**
-
-#### Margin (currently unavailable)
-
-Trading occurs on the spot market, but the exchange lends currency to you in an amount equal to the chosen leverage. You pay the amount lent to you back to the exchange with interest, and your profits/losses are multiplied by the leverage specified.
-
-#### Futures
-
-Perpetual swaps (also known as Perpetual Futures) are contracts traded at a price that is closely tied to the underlying asset they are based off of (ex.). You are not trading the actual asset but instead are trading a derivative contract. Perpetual swap contracts can last indefinitely, in contrast to futures or option contracts.
-
-In addition to the gains/losses from the change in price of the futures contract, traders also exchange _funding fees_, which are gains/losses worth an amount that is derived from the difference in price between the futures contract and the underlying asset. The difference in price between a futures contract and the underlying asset varies between exchanges.
-
-To trade in futures markets, you'll have to set `trading_mode` to "futures".
-You will also have to pick a "margin mode" (explanation below) - with freqtrade currently only supporting isolated margin.
-
-``` json
-"trading_mode": "futures",
-"margin_mode": "isolated"
-```
-
-##### Pair namings
-
-Freqtrade follows the [ccxt naming conventions for futures](https://docs.ccxt.com/en/latest/manual.html?#perpetual-swap-perpetual-future).
-A futures pair will therefore have the naming of `base/quote:settle` (e.g. `ETH/USDT:USDT`).
-
-### Margin mode
-
-On top of `trading_mode` - you will also have to configure your `margin_mode`.
-While freqtrade currently only supports one margin mode, this will change, and by configuring it now you're all set for future updates.
-
-The possible values are: `isolated`, or `cross`(*currently unavailable*).
-
-#### Isolated margin mode
-
-Each market(trading pair), keeps collateral in a separate account
-
-``` json
-"margin_mode": "isolated"
-```
-
-#### Cross margin mode (currently unavailable)
-
-One account is used to share collateral between markets (trading pairs). Margin is taken from total account balance to avoid liquidation when needed.
-
-``` json
-"margin_mode": "cross"
-```
-
-Please read the [exchange specific notes](exchanges.md) for exchanges that support this mode and how they differ.
-
-## Set leverage to use
-
-Different strategies and risk profiles will require different levels of leverage.
-While you could configure one static leverage value - freqtrade offers you the flexibility to adjust this via [strategy leverage callback](strategy-callbacks.md#leverage-callback) - which allows you to use different leverages by pair, or based on some other factor benefitting your strategy result.
-
-If not implemented, leverage defaults to 1x (no leverage).
-
-!!! Warning
-    Higher leverage also equals higher risk - be sure you fully understand the implications of using leverage!
-
-## Understand `liquidation_buffer`
-
-*Defaults to `0.05`*
-
-A ratio specifying how large of a safety net to place between the liquidation price and the stoploss to prevent a position from reaching the liquidation price.
-This artificial liquidation price is calculated as:
-
-`freqtrade_liquidation_price = liquidation_price ± (abs(open_rate - liquidation_price) * liquidation_buffer)`
-
- `±` = `+` for long trades
- `±` = `-` for short trades
-
-Possible values are any floats between 0.0 and 0.99
-
-**ex:** If a trade is entered at a price of 10 coin/USDT, and the liquidation price of this trade is 8 coin/USDT, then with `liquidation_buffer` set to `0.05` the minimum stoploss for this trade would be $8 + ((10 - 8) * 0.05) = 8 + 0.1 = 8.1$
-
-!!! Danger "A `liquidation_buffer` of 0.0, or a low `liquidation_buffer` is likely to result in liquidations, and liquidation fees"
-    Currently Freqtrade is able to calculate liquidation prices, but does not calculate liquidation fees. Setting your `liquidation_buffer` to 0.0, or using a low `liquidation_buffer` could result in your positions being liquidated. Freqtrade does not track liquidation fees, so liquidations will result in inaccurate profit/loss results for your bot. If you use a low `liquidation_buffer`, it is recommended to use `stoploss_on_exchange` if your exchange supports this.
-
-## Unavailable funding rates
-
-For futures data, exchanges commonly provide the futures candles, the marks, and the funding rates. However, it is common that whilst candles and marks might be available, the funding rates are not. This can affect backtesting timeranges, i.e. you may only be able to test recent timeranges and not earlier, experiencing the `No data found. Terminating.` error. To get around this, add the `futures_funding_rate` config option as listed in [configuration.md](configuration.md), and it is recommended that you set this to `0`, unless you know a given specific funding rate for your pair, exchange and timerange. Setting this to anything other than `0` can have drastic effects on your profit calculations within strategy, e.g. within the `custom_exit`, `custom_stoploss`, etc functions.
-
-!!! Warning "This will mean your backtests are inaccurate."
-    This will not overwrite funding rates that are available from the exchange, but bear in mind that setting a false funding rate will mean backtesting results will be inaccurate for historical timeranges where funding rates are not available.
-
-### Developer
-
-#### Margin mode
-
-For shorts, the currency which pays the interest fee for the `borrowed` currency is purchased at the same time of the closing trade (This means that the amount purchased in short closing trades is greater than the amount sold in short opening trades).
-
-For longs, the currency which pays the interest fee for the `borrowed` will already be owned by the user and does not need to be purchased. The interest is subtracted from the `close_value` of the trade.
-
-All Fees are included in `current_profit` calculations during the trade.
-
-#### Futures mode
-
-Funding fees are either added or subtracted from the total amount of a trade
--- a/docs/overrides/main.html
+++ b/docs/overrides/main.html
@ -11,6 +11,9 @@
  {% endif %}
  <div class="md-sidebar md-sidebar--primary" data-md-component="sidebar" data-md-type="navigation" {{ hidden }}>
    <div class="md-sidebar__scrollwrap">
+      <div id="widget-wrapper">
+
+      </div>
      <div class="md-sidebar__inner">
        {% include "partials/nav.html" %}
      </div>
@ -41,4 +44,25 @@
    <script src="https://code.jquery.com/jquery-3.4.1.min.js"
      integrity="sha256-CSXorXvZcTkaix6Yvo6HppcZGetbYMGWSFlBw8HfCJo=" crossorigin="anonymous"></script>

+    <!-- Load binance SDK -->
+    <script async defer src="https://public.bnbstatic.com/static/js/broker-sdk/broker-sdk@1.0.0.min.js"></script>
+
+    <script>
+      window.onload = function () {
+        var sidebar = document.getElementById('widget-wrapper')
+        var newDiv = document.createElement("div");
+        newDiv.id = "widget";
+        try {
+          sidebar.prepend(newDiv);
+
+          window.binanceBrokerPortalSdk.initBrokerSDK('#widget', {
+            apiHost: 'https://www.binance.com',
+            brokerId: 'R4BD3S82',
+            slideTime: 4e4,
+          });
+        } catch(err) {
+          console.log(err)
+        }
+      }
+    </script>
 {% endblock %}
--- a/docs/plotting.md
+++ b/docs/plotting.md
@ -14,7 +14,7 @@ pip install -U -r requirements-plot.txt

 The `freqtrade plot-dataframe` subcommand shows an interactive graph with three subplots:

-* Main plot with candlesticks and indicators following price (sma/ema)
+* Main plot with candlestics and indicators following price (sma/ema)
 * Volume bars
 * Additional indicators as specified by `--indicators2`

@ -65,7 +65,7 @@ optional arguments:
                        _today.json`
  --timerange TIMERANGE
                        Specify what timerange of data to use.
-  -i TIMEFRAME, --timeframe TIMEFRAME
+  -i TIMEFRAME, --timeframe TIMEFRAME, --ticker-interval TIMEFRAME
                        Specify timeframe (`1m`, `5m`, `30m`, `1h`, `1d`).
  --no-trades           Skip using trades from backtesting file and DB.

@ -96,7 +96,7 @@ Strategy arguments:
 Example:

 ``` bash
-freqtrade plot-dataframe -p BTC/ETH --strategy AwesomeStrategy
+freqtrade plot-dataframe -p BTC/ETH
 ```

 The `-p/--pairs` argument can be used to specify pairs you would like to plot.
@ -107,6 +107,9 @@ The `-p/--pairs` argument can be used to specify pairs you would like to plot.
 Specify custom indicators.
 Use `--indicators1` for the main plot and `--indicators2` for the subplot below (if values are in a different range than prices).

+!!! Tip
+    You will almost certainly want to specify a custom strategy! This can be done by adding `-s Classname` / `--strategy ClassName` to the command.
+
 ``` bash
 freqtrade plot-dataframe --strategy AwesomeStrategy -p BTC/ETH --indicators1 sma ema --indicators2 macd
 ```
@ -327,7 +330,7 @@ optional arguments:
  --trade-source {DB,file}
                        Specify the source for trades (Can be DB or file
                        (backtest file)) Default: file
-  -i TIMEFRAME, --timeframe TIMEFRAME
+  -i TIMEFRAME, --timeframe TIMEFRAME, --ticker-interval TIMEFRAME
                        Specify timeframe (`1m`, `5m`, `30m`, `1h`, `1d`).
  --auto-open           Automatically open generated plot.

--- a/docs/producer-consumer.md
+++ b/docs/producer-consumer.md
@ -1,165 +0,0 @@
-# Producer / Consumer mode
-
-freqtrade provides a mechanism whereby an instance (also called `consumer`) may listen to messages from an upstream freqtrade instance (also called `producer`) using the message websocket. Mainly, `analyzed_df` and `whitelist` messages. This allows the reuse of computed indicators (and signals) for pairs in multiple bots without needing to compute them multiple times.
-
-See [Message Websocket](rest-api.md#message-websocket) in the Rest API docs for setting up the `api_server` configuration for your message websocket (this will be your producer).
-
-!!! Note
-    We strongly recommend to set `ws_token` to something random and known only to yourself to avoid unauthorized access to your bot.
-
-## Configuration
-
-Enable subscribing to an instance by adding the `external_message_consumer` section to the consumer's config file.
-
-```json
-{
-    //...
-   "external_message_consumer": {
-        "enabled": true,
-        "producers": [
-            {
-                "name": "default", // This can be any name you'd like, default is "default"
-                "host": "127.0.0.1", // The host from your producer's api_server config
-                "port": 8080, // The port from your producer's api_server config
-                "secure": false, // Use a secure websockets connection, default false
-                "ws_token": "sercet_Ws_t0ken" // The ws_token from your producer's api_server config
-            }
-        ],
-        // The following configurations are optional, and usually not required
-        // "wait_timeout": 300,
-        // "ping_timeout": 10,
-        // "sleep_time": 10,
-        // "remove_entry_exit_signals": false,
-        // "message_size_limit": 8
-    }
-    //...
-}
-```
-
-|  Parameter | Description |
-|------------|-------------|
-| `enabled` | **Required.** Enable consumer mode. If set to false, all other settings in this section are ignored.<br>*Defaults to `false`.*<br> **Datatype:** boolean .
-| `producers` | **Required.** List of producers <br> **Datatype:** Array.
-| `producers.name` | **Required.** Name of this producer. This name must be used in calls to `get_producer_pairs()` and `get_producer_df()` if more than one producer is used.<br> **Datatype:** string
-| `producers.host` | **Required.** The hostname or IP address from your producer.<br> **Datatype:** string
-| `producers.port` | **Required.** The port matching the above host.<br>*Defaults to `8080`.*<br> **Datatype:** Integer
-| `producers.secure` | **Optional.**  Use ssl in websockets connection. Default False.<br> **Datatype:** string
-| `producers.ws_token` | **Required.**  `ws_token` as configured on the producer.<br> **Datatype:** string
-| | **Optional settings**
-| `wait_timeout` | Timeout until we ping again if no message is received. <br>*Defaults to `300`.*<br> **Datatype:** Integer - in seconds.
-| `ping_timeout` | Ping timeout <br>*Defaults to `10`.*<br> **Datatype:** Integer - in seconds.
-| `sleep_time` | Sleep time before retrying to connect.<br>*Defaults to `10`.*<br> **Datatype:** Integer - in seconds.
-| `remove_entry_exit_signals` | Remove signal columns from the dataframe (set them to 0) on dataframe receipt.<br>*Defaults to `False`.*<br> **Datatype:** Boolean.
-| `message_size_limit` | Size limit per message<br>*Defaults to `8`.*<br> **Datatype:** Integer - Megabytes.
-
-Instead of (or as well as) calculating indicators in `populate_indicators()` the follower instance listens on the connection to a producer instance's messages (or multiple producer instances in advanced configurations) and requests the producer's most recently analyzed dataframes for each pair in the active whitelist.
-
-A consumer instance will then have a full copy of the analyzed dataframes without the need to calculate them itself.
-
-## Examples
-
-### Example - Producer Strategy
-
-A simple strategy with multiple indicators. No special considerations are required in the strategy itself.
-
-```py
-class ProducerStrategy(IStrategy):
-    #...
-    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
-        """
-        Calculate indicators in the standard freqtrade way which can then be broadcast to other instances
-        """
-        dataframe['rsi'] = ta.RSI(dataframe)
-        bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
-        dataframe['bb_lowerband'] = bollinger['lower']
-        dataframe['bb_middleband'] = bollinger['mid']
-        dataframe['bb_upperband'] = bollinger['upper']
-        dataframe['tema'] = ta.TEMA(dataframe, timeperiod=9)
-
-        return dataframe
-
-    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
-        """
-        Populates the entry signal for the given dataframe
-        """
-        dataframe.loc[
-            (
-                (qtpylib.crossed_above(dataframe['rsi'], self.buy_rsi.value)) &
-                (dataframe['tema'] <= dataframe['bb_middleband']) &
-                (dataframe['tema'] > dataframe['tema'].shift(1)) &
-                (dataframe['volume'] > 0)
-            ),
-            'enter_long'] = 1
-
-        return dataframe
-```
-
-!!! Tip "FreqAI"
-    You can use this to setup [FreqAI](freqai.md) on a powerful machine, while you run consumers on simple machines like raspberries, which can interpret the signals generated from the producer in different ways.
-
-
-### Example - Consumer Strategy
-
-A logically equivalent strategy which calculates no indicators itself, but will have the same analyzed dataframes available to make trading decisions based on the indicators calculated in the producer. In this example the consumer has the same entry criteria, however this is not necessary. The consumer may use different logic to enter/exit trades, and only use the indicators as specified.
-
-```py
-class ConsumerStrategy(IStrategy):
-    #...
-    process_only_new_candles = False # required for consumers
-
-    _columns_to_expect = ['rsi_default', 'tema_default', 'bb_middleband_default']
-
-    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
-        """
-        Use the websocket api to get pre-populated indicators from another freqtrade instance.
-        Use `self.dp.get_producer_df(pair)` to get the dataframe
-        """
-        pair = metadata['pair']
-        timeframe = self.timeframe
-
-        producer_pairs = self.dp.get_producer_pairs()
-        # You can specify which producer to get pairs from via:
-        # self.dp.get_producer_pairs("my_other_producer")
-
-        # This func returns the analyzed dataframe, and when it was analyzed
-        producer_dataframe, _ = self.dp.get_producer_df(pair)
-        # You can get other data if the producer makes it available:
-        # self.dp.get_producer_df(
-        #   pair,
-        #   timeframe="1h",
-        #   candle_type=CandleType.SPOT,
-        #   producer_name="my_other_producer"
-        # )
-
-        if not producer_dataframe.empty:
-            # If you plan on passing the producer's entry/exit signal directly,
-            # specify ffill=False or it will have unintended results
-            merged_dataframe = merge_informative_pair(dataframe, producer_dataframe,
-                                                      timeframe, timeframe,
-                                                      append_timeframe=False,
-                                                      suffix="default")
-            return merged_dataframe
-        else:
-            dataframe[self._columns_to_expect] = 0
-
-        return dataframe
-
-    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
-        """
-        Populates the entry signal for the given dataframe
-        """
-        # Use the dataframe columns as if we calculated them ourselves
-        dataframe.loc[
-            (
-                (qtpylib.crossed_above(dataframe['rsi_default'], self.buy_rsi.value)) &
-                (dataframe['tema_default'] <= dataframe['bb_middleband_default']) &
-                (dataframe['tema_default'] > dataframe['tema_default'].shift(1)) &
-                (dataframe['volume'] > 0)
-            ),
-            'enter_long'] = 1
-
-        return dataframe
-```
-
-!!! Tip "Using upstream signals"
-    By setting `remove_entry_exit_signals=false`, you can also use the producer's signals directly. They should be available as `enter_long_default` (assuming `suffix="default"` was used) - and can be used as either signal directly, or as additional indicator.
--- a/docs/requirements-docs.txt
+++ b/docs/requirements-docs.txt
@ -1,6 +1,4 @@
-markdown==3.3.7
-mkdocs==1.4.2
-mkdocs-material==9.1.6
-mdx_truly_sane_lists==1.3
-pymdown-extensions==9.11
-jinja2==3.1.2
+mkdocs==1.2.3
+mkdocs-material==8.2.1
+mdx_truly_sane_lists==1.2
+pymdown-extensions==9.2
--- a/docs/rest-api.md
+++ b/docs/rest-api.md
@ -9,6 +9,9 @@ This same command can also be used to update freqUI, should there be a new relea

 Once the bot is started in trade / dry-run mode (with `freqtrade trade`) - the UI will be available under the configured port below (usually `http://127.0.0.1:8080`).

+!!! info "Alpha release"
+    FreqUI is still considered an alpha release - if you encounter bugs or inconsistencies please open a [FreqUI issue](https://github.com/freqtrade/frequi/issues/new/choose).
+
 !!! Note "developers"
    Developers should not use this method, but instead use the method described in the [freqUI repository](https://github.com/freqtrade/frequi) to get the source-code of freqUI.

@ -28,8 +31,7 @@ Sample configuration:
        "jwt_secret_key": "somethingrandom",
        "CORS_origins": [],
        "username": "Freqtrader",
-        "password": "SuperSecret1!",
-        "ws_token": "sercet_Ws_t0ken"
+        "password": "SuperSecret1!"
    },
 ```

@ -64,7 +66,7 @@ secrets.token_hex()

 !!! Danger "Password selection"
    Please make sure to select a very strong, unique password to protect your bot from unauthorized access.
-    Also change `jwt_secret_key` to something random (no need to remember this, but it'll be used to encrypt your session, so it better be something unique!).
+    Also change `jwt_secret_key` to something random (no need to remember this, but it'll be used to encrypt your session, so it better be something unique!). 

 ### Configuration with docker

@ -91,6 +93,7 @@ Make sure that the following 2 lines are available in your docker-compose file:
 !!! Danger "Security warning"
    By using `8080:8080` in the docker port mapping, the API will be available to everyone connecting to the server under the correct port, so others may be able to control your bot.

+
 ## Rest API

 ### Consuming the API
@ -142,10 +145,9 @@ python3 scripts/rest_client.py --config rest_config.json <command> [optional par
 | `locks` | Displays currently locked pairs.
 | `delete_lock <lock_id>` | Deletes (disables) the lock by id.
 | `profit` | Display a summary of your profit/loss from close trades and some stats about your performance.
-| `forceexit <trade_id>` | Instantly exits the given trade  (Ignoring `minimum_roi`).
-| `forceexit all` | Instantly exits all open trades (Ignoring `minimum_roi`).
-| `forceenter <pair> [rate]` | Instantly enters the given pair. Rate is optional. (`force_entry_enable` must be set to True)
-| `forceenter <pair> <side> [rate]` | Instantly longs or shorts the given pair. Rate is optional. (`force_entry_enable` must be set to True)
+| `forcesell <trade_id>` | Instantly sells the given trade  (Ignoring `minimum_roi`).
+| `forcesell all` | Instantly sells all open trades (Ignoring `minimum_roi`).
+| `forcebuy <pair> [rate]` | Instantly buys the given pair. Rate is optional. (`forcebuy_enable` must be set to True)
 | `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).
@ -160,8 +162,6 @@ python3 scripts/rest_client.py --config rest_config.json <command> [optional par
 | `strategy <strategy>` | Get specific Strategy content. **Alpha**
 | `available_pairs` | List available backtest data. **Alpha**
 | `version` | Show version.
-| `sysinfo` | Show information about the system load.
-| `health` | Show bot health (last bot loop).

 !!! Warning "Alpha status"
    Endpoints labeled with *Alpha status* above may change at any time without notice.
@ -189,11 +189,6 @@ blacklist

        :param add: List of coins to add (example: "BNB/BTC")

-cancel_open_order
-	Cancel open order for trade.
-
-        :param trade_id: Cancels open orders for this trade.
-
 count
 	Return the amount of open trades.

@ -220,22 +215,10 @@ forcebuy
        :param pair: Pair to buy (ETH/BTC)
        :param price: Optional - price to buy

-forceenter
-	Force entering a trade
-
-        :param pair: Pair to buy (ETH/BTC)
-        :param side: 'long' or 'short'
-        :param price: Optional - price to buy
-
-forceexit
-	Force-exit a trade.
+forcesell
+	Force-sell a trade.

        :param tradeid: Id of the trade (can be received via status command)
-        :param ordertype: Order type to use (must be market or limit)
-        :param amount: Amount to sell. Full sell if not given
-
-health
-	Provides a quick health check of the running bot.

 locks
 	Return current locks
@ -276,6 +259,7 @@ reload_config
 	Reload configuration.

 show_config
+	
        Returns part of the configuration, relevant for trading operations.

 start
@ -301,9 +285,6 @@ strategy

        :param strategy: Strategy class name

-sysinfo
-	Provides system information (CPU, RAM usage)
-
 trade
 	Return specific trade

@ -320,119 +301,12 @@ version

 whitelist
 	Show the current whitelist.
-
-
 ```

-### Message WebSocket
-
-The API Server includes a websocket endpoint for subscribing to RPC messages from the freqtrade Bot.
-This can be used to consume real-time data from your bot, such as entry/exit fill messages, whitelist changes, populated indicators for pairs, and more.
-
-This is also used to setup [Producer/Consumer mode](producer-consumer.md) in Freqtrade.
-
-Assuming your rest API is set to `127.0.0.1` on port `8080`, the endpoint is available at `http://localhost:8080/api/v1/message/ws`.
-
-To access the websocket endpoint, the `ws_token` is required as a query parameter in the endpoint URL.
-
-To generate a safe `ws_token` you can run the following code:
-
-``` python
->>> import secrets
->>> secrets.token_urlsafe(25)
-'hZ-y58LXyX_HZ8O1cJzVyN6ePWrLpNQv4Q'
-```
-
-You would then add that token under `ws_token` in your `api_server` config. Like so:
-
-``` json
-"api_server": {
-    "enabled": true,
-    "listen_ip_address": "127.0.0.1",
-    "listen_port": 8080,
-    "verbosity": "error",
-    "enable_openapi": false,
-    "jwt_secret_key": "somethingrandom",
-    "CORS_origins": [],
-    "username": "Freqtrader",
-    "password": "SuperSecret1!",
-    "ws_token": "hZ-y58LXyX_HZ8O1cJzVyN6ePWrLpNQv4Q" // <-----
-},
-```
-
-You can now connect to the endpoint at `http://localhost:8080/api/v1/message/ws?token=hZ-y58LXyX_HZ8O1cJzVyN6ePWrLpNQv4Q`.
-
-!!! Danger "Reuse of example tokens"
-    Please do not use the above example token. To make sure you are secure, generate a completely new token.
-
-#### Using the WebSocket
-
-Once connected to the WebSocket, the bot will broadcast RPC messages to anyone who is subscribed to them. To subscribe to a list of messages, you must send a JSON request through the WebSocket like the one below. The `data` key must be a list of message type strings.
-
-``` json
-{
-  "type": "subscribe",
-  "data": ["whitelist", "analyzed_df"] // A list of string message types
-}
-```
-
-For a list of message types, please refer to the RPCMessageType enum in `freqtrade/enums/rpcmessagetype.py`
-
-Now anytime those types of RPC messages are sent in the bot, you will receive them through the WebSocket as long as the connection is active. They typically take the same form as the request:
-
-``` json
-{
-  "type": "analyzed_df",
-  "data": {
-      "key": ["NEO/BTC", "5m", "spot"],
-      "df": {}, // The dataframe
-      "la": "2022-09-08 22:14:41.457786+00:00"
-  }
-}
-```
-
-#### Reverse Proxy setup
-
-When using [Nginx](https://nginx.org/en/docs/), the following configuration is required for WebSockets to work (Note this configuration is incomplete, it's missing some information and can not be used as is):
-
-Please make sure to replace `<freqtrade_listen_ip>` (and the subsequent port) with the IP and Port matching your configuration/setup.
-
-```
-http {
-    map $http_upgrade $connection_upgrade {
-        default upgrade;
-        '' close;
-    }
-
-    #...
-
-    server {
-        #...
-
-        location / {
-            proxy_http_version 1.1;
-            proxy_pass http://<freqtrade_listen_ip>:8080;
-            proxy_set_header Upgrade $http_upgrade;
-            proxy_set_header Connection $connection_upgrade;
-            proxy_set_header Host $host;
-        }
-    }
-}
-```
-
-To properly configure your reverse proxy (securely), please consult it's documentation for proxying websockets.
-
- **Traefik**: Traefik supports websockets out of the box, see the [documentation](https://doc.traefik.io/traefik/)
- **Caddy**: Caddy v2 supports websockets out of the box, see the [documentation](https://caddyserver.com/docs/v2-upgrade#proxy)
-
-!!! Tip "SSL certificates"
-    You can use tools like certbot to setup ssl certificates to access your bot's UI through encrypted connection by using any fo the above reverse proxies.
-    While this will protect your data in transit, we do not recommend to run the freqtrade API outside of your private network (VPN, SSH tunnel).
-
 ### OpenAPI interface

 To enable the builtin openAPI interface (Swagger UI), specify `"enable_openapi": true` in the api_server configuration.
-This will enable the Swagger UI at the `/docs` endpoint. By default, that's running at http://localhost:8080/docs - but it'll depend on your settings.
+This will enable the Swagger UI at the `/docs` endpoint. By default, that's running at http://localhost:8080/docs/ - but it'll depend on your settings.

 ### Advanced API usage using JWT tokens

--- a/docs/sandbox-testing.md
+++ b/docs/sandbox-testing.md
@ -104,16 +104,16 @@ To mitigate this, you can try to match the first order on the opposite orderbook

 ``` jsonc
  "order_types": {
-    "entry": "limit",
-    "exit": "limit"
+    "buy": "limit",
+    "sell": "limit"
    // ...
  },
-  "entry_pricing": {
-    "price_side": "other",
+  "bid_strategy": {
+    "price_side": "ask",
    // ...
  },
-  "exit_pricing":{
-    "price_side": "other",
+  "ask_strategy":{
+    "price_side": "bid",
    // ...
  },
  ```
--- a/docs/sql_cheatsheet.md
+++ b/docs/sql_cheatsheet.md
@ -13,12 +13,12 @@ Feel free to use a visual Database editor like SqliteBrowser if you feel more co
 sudo apt-get install sqlite3
 ```

-### Using sqlite3 via docker
+### Using sqlite3 via docker-compose

 The freqtrade docker image does contain sqlite3, so you can edit the database without having to install anything on the host system.

 ``` bash
-docker compose exec freqtrade /bin/bash
+docker-compose exec freqtrade /bin/bash
 sqlite3 <database-file>.sqlite
 ```

@ -49,14 +49,14 @@ sqlite3
 SELECT * FROM trades;
 ```

-## Fix trade still open after a manual exit on the exchange
+## Fix trade still open after a manual sell on the exchange

 !!! Warning
-    Manually selling a pair on the exchange will not be detected by the bot and it will try to sell anyway. Whenever possible, /forceexit <tradeid> should be used to accomplish the same thing.  
+    Manually selling a pair on the exchange will not be detected by the bot and it will try to sell anyway. Whenever possible, forcesell <tradeid> should be used to accomplish the same thing.  
    It is strongly advised to backup your database file before making any manual changes.

 !!! Note
-    This should not be necessary after /forceexit, as force_exit orders are closed automatically by the bot on the next iteration.
+    This should not be necessary after /forcesell, as forcesell orders are closed automatically by the bot on the next iteration.

 ```sql
 UPDATE trades
@ -65,7 +65,7 @@ SET is_open=0,
  close_rate=<close_rate>,
  close_profit = close_rate / open_rate - 1,
  close_profit_abs = (amount * <close_rate> * (1 - fee_close) - (amount * (open_rate * (1 - fee_open)))),
-  exit_reason=<exit_reason>
+  sell_reason=<sell_reason>
 WHERE id=<trade_ID_to_update>;
 ```

@ -78,7 +78,7 @@ SET is_open=0,
  close_rate=0.19638016,
  close_profit=0.0496,
  close_profit_abs = (amount * 0.19638016 * (1 - fee_close) - (amount * (open_rate * (1 - fee_open)))),
-  exit_reason='force_exit'  
+  sell_reason='force_sell'  
 WHERE id=31;
 ```

@ -89,12 +89,11 @@ WHERE id=31;

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

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

+```sql
 DELETE FROM trades WHERE id = 31;
 ```

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

 ## Use a different database system

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

 ### PostgreSQL

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

--- a/docs/stoploss.md
+++ b/docs/stoploss.md
@ -17,28 +17,16 @@ Those stoploss modes can be *on exchange* or *off exchange*.
 These modes can be configured with these values:

 ``` python
-    'emergency_exit': 'market',
+    'emergencysell': 'market',
    'stoploss_on_exchange': False
    'stoploss_on_exchange_interval': 60,
    'stoploss_on_exchange_limit_ratio': 0.99
 ```

-Stoploss on exchange is only supported for the following exchanges, and not all exchanges support both stop-limit and stop-market.
-The Order-type will be ignored if only one mode is available.
-
-| Exchange | stop-loss type |
-|----------|-------------|
-| Binance  | limit |
-| Binance Futures  | market, limit |
-| Huobi    | limit |
-| kraken   | market, limit |
-| Gate     | limit |
-| Okx      | limit |
-| Kucoin   | stop-limit, stop-market|
-
-!!! Note "Tight stoploss"
-    <ins>Do not set too low/tight stoploss value when using stop loss on exchange!</ins>  
-    If set to low/tight you will have greater risk of missing fill on the order and stoploss will not work.
+!!! Note
+    Stoploss on exchange is only supported for Binance (stop-loss-limit), Kraken (stop-loss-market, stop-loss-limit) and FTX (stop limit and stop-market) as of now.  
+    <ins>Do not set too low/tight stoploss value if using stop loss on exchange!</ins>  
+    If set to low/tight then you have greater risk of missing fill on the order and stoploss will not work.

 ### stoploss_on_exchange and stoploss_on_exchange_limit_ratio

@ -64,42 +52,30 @@ The bot cannot do these every 5 seconds (at each iteration), otherwise it would
 So this parameter will tell the bot how often it should update the stoploss order. The default value is 60 (1 minute).
 This same logic will reapply a stoploss order on the exchange should you cancel it accidentally.

-### stoploss_price_type
+### forcesell

-!!! Warning "Only applies to futures"
-    `stoploss_price_type` only applies to futures markets (on exchanges where it's available).
-    Freqtrade will perform a validation of this setting on startup, failing to start if an invalid setting for your exchange has been selected.
-    Supported price types are gonna differs between each exchanges. Please check with your exchange on which price types it supports.
+`forcesell` is an optional value, which defaults to the same value as `sell` and is used when sending a `/forcesell` command from Telegram or from the Rest API.

-Stoploss on exchange on futures markets can trigger on different price types.
-The naming for these prices in exchange terminology often varies, but is usually something around "last" (or "contract price" ), "mark" and "index".
+### forcebuy

-Acceptable values for this setting are `"last"`, `"mark"` and `"index"` - which freqtrade will transfer automatically to the corresponding API type, and place the [stoploss on exchange](#stoploss_on_exchange-and-stoploss_on_exchange_limit_ratio) order correspondingly.
+`forcebuy` is an optional value, which defaults to the same value as `buy` and is used when sending a `/forcebuy` command from Telegram or from the Rest API.

-### force_exit
+### emergencysell

-`force_exit` is an optional value, which defaults to the same value as `exit` and is used when sending a `/forceexit` command from Telegram or from the Rest API.
-
-### force_entry
-
-`force_entry` is an optional value, which defaults to the same value as `entry` and is used when sending a `/forceentry` command from Telegram or from the Rest API.
-
-### emergency_exit
-
-`emergency_exit` is an optional value, which defaults to `market` and is used when creating stop loss on exchange orders fails.
+`emergencysell` is an optional value, which defaults to `market` and is used when creating stop loss on exchange orders fails.
 The below is the default which is used if not changed in strategy or configuration file.

 Example from strategy file:

 ``` python
 order_types = {
-    "entry": "limit",
-    "exit": "limit",
-    "emergency_exit": "market",
-    "stoploss": "market",
-    "stoploss_on_exchange": True,
-    "stoploss_on_exchange_interval": 60,
-    "stoploss_on_exchange_limit_ratio": 0.99
+    'buy': 'limit',
+    'sell': 'limit',
+    'emergencysell': 'market',
+    'stoploss': 'market',
+    'stoploss_on_exchange': True,
+    'stoploss_on_exchange_interval': 60,
+    'stoploss_on_exchange_limit_ratio': 0.99
 }
 ```

@ -111,7 +87,7 @@ At this stage the bot contains the following stoploss support modes:
 2. Trailing stop loss.
 3. Trailing stop loss, custom positive loss.
 4. Trailing stop loss only once the trade has reached a certain offset.
-5. [Custom stoploss function](strategy-callbacks.md#custom-stoploss)
+5. [Custom stoploss function](strategy-advanced.md#custom-stoploss)

 ### Static Stop Loss

@ -154,7 +130,7 @@ In summary: The stoploss will be adjusted to be always be -10% of the highest ob

 ### Trailing stop loss, custom positive loss

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

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

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

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

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

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

 ``` python
@ -237,18 +191,6 @@ For example, simplified math:
 !!! Tip
    Make sure to have this value (`trailing_stop_positive_offset`) lower than minimal ROI, otherwise minimal ROI will apply first and sell the trade.

-## Stoploss and Leverage
-
-Stoploss should be thought of as "risk on this trade" - so a stoploss of 10% on a 100$ trade means you are willing to lose 10$ (10%) on this trade - which would trigger if the price moves 10% to the downside.
-
-When using leverage, the same principle is applied - with stoploss defining the risk on the trade (the amount you are willing to lose).
-
-Therefore, a stoploss of 10% on a 10x trade would trigger on a 1% price move.
-If your stake amount (own capital) was 100$ - this trade would be 1000$ at 10x (after leverage).
-If price moves 1% - you've lost 10$ of your own capital - therfore stoploss will trigger in this case.
-
-Make sure to be aware of this, and avoid using too tight stoploss (at 10x leverage, 10% risk may be too little to allow the trade to "breath" a little).
-
 ## Changing stoploss on open trades

 A stoploss on an open trade can be changed by changing the value in the configuration or strategy and use the `/reload_config` command (alternatively, completely stopping and restarting the bot also works).
--- a/docs/strategy-advanced.md
+++ b/docs/strategy-advanced.md
@ -49,7 +49,7 @@ from freqtrade.exchange import timeframe_to_prev_date

 class AwesomeStrategy(IStrategy):
    def confirm_trade_exit(self, pair: str, trade: 'Trade', order_type: str, amount: float,
-                           rate: float, time_in_force: str, exit_reason: str,
+                           rate: float, time_in_force: str, sell_reason: str,
                           current_time: 'datetime', **kwargs) -> bool:
        # Obtain pair dataframe.
        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
@ -77,53 +77,47 @@ class AwesomeStrategy(IStrategy):

 ***

-## Enter Tag
+## Buy Tag

 When your strategy has multiple buy signals, you can name the signal that triggered.
-Then you can access your buy signal on `custom_exit`
+Then you can access you buy signal on `custom_sell`

 ```python
-def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
    dataframe.loc[
        (
            (dataframe['rsi'] < 35) &
            (dataframe['volume'] > 0)
        ),
-        ['enter_long', 'enter_tag']] = (1, 'buy_signal_rsi')
+        ['buy', 'buy_tag']] = (1, 'buy_signal_rsi')

    return dataframe

-def custom_exit(self, pair: str, trade: Trade, current_time: datetime, current_rate: float,
-                current_profit: float, **kwargs):
+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()
-    if trade.enter_tag == 'buy_signal_rsi' and last_candle['rsi'] > 80:
+    if trade.buy_tag == 'buy_signal_rsi' and last_candle['rsi'] > 80:
        return 'sell_signal_rsi'
    return None

 ```

 !!! Note
-    `enter_tag` is limited to 100 characters, remaining data will be truncated.
-
-!!! Warning
-    There is only one `enter_tag` column, which is used for both long and short trades.
-    As a consequence, this column must be treated as "last write wins" (it's just a dataframe column after all).
-    In fancy situations, where multiple signals collide (or if signals are deactivated again based on different conditions), this can lead to odd results with the wrong tag applied to an entry signal.
-    These results are a consequence of the strategy overwriting prior tags - where the last tag will "stick" and will be the one freqtrade will use.
+    `buy_tag` is limited to 100 characters, remaining data will be truncated.

 ## Exit tag

 Similar to [Buy Tagging](#buy-tag), you can also specify a sell tag.

 ``` python
-def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
    dataframe.loc[
        (
            (dataframe['rsi'] > 70) &
            (dataframe['volume'] > 0)
        ),
-        ['exit_long', 'exit_tag']] = (1, 'exit_rsi')
+        ['sell', 'exit_tag']] = (1, 'exit_rsi')

    return dataframe
 ```
@ -131,7 +125,7 @@ def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame
 The provided exit-tag is then used as sell-reason - and shown as such in backtest results.

 !!! Note
-    `exit_reason` is limited to 100 characters, remaining data will be truncated.
+    `sell_reason` is limited to 100 characters, remaining data will be truncated.

 ## Strategy version

@ -152,7 +146,7 @@ def version(self) -> str:

 The strategies can be derived from other strategies. This avoids duplication of your custom strategy code. You can use this technique to override small parts of your main strategy, leaving the rest untouched:

-``` python title="user_data/strategies/myawesomestrategy.py"
+``` python
 class MyAwesomeStrategy(IStrategy):
    ...
    stoploss = 0.13
@ -161,10 +155,6 @@ class MyAwesomeStrategy(IStrategy):
    # should be in any custom strategy...
    ...

-```
-
-``` python title="user_data/strategies/MyAwesomeStrategy2.py"
-from myawesomestrategy import MyAwesomeStrategy
 class MyAwesomeStrategy2(MyAwesomeStrategy):
    # Override something
    stoploss = 0.08
@ -173,7 +163,16 @@ class MyAwesomeStrategy2(MyAwesomeStrategy):

 Both attributes and methods may be overridden, altering behavior of the original strategy in a way you need.

-While keeping the subclass in the same file is technically possible, it can lead to some problems with hyperopt parameter files, we therefore recommend to use separate strategy files, and import the parent strategy as shown above.
+!!! Note "Parent-strategy in different files"
+    If you have the parent-strategy in a different file, you'll need to add the following to the top of your "child"-file to ensure proper loading, otherwise freqtrade may not be able to load the parent strategy correctly.
+
+    ``` python
+    import sys
+    from pathlib import Path
+    sys.path.append(str(Path(__file__).parent))
+
+    from myawesomestrategy import MyAwesomeStrategy
+    ```

 ## Embedding Strategies

@ -230,5 +229,3 @@ for val in self.buy_ema_short.range:
 # Append columns to existing dataframe
 merged_frame = pd.concat(frames, axis=1)
 ```
-
-Freqtrade does however also counter this by running `dataframe.copy()` on the dataframe right after the `populate_indicators()` method - so performance implications of this should be low to non-existant.
--- a/docs/strategy-callbacks.md
+++ b/docs/strategy-callbacks.md
@ -1,58 +1,28 @@
 # Strategy Callbacks

-While the main strategy functions (`populate_indicators()`, `populate_entry_trend()`, `populate_exit_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".
+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_start()`](#bot-start)
 * [`bot_loop_start()`](#bot-loop-start)
-* [`custom_stake_amount()`](#stake-size-management)
-* [`custom_exit()`](#custom-exit-signal)
+* [`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_entry_timeout()` and `check_exit_timeout()`](#custom-order-timeout-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)
 * [`adjust_trade_position()`](#adjust-trade-position)
-* [`adjust_entry_price()`](#adjust-entry-price)
-* [`leverage()`](#leverage-callback)

 !!! Tip "Callback calling sequence"
    You can find the callback calling sequence in [bot-basics](bot-basics.md#bot-execution-logic)

-## Bot start
-
-A simple callback which is called once when the strategy is loaded.
-This can be used to perform actions that must only be performed once and runs after dataprovider and wallet are set
-
-``` python
-import requests
-
-class AwesomeStrategy(IStrategy):
-
-    # ... populate_* methods
-
-    def bot_start(self, **kwargs) -> None:
-        """
-        Called only once after bot instantiation.
-        :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.cust_remote_data = requests.get('https://some_remote_source.example.com')
-
-```
-
-During hyperopt, this runs only once at startup.
-
 ## Bot loop start

-A simple callback which is called once at the start of every bot throttling iteration in dry/live mode (roughly every 5
-seconds, unless configured differently) or once per candle in backtest/hyperopt mode.
+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
@ -62,12 +32,11 @@ class AwesomeStrategy(IStrategy):

    # ... populate_* methods

-    def bot_loop_start(self, current_time: datetime, **kwargs) -> None:
+    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 current_time: datetime object, containing the current datetime
        :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'):
@ -77,16 +46,15 @@ class AwesomeStrategy(IStrategy):

 ```

-## Stake size management
+## 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: Optional[float], max_stake: float,
-                            leverage: float, entry_tag: Optional[str], side: str,
-                            **kwargs) -> float:
+                            proposed_stake: float, min_stake: float, max_stake: float,
+                            entry_tag: Optional[str], **kwargs) -> float:

        dataframe, _ = self.dp.get_analyzed_dataframe(pair=pair, timeframe=self.timeframe)
        current_candle = dataframe.iloc[-1].squeeze()
@ -111,25 +79,24 @@ Freqtrade will fall back to the `proposed_stake` value should your code raise an
 !!! Tip
    Returning `0` or `None` will prevent trades from being placed.

-## Custom exit signal
+## Custom sell signal

 Called for open trade every throttling iteration (roughly every 5 seconds) until a trade is closed.

-Allows to define custom exit signals, indicating that specified position should be sold. This is very useful when we need to customize exit conditions for each individual trade, or if you need trade data to make an exit decision.
+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_exit()`.
+For example you could implement a 1:2 risk-reward ROI with `custom_sell()`.

-Using `custom_exit()` 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.
+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 exit signal on a candle at specified time. This method is not called when exit signal is set already, or if exit signals are disabled (`use_exit_signal=False`). `string` max length is 64 characters. Exceeding this limit will cause the message to be truncated to 64 characters.
-    `custom_exit()` will ignore `exit_profit_only`, and will always be called unless `use_exit_signal=False`, even if there is a new enter signal.
+    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 exit trades that were open longer than one day:
+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_exit(self, pair: str, trade: 'Trade', current_time: 'datetime', current_rate: float,
+    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()
@ -153,15 +120,13 @@ See [Dataframe access](strategy-advanced.md#dataframe-access) for more informati

 ## Custom stoploss

-Called for open trade every iteration (roughly every 5 seconds) until a trade is closed.
-
+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), and is still mandatory.
+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.
-During backtesting, `current_rate` (and `current_profit`) are provided against the candle's high (or low for short trades) - while the resulting stoploss is evaluated against the candle's low (or high for short trades).

 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.

@ -193,7 +158,7 @@ class AwesomeStrategy(IStrategy):
        :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 exit_pricing.
+        :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
@ -318,11 +283,11 @@ class AwesomeStrategy(IStrategy):

        # evaluate highest to lowest, so that highest possible stop is used
        if current_profit > 0.40:
-            return stoploss_from_open(0.25, current_profit, is_short=trade.is_short, leverage=trade.leverage)
+            return stoploss_from_open(0.25, current_profit)
        elif current_profit > 0.25:
-            return stoploss_from_open(0.15, current_profit, is_short=trade.is_short, leverage=trade.leverage)
+            return stoploss_from_open(0.15, current_profit)
        elif current_profit > 0.20:
-            return stoploss_from_open(0.07, current_profit, is_short=trade.is_short, leverage=trade.leverage)
+            return stoploss_from_open(0.07, current_profit)

        # return maximum stoploss value, keeping current stoploss price unchanged
        return 1
@ -397,36 +362,36 @@ class AwesomeStrategy(IStrategy):

    # ... populate_* methods

-    def custom_entry_price(self, pair: str, current_time: datetime, proposed_rate: float,
-                           entry_tag: Optional[str], side: str, **kwargs) -> float:
+    def custom_entry_price(self, pair: str, current_time: datetime, proposed_rate: float, 
+                           entry_tag: Optional[str], **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, exit_tag: Optional[str], **kwargs) -> 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**:
+    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"
    Custom prices are supported in backtesting (starting with 2021.12), and orders will fill if the price falls within the candle's low/high range.
    Orders that don't fill immediately are subject to regular timeout handling, which happens once per (detail) candle.
-    `custom_exit_price()` is only called for sells of type exit_signal, Custom exit and partial exits. All other exit-types will use regular backtesting prices.
+    `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

@ -441,7 +406,7 @@ However, freqtrade also offers a custom callback for both order types, which all
 ### Custom order timeout example

 Called for every open order until that order is either filled or cancelled.
-`check_entry_timeout()` is called for trade entries, while `check_exit_timeout()` is called for trade exit orders.
+`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.
@ -450,7 +415,7 @@ The function must return either `True` (cancel order) or `False` (keep order ali

 ``` python
 from datetime import datetime, timedelta
-from freqtrade.persistence import Trade, Order
+from freqtrade.persistence import Trade

 class AwesomeStrategy(IStrategy):

@ -458,12 +423,12 @@ class AwesomeStrategy(IStrategy):

    # Set unfilledtimeout to 25 hours, since the maximum timeout from below is 24 hours.
    unfilledtimeout = {
-        'entry': 60 * 25,
-        'exit': 60 * 25
+        'buy': 60 * 25,
+        'sell': 60 * 25
    }

-    def check_entry_timeout(self, pair: str, trade: 'Trade', order: 'Order',
-                            current_time: datetime, **kwargs) -> bool:
+    def check_buy_timeout(self, pair: str, trade: 'Trade', order: dict, 
+                          current_time: datetime, **kwargs) -> bool:
        if trade.open_rate > 100 and trade.open_date_utc < current_time - timedelta(minutes=5):
            return True
        elif trade.open_rate > 10 and trade.open_date_utc < current_time - timedelta(minutes=3):
@ -473,7 +438,7 @@ class AwesomeStrategy(IStrategy):
        return False


-    def check_exit_timeout(self, pair: str, trade: Trade, order: 'Order',
+    def check_sell_timeout(self, pair: str, trade: Trade, order: dict,
                           current_time: datetime, **kwargs) -> bool:
        if trade.open_rate > 100 and trade.open_date_utc < current_time - timedelta(minutes=5):
            return True
@ -491,7 +456,7 @@ class AwesomeStrategy(IStrategy):

 ``` python
 from datetime import datetime
-from freqtrade.persistence import Trade, Order
+from freqtrade.persistence import Trade

 class AwesomeStrategy(IStrategy):

@ -499,26 +464,26 @@ class AwesomeStrategy(IStrategy):

    # Set unfilledtimeout to 25 hours, since the maximum timeout from below is 24 hours.
    unfilledtimeout = {
-        'entry': 60 * 25,
-        'exit': 60 * 25
+        'buy': 60 * 25,
+        'sell': 60 * 25
    }

-    def check_entry_timeout(self, pair: str, trade: 'Trade', order: 'Order',
-                            current_time: datetime, **kwargs) -> bool:
+    def check_buy_timeout(self, pair: str, trade: Trade, order: dict,
+                          current_time: datetime, **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:
+        if current_price > order['price'] * 1.02:
            return True
        return False


-    def check_exit_timeout(self, pair: str, trade: 'Trade', order: 'Order',
+    def check_sell_timeout(self, pair: str, trade: Trade, order: dict,
                           current_time: datetime, **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:
+        if current_price < order['price'] * 0.98:
            return True
        return False
 ```
@ -540,10 +505,10 @@ 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, entry_tag: Optional[str],
-                            side: str, **kwargs) -> bool:
+                            time_in_force: str, current_time: datetime, entry_tag: Optional[str], 
+                            **kwargs) -> bool:
        """
-        Called right before placing a entry order.
+        Called right before placing a buy order.
        Timing for this function is critical, so avoid doing heavy computations or
        network requests in this method.

@ -551,15 +516,12 @@ class AwesomeStrategy(IStrategy):

        When not implemented by a strategy, returns True (always confirming).

-        :param pair: Pair that's about to be bought/shorted.
+        :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 (base) currency that's going to be traded.
-        :param rate: Rate that's going to be used when using limit orders 
-                     or current rate for market orders.
+        :param 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 entry_tag: Optional entry_tag (buy_tag) if provided with the buy signal.
-        :param side: 'long' or 'short' - indicating the direction of the proposed trade
        :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
@ -572,14 +534,6 @@ class AwesomeStrategy(IStrategy):

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

-`confirm_trade_exit()` may be called multiple times within one iteration for the same trade if different exit-reasons apply.
-The exit-reasons (if applicable) will be in the following sequence:
-
-* `exit_signal` / `custom_exit`
-* `stop_loss`
-* `roi`
-* `trailing_stop_loss`
-
 ``` python
 from freqtrade.persistence import Trade

@ -589,10 +543,10 @@ 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, exit_reason: str,
+                           rate: float, time_in_force: str, sell_reason: str,
                           current_time: datetime, **kwargs) -> bool:
        """
-        Called right before placing a regular exit order.
+        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.

@ -600,22 +554,20 @@ class AwesomeStrategy(IStrategy):

        When not implemented by a strategy, returns True (always confirming).

-        :param pair: Pair for trade that's about to be exited.
-        :param trade: trade object.
+        :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 base currency.
+        :param amount: Amount in quote currency.
        :param rate: Rate that's going to be used when using limit orders
-                     or current rate for market orders.
        :param time_in_force: Time in force. Defaults to GTC (Good-til-cancelled).
-        :param exit_reason: Exit reason.
+        :param sell_reason: Sell reason.
            Can be any of ['roi', 'stop_loss', 'stoploss_on_exchange', 'trailing_stop_loss',
-                           'exit_signal', 'force_exit', 'emergency_exit']
+                           '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, then the exit-order is placed on the exchange.
+        :return bool: When True is returned, then the sell-order is placed on the exchange.
            False aborts the process
        """
-        if exit_reason == 'force_exit' and trade.calc_profit_ratio(rate) < 0:
+        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)
@ -624,15 +576,11 @@ class AwesomeStrategy(IStrategy):

 ```

-!!! Warning
-    `confirm_trade_exit()` can prevent stoploss exits, causing significant losses as this would ignore stoploss exits.
-    `confirm_trade_exit()` will not be called for Liquidations - as liquidations are forced by the exchange, and therefore cannot be rejected.
-
 ## Adjust trade position

 The `position_adjustment_enable` strategy property enables the usage of `adjust_trade_position()` callback in the strategy.
 For performance reasons, it's disabled by default and freqtrade will show a warning message on startup if enabled.
-`adjust_trade_position()` can be used to perform additional orders, for example to manage risk with DCA (Dollar Cost Averaging) or to increase or decrease positions.
+`adjust_trade_position()` can be used to perform additional orders, for example to manage risk with DCA (Dollar Cost Averaging).

 `max_entry_position_adjustment` property is used to limit the number of additional buys per trade (on top of the first buy) that the bot can execute. By default, the value is -1 which means the bot have no limit on number of adjustment buys.

@ -640,14 +588,9 @@ The strategy is expected to return a stake_amount (in stake currency) between `m
 If there are not enough funds in the wallet (the return value is above `max_stake`) then the signal will be ignored.
 Additional orders also result in additional fees and those orders don't count towards `max_open_trades`.

-This callback is **not** called when there is an open order (either buy or sell) waiting for execution.
-
+This callback is **not** called when there is an open order (either buy or sell) waiting for execution, or when you have reached the maximum amount of extra buys that you have set on `max_entry_position_adjustment`.
 `adjust_trade_position()` is called very frequently for the duration of a trade, so you must keep your implementation as performant as possible.

-Additional Buys are ignored once you have reached the maximum amount of extra buys that you have set on `max_entry_position_adjustment`, but the callback is called anyway looking for partial exits.
-
-Position adjustments will always be applied in the direction of the trade, so a positive value will always increase your position (negative values will decrease your position), no matter if it's a long or short trade. Modifications to leverage are not possible, and the stake-amount is assumed to be before applying leverage.
-
 !!! Note "About stake size"
    Using fixed stake size means it will be the amount used for the first order, just like without position adjustment.
    If you wish to buy additional orders with DCA, then make sure to leave enough funds in the wallet for that.
@ -655,78 +598,57 @@ Position adjustments will always be applied in the direction of the trade, so a

 !!! Warning
    Stoploss is still calculated from the initial opening price, not averaged price.
-    Regular stoploss rules still apply (cannot move down).

-    While `/stopentry` command stops the bot from entering new trades, the position adjustment feature will continue buying new orders on existing trades.
+!!! Warning "/stopbuy"
+    While `/stopbuy` command stops the bot from entering new trades, the position adjustment feature will continue buying new orders on existing trades.

 !!! Warning "Backtesting"
-    During backtesting this callback is called for each candle in `timeframe` or `timeframe_detail`, so run-time performance will be affected.
-    This can also cause deviating results between live and backtesting, since backtesting can adjust the trade only once per candle, whereas live could adjust the trade multiple times per candle.
+    During backtesting this callback is called for each candle in `timeframe` or `timeframe_detail`, so performance will be affected.

 ``` python
 from freqtrade.persistence import Trade


 class DigDeeperStrategy(IStrategy):
-
+    
    position_adjustment_enable = True
-
+    
    # Attempts to handle large drops with DCA. High stoploss is required.
    stoploss = -0.30
-
+    
    # ... populate_* methods
-
+    
    # Example specific variables
    max_entry_position_adjustment = 3
    # This number is explained a bit further down
    max_dca_multiplier = 5.5
-
+    
    # This is called when placing the initial order (opening trade)
    def custom_stake_amount(self, pair: str, current_time: datetime, current_rate: float,
-                            proposed_stake: float, min_stake: Optional[float], max_stake: float,
-                            leverage: float, entry_tag: Optional[str], side: str,
-                            **kwargs) -> float:
-
+                            proposed_stake: float, min_stake: float, max_stake: float,
+                            entry_tag: Optional[str], **kwargs) -> float:
+        
        # We need to leave most of the funds for possible further DCA orders
        # This also applies to fixed stakes
        return proposed_stake / self.max_dca_multiplier
-
+        
    def adjust_trade_position(self, trade: Trade, current_time: datetime,
-                              current_rate: float, current_profit: float,
-                              min_stake: Optional[float], max_stake: float,
-                              current_entry_rate: float, current_exit_rate: float,
-                              current_entry_profit: float, current_exit_profit: float,
-                              **kwargs) -> Optional[float]:
+                              current_rate: float, current_profit: float, min_stake: float,
+                              max_stake: float, **kwargs):
        """
-        Custom trade adjustment logic, returning the stake amount that a trade should be
-        increased or decreased.
-        This means extra buy or sell orders with additional fees.
-        Only called when `position_adjustment_enable` is set to True.
-
-        For full documentation please go to https://www.freqtrade.io/en/latest/strategy-advanced/
-
-        When not implemented by a strategy, returns None
-
+        Custom trade adjustment logic, returning the stake amount that a trade should be increased.
+        This means extra buy orders with additional fees.
+ 
        :param trade: trade object.
        :param current_time: datetime object, containing the current datetime
        :param current_rate: Current buy rate.
        :param current_profit: Current profit (as ratio), calculated based on current_rate.
-        :param min_stake: Minimal stake size allowed by exchange (for both entries and exits)
-        :param max_stake: Maximum stake allowed (either through balance, or by exchange limits).
-        :param current_entry_rate: Current rate using entry pricing.
-        :param current_exit_rate: Current rate using exit pricing.
-        :param current_entry_profit: Current profit using entry pricing.
-        :param current_exit_profit: Current profit using exit pricing.
+        :param min_stake: Minimal stake size allowed by exchange.
+        :param max_stake: Balance available for trading.
        :param **kwargs: Ensure to keep this here so updates to this won't break your strategy.
-        :return float: Stake amount to adjust your trade,
-                       Positive values to increase position, Negative values to decrease position.
-                       Return None for no action.
+        :return float: Stake amount to adjust your trade
        """
-
-        if current_profit > 0.05 and trade.nr_of_successful_exits == 0:
-            # Take half of the profit at +5%
-            return -(trade.stake_amount / 2)
-
+        
        if current_profit > -0.05:
            return None

@ -738,8 +660,8 @@ class DigDeeperStrategy(IStrategy):
        if last_candle['close'] < previous_candle['close']:
            return None

-        filled_entries = trade.select_filled_orders(trade.entry_side)
-        count_of_entries = trade.nr_of_successful_entries
+        filled_buys = trade.select_filled_orders('buy')
+        count_of_buys = trade.nr_of_successful_buys
        # Allow up to 3 additional increasingly larger buys (4 in total)
        # Initial buy is 1x
        # If that falls to -5% profit, we buy 1.25x more, average profit should increase to roughly -2.2%
@ -750,9 +672,9 @@ class DigDeeperStrategy(IStrategy):
        # Hope you have a deep wallet!
        try:
            # This returns first order stake size
-            stake_amount = filled_entries[0].cost
+            stake_amount = filled_buys[0].cost
            # This then calculates current safety order size
-            stake_amount = stake_amount * (1 + (count_of_entries * 0.25))
+            stake_amount = stake_amount * (1 + (count_of_buys * 0.25))
            return stake_amount
        except Exception as exception:
            return None
@ -760,117 +682,3 @@ class DigDeeperStrategy(IStrategy):
        return None

 ```
-
-### Position adjust calculations
-
-* Entry rates are calculated using weighted averages.
-* Exits will not influence the average entry rate.
-* Partial exit relative profit is relative to the average entry price at this point.
-* Final exit relative profit is calculated based on the total invested capital. (See example below)
-
-??? example "Calculation example"
-    *This example assumes 0 fees for simplicity, and a long position on an imaginary coin.*  
-    
-    * Buy 100@8\$ 
-    * Buy 100@9\$ -> Avg price: 8.5\$
-    * Sell 100@10\$ -> Avg price: 8.5\$, realized profit 150\$, 17.65%
-    * Buy 150@11\$ -> Avg price: 10\$, realized profit 150\$, 17.65%
-    * Sell 100@12\$ -> Avg price: 10\$, total realized profit 350\$, 20%
-    * Sell 150@14\$ -> Avg price: 10\$, total realized profit 950\$, 40%  <- *This will be the last "Exit" message*
-
-    The total profit for this trade was 950$ on a 3350$ investment (`100@8$ + 100@9$ + 150@11$`). As such - the final relative profit is 28.35% (`950 / 3350`).
-
-## Adjust Entry Price
-
-The `adjust_entry_price()` callback may be used by strategy developer to refresh/replace limit orders upon arrival of new candles.
-Be aware that `custom_entry_price()` is still the one dictating initial entry limit order price target at the time of entry trigger.
-
-Orders can be cancelled out of this callback by returning `None`.
-
-Returning `current_order_rate` will keep the order on the exchange "as is".
-Returning any other price will cancel the existing order, and replace it with a new order.
-
-The trade open-date (`trade.open_date_utc`) will remain at the time of the very first order placed.
-Please make sure to be aware of this - and eventually adjust your logic in other callbacks to account for this, and use the date of the first filled order instead.
-
-!!! Warning "Regular timeout"
-    Entry `unfilledtimeout` mechanism (as well as `check_entry_timeout()`) takes precedence over this.
-    Entry Orders that are cancelled via the above methods will not have this callback called. Be sure to update timeout values to match your expectations.
-
-```python
-from freqtrade.persistence import Trade
-from datetime import timedelta
-
-class AwesomeStrategy(IStrategy):
-
-    # ... populate_* methods
-
-    def adjust_entry_price(self, trade: Trade, order: Optional[Order], pair: str,
-                           current_time: datetime, proposed_rate: float, current_order_rate: float,
-                           entry_tag: Optional[str], side: str, **kwargs) -> float:
-        """
-        Entry price re-adjustment logic, returning the user desired limit price.
-        This only executes when a order was already placed, still open (unfilled fully or partially)
-        and not timed out on subsequent candles after entry trigger.
-
-        When not implemented by a strategy, returns current_order_rate as default.
-        If current_order_rate is returned then the existing order is maintained.
-        If None is returned then order gets canceled but not replaced by a new one.
-
-        :param pair: Pair that's currently analyzed
-        :param trade: Trade object.
-        :param order: Order object
-        :param current_time: datetime object, containing the current datetime
-        :param proposed_rate: Rate, calculated based on pricing settings in entry_pricing.
-        :param current_order_rate: Rate of the existing order in place.
-        :param entry_tag: Optional entry_tag (buy_tag) if provided with the buy signal.
-        :param side: 'long' or 'short' - indicating the direction of the proposed trade
-        :param **kwargs: Ensure to keep this here so updates to this won't break your strategy.
-        :return float: New entry price value if provided
-
-        """
-        # Limit orders to use and follow SMA200 as price target for the first 10 minutes since entry trigger for BTC/USDT pair.
-        if pair == 'BTC/USDT' and entry_tag == 'long_sma200' and side == 'long' and (current_time - timedelta(minutes=10)) > trade.open_date_utc:
-            # just cancel the order if it has been filled more than half of the amount
-            if order.filled > order.remaining:
-                return None
-            else:
-                dataframe, _ = self.dp.get_analyzed_dataframe(pair=pair, timeframe=self.timeframe)
-                current_candle = dataframe.iloc[-1].squeeze()
-                # desired price
-                return current_candle['sma_200']
-        # default: maintain existing order
-        return current_order_rate
-```
-
-## Leverage Callback
-
-When trading in markets that allow leverage, this method must return the desired Leverage (Defaults to 1 -> No leverage).
-
-Assuming a capital of 500USDT, a trade with leverage=3 would result in a position with 500 x 3 = 1500 USDT.
-
-Values that are above `max_leverage` will be adjusted to `max_leverage`.
-For markets / exchanges that don't support leverage, this method is ignored.
-
-``` python
-class AwesomeStrategy(IStrategy):
-    def leverage(self, pair: str, current_time: datetime, current_rate: float,
-                 proposed_leverage: float, max_leverage: float, entry_tag: Optional[str], side: str,
-                 **kwargs) -> float:
-        """
-        Customize leverage for each new trade. This method is only called in futures mode.
-
-        :param pair: Pair that's currently analyzed
-        :param current_time: datetime object, containing the current datetime
-        :param current_rate: Rate, calculated based on pricing settings in exit_pricing.
-        :param proposed_leverage: A leverage proposed by the bot.
-        :param max_leverage: Max leverage allowed on this pair
-        :param entry_tag: Optional entry_tag (buy_tag) if provided with the buy signal.
-        :param side: 'long' or 'short' - indicating the direction of the proposed trade
-        :return: A leverage amount, which is between 1.0 and max_leverage.
-        """
-        return 1.0
-```
-
-All profit calculations include leverage. Stoploss / ROI also include leverage in their calculation.
-Defining a stoploss of 10% at 10x leverage would trigger the stoploss with a 1% move to the downside.
--- a/docs/strategy-customization.md
+++ b/docs/strategy-customization.md
@ -26,8 +26,8 @@ This will create a new strategy file from a template, which will be located unde
 A strategy file contains all the information needed to build a good strategy:

 - Indicators
- Entry strategy rules
- Exit strategy rules
+- Buy strategy rules
+- Sell strategy rules
 - Minimal ROI recommended
 - Stoploss strongly recommended

@ -35,7 +35,7 @@ The bot also include a sample strategy called `SampleStrategy` you can update: `
 You can test it with the parameter: `--strategy SampleStrategy`

 Additionally, there is an attribute called `INTERFACE_VERSION`, which defines the version of the strategy interface the bot should use.
-The current version is 3 - which is also the default when it's not set explicitly in the strategy.
+The current version is 2 - which is also the default when it's not set explicitly in the strategy.

 Future versions will require this to be set.

@ -82,7 +82,7 @@ As a dataframe is a table, simple python comparisons like the following will not

 ``` python
    if dataframe['rsi'] > 30:
-        dataframe['enter_long'] = 1
+        dataframe['buy'] = 1
 ```

 The above section will fail with `The truth value of a Series is ambiguous. [...]`.
@ -92,16 +92,16 @@ This must instead be written in a pandas-compatible way, so the operation is per
 ``` python
    dataframe.loc[
        (dataframe['rsi'] > 30)
-    , 'enter_long'] = 1
+    , '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 signals need indicators. You can add more indicators by extending the list contained in the method `populate_indicators()` from your strategy file.
+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.

-You should only add the indicators used in either `populate_entry_trend()`, `populate_exit_trend()`, or to populate another indicator, otherwise performance may suffer.
+You should only add the indicators used in either `populate_buy_trend()`, `populate_sell_trend()`, or to populate another indicator, otherwise performance may suffer.

 It's important to always return the dataframe without removing/modifying the columns `"open", "high", "low", "close", "volume"`, otherwise these fields would contain something unexpected.

@ -166,7 +166,7 @@ Additional technical libraries can be installed as necessary, or custom indicato

 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. In the case where a user includes higher timeframes with informative pairs, the `startup_candle_count` does not necessarily change. The value is the maximum period (in candles) that any of the informatives timeframes need to compute stable indicators.
+This should be set to the maximum number of candles that the strategy requires to calculate stable indicators.

 In this example strategy, this should be set to 100 (`startup_candle_count = 100`), since the longest needed history is 100 candles.

@ -199,18 +199,18 @@ If this data is available, indicators will be calculated with this extended time
 !!! Note
    If data for the startup period is not available, then the timerange will be adjusted to account for this startup period - so Backtesting would start at 2019-01-01 08:30:00.

-### Entry signal rules
+### Buy signal rules

-Edit the method `populate_entry_trend()` in your strategy file to update your entry strategy.
+Edit the method `populate_buy_trend()` in your strategy file to update your buy strategy.

 It's important to always return the dataframe without removing/modifying the columns `"open", "high", "low", "close", "volume"`, otherwise these fields would contain something unexpected.

-This method will also define a new column, `"enter_long"` (`"enter_short"` for shorts), which needs to contain 1 for entries, and 0 for "no action". `enter_long` is a mandatory column that must be set even if the strategy is shorting only.
+This method will also define a new column, `"buy"`, which needs to contain 1 for buys, and 0 for "no action".

 Sample from `user_data/strategies/sample_strategy.py`:

 ```python
-def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
    """
    Based on TA indicators, populates the buy signal for the given dataframe
    :param dataframe: DataFrame populated with indicators
@ -224,59 +224,29 @@ def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFram
            (dataframe['tema'] > dataframe['tema'].shift(1)) &  # Guard
            (dataframe['volume'] > 0)  # Make sure Volume is not 0
        ),
-        ['enter_long', 'enter_tag']] = (1, 'rsi_cross')
+        'buy'] = 1

    return dataframe
 ```

-??? Note "Enter short trades"
-    Short-entries can be created by setting `enter_short` (corresponds to `enter_long` for long trades).
-    The `enter_tag` column remains identical.
-    Short-trades need to be supported by your exchange and market configuration!
-    Please make sure to set [`can_short`]() appropriately on your strategy if you intend to short.
-
-    ```python
-    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
-        dataframe.loc[
-            (
-                (qtpylib.crossed_above(dataframe['rsi'], 30)) &  # Signal: RSI crosses above 30
-                (dataframe['tema'] <= dataframe['bb_middleband']) &  # Guard
-                (dataframe['tema'] > dataframe['tema'].shift(1)) &  # Guard
-                (dataframe['volume'] > 0)  # Make sure Volume is not 0
-            ),
-            ['enter_long', 'enter_tag']] = (1, 'rsi_cross')
-
-        dataframe.loc[
-            (
-                (qtpylib.crossed_below(dataframe['rsi'], 70)) &  # Signal: RSI crosses below 70
-                (dataframe['tema'] > dataframe['bb_middleband']) &  # Guard
-                (dataframe['tema'] < dataframe['tema'].shift(1)) &  # Guard
-                (dataframe['volume'] > 0)  # Make sure Volume is not 0
-            ),
-            ['enter_short', 'enter_tag']] = (1, 'rsi_cross')
-
-        return dataframe
-    ```
-
 !!! Note
    Buying requires sellers to buy from - therefore volume needs to be > 0 (`dataframe['volume'] > 0`) to make sure that the bot does not buy/sell in no-activity periods.

-### Exit signal rules
+### Sell signal rules

-Edit the method `populate_exit_trend()` into your strategy file to update your exit strategy.
-The exit-signal is only used for exits if `use_exit_signal` is set to true in the configuration.
-`use_exit_signal` will not influence [signal collision rules](#colliding-signals) - which will still apply and can prevent entries.
+Edit the method `populate_sell_trend()` into your strategy file to update your sell strategy.
+Please note that the sell-signal is only used if `use_sell_signal` is set to true in the configuration.

 It's important to always return the dataframe without removing/modifying the columns `"open", "high", "low", "close", "volume"`, otherwise these fields would contain something unexpected.

-This method will also define a new column, `"exit_long"` (`"exit_short"` for shorts), which needs to contain 1 for exits, and 0 for "no action".
+This method will also define a new column, `"sell"`, which needs to contain 1 for sells, and 0 for "no action".

 Sample from `user_data/strategies/sample_strategy.py`:

 ```python
-def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
    """
-    Based on TA indicators, populates the exit signal for the given dataframe
+    Based on TA indicators, populates the sell signal for the given dataframe
    :param dataframe: DataFrame populated with indicators
    :param metadata: Additional information, like the currently traded pair
    :return: DataFrame with buy column
@ -288,39 +258,13 @@ def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame
            (dataframe['tema'] < dataframe['tema'].shift(1)) &  # Guard
            (dataframe['volume'] > 0)  # Make sure Volume is not 0
        ),
-        ['exit_long', 'exit_tag']] = (1, 'rsi_too_high')
+        'sell'] = 1
    return dataframe
 ```

-??? Note "Exit short trades"
-    Short-exits can be created by setting `exit_short` (corresponds to `exit_long`).
-    The `exit_tag` column remains identical.
-    Short-trades need to be supported by your exchange and market configuration!
-
-    ```python
-    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
-        dataframe.loc[
-            (
-                (qtpylib.crossed_above(dataframe['rsi'], 70)) &  # Signal: RSI crosses above 70
-                (dataframe['tema'] > dataframe['bb_middleband']) &  # Guard
-                (dataframe['tema'] < dataframe['tema'].shift(1)) &  # Guard
-                (dataframe['volume'] > 0)  # Make sure Volume is not 0
-            ),
-            ['exit_long', 'exit_tag']] = (1, 'rsi_too_high')
-        dataframe.loc[
-            (
-                (qtpylib.crossed_below(dataframe['rsi'], 30)) &  # Signal: RSI crosses below 30
-                (dataframe['tema'] < dataframe['bb_middleband']) &  # Guard
-                (dataframe['tema'] > dataframe['tema'].shift(1)) &  # Guard
-                (dataframe['volume'] > 0)  # Make sure Volume is not 0
-            ),
-            ['exit_short', 'exit_tag']] = (1, 'rsi_too_low')
-        return dataframe
-    ```
-
 ### Minimal ROI

-This dict defines the minimal Return On Investment (ROI) a trade should reach before exiting, independent from the exit signal.
+This dict defines the minimal Return On Investment (ROI) a trade should reach before selling, independent from the sell signal.

 It is of the following format, with the dict key (left side of the colon) being the minutes passed since the trade opened, and the value (right side of the colon) being the percentage.

@ -335,10 +279,10 @@ minimal_roi = {

 The above configuration would therefore mean:

- Exit whenever 4% profit was reached
- Exit when 2% profit was reached (in effect after 20 minutes)
- Exit when 1% profit was reached (in effect after 30 minutes)
- Exit when trade is non-loosing (in effect after 40 minutes)
+- Sell whenever 4% profit was reached
+- Sell when 2% profit was reached (in effect after 20 minutes)
+- Sell when 1% profit was reached (in effect after 30 minutes)
+- Sell when trade is non-loosing (in effect after 40 minutes)

 The calculation does include fees.

@ -350,7 +294,7 @@ minimal_roi = {
 }
 ```

-While technically not completely disabled, this would exit once the trade reaches 10000% Profit.
+While technically not completely disabled, this would sell once the trade reaches 10000% Profit.

 To use times based on candle duration (timeframe), the following snippet can be handy.
 This will allow you to change the timeframe for the strategy, and ROI times will still be set as candles (e.g. after 3 candles ...)
@ -363,9 +307,9 @@ class AwesomeStrategy(IStrategy):
    timeframe = "1d"
    timeframe_mins = timeframe_to_minutes(timeframe)
    minimal_roi = {
-        "0": 0.05,                      # 5% for the first 3 candles
-        str(timeframe_mins * 3): 0.02,  # 2% after 3 candles
-        str(timeframe_mins * 6): 0.01,  # 1% After 6 candles
+        "0": 0.05,                             # 5% for the first 3 candles
+        str(timeframe_mins * 3)): 0.02,  # 2% after 3 candles
+        str(timeframe_mins * 6)): 0.01,  # 1% After 6 candles
    }
 ```

@ -381,24 +325,18 @@ stoploss = -0.10

 For the full documentation on stoploss features, look at the dedicated [stoploss page](stoploss.md).

-### Timeframe
+### Timeframe (formerly ticker interval)

 This is the set of candles the bot should download and use for the analysis.
 Common values are `"1m"`, `"5m"`, `"15m"`, `"1h"`, however all values supported by your exchange should work.

-Please note that the same entry/exit signals may work well with one timeframe, but not with the others.
+Please note that the same buy/sell signals may work well with one timeframe, but not with the others.

 This setting is accessible within the strategy methods as the `self.timeframe` attribute.

-### Can short
-
-To use short signals in futures markets, you will have to let us know to do so by setting `can_short=True`.
-Strategies which enable this will fail to load on spot markets.
-Disabling of this will have short signals ignored (also in futures markets).
-
 ### Metadata dict

-The metadata-dict (available for `populate_entry_trend`, `populate_exit_trend`, `populate_indicators`) contains additional information.
+The metadata-dict (available for `populate_buy_trend`, `populate_sell_trend`, `populate_indicators`) contains additional information.
 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.
@ -444,21 +382,6 @@ A full sample can be found [in the DataProvider section](#complete-data-provider
    It is however better to use resampling to longer timeframes whenever possible
    to avoid hammering the exchange with too many requests and risk being blocked.

-??? Note "Alternative candle types"
-    Informative_pairs can also provide a 3rd tuple element defining the candle type explicitly.
-    Availability of alternative candle-types will depend on the trading-mode and the exchange. 
-    In general, spot pairs cannot be used in futures markets, and futures candles can't be used as informative pairs for spot bots.
-    Details about this may vary, if they do, this can be found in the exchange documentation.
-
-    ``` python
-    def informative_pairs(self):
-        return [
-            ("ETH/USDT", "5m", ""),   # Uses default candletype, depends on trading_mode (recommended)
-            ("ETH/USDT", "5m", "spot"),   # Forces usage of spot candles (only valid for bots running on spot markets).
-            ("BTC/TUSD", "15m", "futures"),  # Uses futures candles (only bots with `trading_mode=futures`)
-            ("BTC/TUSD", "15m", "mark"),  # Uses mark candles (only bots with `trading_mode=futures`)
-        ]
-    ```
 ***

 ### Informative pairs decorator (`@informative()`)
@ -472,8 +395,6 @@ for more information.
    ``` python
    def informative(timeframe: str, asset: str = '',
                    fmt: Optional[Union[str, Callable[[KwArg(str)], str]]] = None,
-                    *,
-                    candle_type: Optional[CandleType] = None,
                    ffill: bool = True) -> Callable[[PopulateIndicators], PopulateIndicators]:
        """
        A decorator for populate_indicators_Nn(self, dataframe, metadata), allowing these functions to
@ -502,7 +423,6 @@ for more information.
        * {column} - name of dataframe column.
        * {timeframe} - timeframe of informative dataframe.
        :param ffill: ffill dataframe after merging informative pair.
-        :param candle_type: '', mark, index, premiumIndex, or funding_rate
        """
    ```

@ -531,7 +451,7 @@ for more information.

        # Define BTC/STAKE informative pair. Available in populate_indicators and other methods as
        # 'btc_rsi_1h'. Current stake currency should be specified as {stake} format variable 
-        # instead of hard-coding actual stake currency. Available in populate_indicators and other 
+        # instead of hardcoding actual stake currency. Available in populate_indicators and other 
        # methods as 'btc_usdt_rsi_1h' (when stake currency is USDT).
        @informative('1h', 'BTC/{stake}')
        def populate_indicators_btc_1h(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
@ -570,7 +490,7 @@ for more information.
    Use string formatting when accessing informative dataframes of other pairs. This will allow easily changing stake currency in config without having to adjust strategy code.

    ``` python
-    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        stake = self.config['stake_currency']
        dataframe.loc[
            (
@ -578,7 +498,7 @@ for more information.
                &
                (dataframe['volume'] > 0)
            ),
-            ['enter_long', 'enter_tag']] = (1, 'buy_signal_rsi')
+            ['buy', 'buy_tag']] = (1, 'buy_signal_rsi')
    
        return dataframe
    ```
@ -590,6 +510,7 @@ for more information.
    will overwrite previously defined method and not produce any errors due to limitations of Python programming language. In such cases you will find that indicators
    created in earlier-defined methods are not available in the dataframe. Carefully review method names and make sure they are unique!

+
 ## Additional data (DataProvider)

 The strategy provides access to the `DataProvider`. This allows you to get additional data to use in your strategy.
@ -620,8 +541,9 @@ Please always check the mode of operation to select the correct method to get da
 ### *available_pairs*

 ``` python
-for pair, timeframe in self.dp.available_pairs:
-    print(f"available {pair}, {timeframe}")
+if self.dp:
+    for pair, timeframe in self.dp.available_pairs:
+        print(f"available {pair}, {timeframe}")
 ```

 ### *current_whitelist()*
@ -632,7 +554,7 @@ 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 `5m` candles into daily candles for use in a 14 day RSI. Most exchanges limit us to just 500-1000 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 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.

@ -648,22 +570,20 @@ This is where calling `self.dp.current_whitelist()` comes in handy.
        return informative_pairs
 ```

-??? Note "Plotting with current_whitelist"
-    Current whitelist is not supported for `plot-dataframe`, as this command is usually used by providing an explicit pairlist - and would therefore make the return values of this method misleading.
-
 ### *get_pair_dataframe(pair, timeframe)*

 ``` python
 # fetch live / historical candle (OHLCV) data for the first informative pair
-inf_pair, inf_timeframe = self.informative_pairs()[0]
-informative = self.dp.get_pair_dataframe(pair=inf_pair,
-                                         timeframe=inf_timeframe)
+if self.dp:
+    inf_pair, inf_timeframe = self.informative_pairs()[0]
+    informative = self.dp.get_pair_dataframe(pair=inf_pair,
+                                             timeframe=inf_timeframe)
 ```

 !!! Warning "Warning about backtesting"
-    In backtesting, `dp.get_pair_dataframe()` behavior differs depending on where it's called.
-    Within `populate_*()` methods, `dp.get_pair_dataframe()` returns the full timerange. Please make sure to not "look into the future" to avoid surprises when running in dry/live mode.
-    Within [callbacks](strategy-callbacks.md), you'll get the full timerange up to the current (simulated) candle.
+    Be careful when using dataprovider in backtesting. `historic_ohlcv()` (and `get_pair_dataframe()`
+    for the backtesting runmode) provides the full time-range in one go,
+    so please be aware of it and make sure to not "look into the future" to avoid surprises when running in dry/live mode.

 ### *get_analyzed_dataframe(pair, timeframe)*

@ -672,22 +592,24 @@ It can also be used in specific callbacks to get the signal that caused the acti

 ``` python
 # fetch current dataframe
-dataframe, last_updated = self.dp.get_analyzed_dataframe(pair=metadata['pair'],
-                                                         timeframe=self.timeframe)
+if self.dp:
+    if self.dp.runmode.value in ('live', 'dry_run'):
+        dataframe, last_updated = self.dp.get_analyzed_dataframe(pair=metadata['pair'],
+                                                                 timeframe=self.timeframe)
 ```

 !!! Note "No data available"
    Returns an empty dataframe if the requested pair was not cached.
-    You can check for this with `if dataframe.empty:` and handle this case accordingly.
    This should not happen when using whitelisted pairs.

 ### *orderbook(pair, maximum)*

 ``` python
-if self.dp.runmode.value in ('live', 'dry_run'):
-    ob = self.dp.orderbook(metadata['pair'], 1)
-    dataframe['best_bid'] = ob['bids'][0][0]
-    dataframe['best_ask'] = ob['asks'][0][0]
+if self.dp:
+    if self.dp.runmode.value in ('live', 'dry_run'):
+        ob = self.dp.orderbook(metadata['pair'], 1)
+        dataframe['best_bid'] = ob['bids'][0][0]
+        dataframe['best_ask'] = ob['asks'][0][0]
 ```

 The orderbook structure is aligned with the order structure from [ccxt](https://github.com/ccxt/ccxt/wiki/Manual#order-book-structure), so the result will look as follows:
@ -716,38 +638,22 @@ Therefore, using `ob['bids'][0][0]` as demonstrated above will result in using t
 ### *ticker(pair)*

 ``` python
-if self.dp.runmode.value in ('live', 'dry_run'):
-    ticker = self.dp.ticker(metadata['pair'])
-    dataframe['last_price'] = ticker['last']
-    dataframe['volume24h'] = ticker['quoteVolume']
-    dataframe['vwap'] = ticker['vwap']
+if self.dp:
+    if self.dp.runmode.value in ('live', 'dry_run'):
+        ticker = self.dp.ticker(metadata['pair'])
+        dataframe['last_price'] = ticker['last']
+        dataframe['volume24h'] = ticker['quoteVolume']
+        dataframe['vwap'] = ticker['vwap']
 ```

 !!! Warning
    Although the ticker data structure is a part of the ccxt Unified Interface, the values returned by this method can
-    vary for different exchanges. For instance, many exchanges do not return `vwap` values, some exchanges
+    vary for different exchanges. For instance, many exchanges do not return `vwap` values, the FTX exchange
    does not always fills in the `last` field (so it can be None), etc. So you need to carefully verify the ticker
    data returned from the exchange and add appropriate error handling / defaults.

 !!! Warning "Warning about backtesting"
-    This method will always return up-to-date values - so usage during backtesting / hyperopt without runmode checks will lead to wrong results.
-
-### Send Notification
-
-The dataprovider `.send_msg()` function allows you to send custom notifications from your strategy.
-Identical notifications will only be sent once per candle, unless the 2nd argument (`always_send`) is set to True.
-
-``` python
-    self.dp.send_msg(f"{metadata['pair']} just got hot!")
-
-    # Force send this notification, avoid caching (Please read warning below!)
-    self.dp.send_msg(f"{metadata['pair']} just got hot!", always_send=True)
-```
-
-Notifications will only be sent in trading modes (Live/Dry-run) - so this method can be called without conditions for backtesting.
-
-!!! Warning "Spamming"
-    You can spam yourself pretty good by setting `always_send=True` in this method. Use this with great care and only in conditions you know will not happen throughout a candle to avoid a message every 5 seconds.
+    This method will always return up-to-date values - so usage during backtesting / hyperopt will lead to wrong results.

 ### Complete Data-provider sample

@ -800,7 +706,7 @@ class SampleStrategy(IStrategy):

        return dataframe

-    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:

        dataframe.loc[
            (
@ -808,7 +714,7 @@ class SampleStrategy(IStrategy):
                (dataframe['rsi_1d'] < 30) &                     # Ensure daily RSI is < 30
                (dataframe['volume'] > 0)                        # Ensure this candle had volume (important for backtesting)
            ),
-            ['enter_long', 'enter_tag']] = (1, 'rsi_cross')
+            'buy'] = 1

 ```

@ -827,8 +733,6 @@ Options:
 - Merge the dataframe without lookahead bias
 - Forward-fill (optional)

-For a full sample, please refer to the [complete data provider example](#complete-data-provider-sample) below.
-
 All columns of the informative dataframe will be available on the returning dataframe in a renamed fashion:

 !!! Example "Column renaming"
@ -881,15 +785,13 @@ All columns of the informative dataframe will be available on the returning data

 ### *stoploss_from_open()*

-Stoploss values returned from `custom_stoploss` must specify a percentage relative to `current_rate`, but sometimes you may want to specify a stoploss relative to the entry point instead. `stoploss_from_open()` is a helper function to calculate a stoploss value that can be returned from `custom_stoploss` which will be equivalent to the desired trade profit above the entry point.
+Stoploss values returned from `custom_stoploss` must specify a percentage relative to `current_rate`, but sometimes you may want to specify a stoploss relative to the open price instead. `stoploss_from_open()` is a helper function to calculate a stoploss value that can be returned from `custom_stoploss` which will be equivalent to the desired percentage above the open price.

 ??? Example "Returning a stoploss relative to the open price from the custom stoploss function"

    Say the open price was $100, and `current_price` is $121 (`current_profit` will be `0.21`).  

-    If we want a stop price at 7% above the open price we can call `stoploss_from_open(0.07, current_profit, False)` which will return `0.1157024793`.  11.57% below $121 is $107, which is the same as 7% above $100.
-
-    This function will consider leverage - so at 10x leverage, the actual stoploss would be 0.7% above $100 (0.7% * 10x = 7%).
+    If we want a stop price at 7% above the open price we can call `stoploss_from_open(0.07, current_profit)` which will return `0.1157024793`.  11.57% below $121 is $107, which is the same as 7% above $100.


    ``` python
@ -909,7 +811,7 @@ Stoploss values returned from `custom_stoploss` must specify a percentage relati

            # once the profit has risen above 10%, keep the stoploss at 7% above the open price
            if current_profit > 0.10:
-                return stoploss_from_open(0.07, current_profit, is_short=trade.is_short, leverage=trade.leverage)
+                return stoploss_from_open(0.07, current_profit)

            return 1

@ -920,7 +822,7 @@ Stoploss values returned from `custom_stoploss` must specify a percentage relati
 !!! Note
    Providing invalid input to `stoploss_from_open()` may produce "CustomStoploss function did not return valid stoploss" warnings.
    This may happen if `current_profit` parameter is below specified `open_relative_stop`. Such situations may arise when closing trade
-    is blocked by `confirm_trade_exit()` method. Warnings can be solved by never blocking stop loss sells by checking `exit_reason` in
+    is blocked by `confirm_trade_exit()` method. Warnings can be solved by never blocking stop loss sells by checking `sell_reason` in
    `confirm_trade_exit()`, or by using `return stoploss_from_open(...) or 1` idiom, which will request to not change stop loss when
    `current_profit < open_relative_stop`.

@ -930,7 +832,7 @@ In some situations it may be confusing to deal with stops relative to current ra

 ??? Example "Returning a stoploss using absolute price from the custom stoploss function"

-    If we want to trail a stop price at 2xATR below current price we can call `stoploss_from_absolute(current_rate - (candle['atr'] * 2), current_rate, is_short=trade.is_short)`.
+    If we want to trail a stop price at 2xATR below current proce we can call `stoploss_from_absolute(current_rate - (candle['atr'] * 2), current_rate)`.

    ``` python

@ -950,20 +852,18 @@ In some situations it may be confusing to deal with stops relative to current ra
                            current_rate: float, current_profit: float, **kwargs) -> float:
            dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
            candle = dataframe.iloc[-1].squeeze()
-            return stoploss_from_absolute(current_rate - (candle['atr'] * 2), current_rate, is_short=trade.is_short)
+            return stoploss_from_absolute(current_rate - (candle['atr'] * 2), current_rate)

    ```

 ## Additional data (Wallets)

-The strategy provides access to the `wallets` object. This contains the current balances on the exchange.
+The strategy provides access to the `Wallets` object. This contains the current balances on the exchange.

-!!! Note "Backtesting / Hyperopt"
-    Wallets behaves differently depending on the function it's called.
-    Within `populate_*()` methods, it'll return the full wallet as configured.
-    Within [callbacks](strategy-callbacks.md), you'll get the wallet state corresponding to the actual simulated wallet at that point in the simulation process.
+!!! Note
+    Wallets is not available during backtesting / hyperopt.

-Please always check if `wallets` is available to avoid failures during backtesting.
+Please always check if `Wallets` is available to avoid failures during backtesting.

 ``` python
 if self.wallets:
@ -993,18 +893,38 @@ from freqtrade.persistence import Trade
 The following example queries for the current pair and trades from today, however other filters can easily be added.

 ``` python
-trades = Trade.get_trades_proxy(pair=metadata['pair'],
-                                open_date=datetime.now(timezone.utc) - timedelta(days=1),
-                                is_open=False,
-            ]).order_by(Trade.close_date).all()
-# Summarize profit for this pair.
-curdayprofit = sum(trade.close_profit for trade in trades)
+if self.config['runmode'].value in ('live', 'dry_run'):
+    trades = Trade.get_trades([Trade.pair == metadata['pair'],
+                               Trade.open_date > datetime.utcnow() - timedelta(days=1),
+                               Trade.is_open.is_(False),
+                ]).order_by(Trade.close_date).all()
+    # Summarize profit for this pair.
+    curdayprofit = sum(trade.close_profit for trade in trades)
 ```

-For a full list of available methods, please consult the [Trade object](trade-object.md) documentation.
+Get amount of stake_currency currently invested in Trades:
+
+``` python
+if self.config['runmode'].value in ('live', 'dry_run'):
+    total_stakes = Trade.total_open_trades_stakes()
+```
+
+Retrieve performance per pair.
+Returns a List of dicts per pair.
+
+``` python
+if self.config['runmode'].value in ('live', 'dry_run'):
+    performance = Trade.get_overall_performance()
+```
+
+Sample return value: ETH/BTC had 5 trades, with a total profit of 1.5% (ratio of 0.015).
+
+``` json
+{'pair': "ETH/BTC", 'profit': 0.015, 'count': 5}
+```

 !!! Warning
-    Trade history is not available in `populate_*` methods during backtesting or hyperopt, and will result in empty results.
+    Trade history is not available during backtesting or hyperopt.

 ## Prevent trades from happening for a specific pair

@ -1040,10 +960,11 @@ from datetime import timedelta, datetime, timezone

 # Within populate indicators (or populate_buy):
 if self.config['runmode'].value in ('live', 'dry_run'):
-    # fetch closed trades for the last 2 days
-    trades = Trade.get_trades_proxy(
-        pair=metadata['pair'], is_open=False, 
-        open_date=datetime.now(timezone.utc) - timedelta(days=2))
+   # fetch closed trades for the last 2 days
+    trades = Trade.get_trades([Trade.pair == metadata['pair'],
+                               Trade.open_date > datetime.utcnow() - timedelta(days=2),
+                               Trade.is_open.is_(False),
+                ]).all()
    # Analyze the conditions you'd like to lock the pair .... will probably be different for every strategy
    sumprofit = sum(trade.close_profit for trade in trades)
    if sumprofit < 0:
@ -1053,16 +974,16 @@ if self.config['runmode'].value in ('live', 'dry_run'):

 ## Print created dataframe

-To inspect the created dataframe, you can issue a print-statement in either `populate_entry_trend()` or `populate_exit_trend()`.
+To inspect the created dataframe, you can issue a print-statement in either `populate_buy_trend()` or `populate_sell_trend()`.
 You may also want to print the pair so it's clear what data is currently shown.

 ``` python
-def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
    dataframe.loc[
        (
            #>> whatever condition<<<
        ),
-        ['enter_long', 'enter_tag']] = (1, 'somestring')
+        'buy'] = 1

    # Print the Analyzed pair
    print(f"result for {metadata['pair']}")
@ -1091,12 +1012,7 @@ The following lists some common patterns which should be avoided to prevent frus

 ### Colliding signals

-When conflicting signals collide (e.g. both `'enter_long'` and `'exit_long'` are 1), freqtrade will do nothing and ignore the entry signal. This will avoid trades that enter, and exit immediately. Obviously, this can potentially lead to missed entries.
-
-The following rules apply, and entry signals will be ignored if more than one of the 3 signals is set:
-
- `enter_long` -> `exit_long`, `enter_short`
- `enter_short` -> `exit_short`, `enter_long`
+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

--- a/docs/strategy_analysis_example.md
+++ b/docs/strategy_analysis_example.md
@ -2,52 +2,27 @@

 Debugging a strategy can be time-consuming. Freqtrade offers helper functions to visualize raw data.
 The following assumes you work with SampleStrategy, data for 5m timeframe from Binance and have downloaded them into the data directory in the default location.
-Please follow the [documentation](https://www.freqtrade.io/en/stable/data-download/) for more details.

 ## Setup

-### Change Working directory to repository root
-

 ```python
-import os
 from pathlib import Path
-
-# Change directory
-# Modify this cell to insure that the output shows the correct path.
-# Define all paths relative to the project root shown in the cell output
-project_root = "somedir/freqtrade"
-i=0
-try:
-    os.chdirdir(project_root)
-    assert Path('LICENSE').is_file()
-except:
-    while i<4 and (not Path('LICENSE').is_file()):
-        os.chdir(Path(Path.cwd(), '../'))
-        i+=1
-    project_root = Path.cwd()
-print(Path.cwd())
-```
-
-### Configure Freqtrade environment
-
-
-```python
 from freqtrade.configuration import Configuration

 # Customize these according to your needs.

 # Initialize empty configuration object
 config = Configuration.from_files([])
-# Optionally (recommended), use existing configuration file
-# config = Configuration.from_files(["user_data/config.json"])
+# Optionally, use existing configuration file
+# config = Configuration.from_files(["config.json"])

 # Define some constants
 config["timeframe"] = "5m"
 # Name of the strategy class
 config["strategy"] = "SampleStrategy"
 # Location of the data
-data_location = config["datadir"]
+data_location = Path(config['user_data_dir'], 'data', 'binance')
 # Pair to analyze - Only use one pair here
 pair = "BTC/USDT"
 ```
@ -56,17 +31,15 @@ pair = "BTC/USDT"
 ```python
 # Load data using values set above
 from freqtrade.data.history import load_pair_history
-from freqtrade.enums import CandleType

 candles = load_pair_history(datadir=data_location,
                            timeframe=config["timeframe"],
                            pair=pair,
-                            data_format = "json",  # Make sure to update this to your data
-                            candle_type=CandleType.SPOT,
+                            data_format = "hdf5",
                            )

 # Confirm success
-print(f"Loaded {len(candles)} rows of data for {pair} from {data_location}")
+print("Loaded " + str(len(candles)) + f" rows of data for {pair} from {data_location}")
 candles.head()
 ```

@ -80,7 +53,6 @@ from freqtrade.resolvers import StrategyResolver
 from freqtrade.data.dataprovider import DataProvider
 strategy = StrategyResolver.load_strategy(config)
 strategy.dp = DataProvider(config, None, None)
-strategy.ft_bot_start()

 # Generate buy/sell signals using strategy
 df = strategy.analyze_ticker(candles, {'pair': pair})
@ -101,7 +73,7 @@ df.tail()

 ```python
 # Report results
-print(f"Generated {df['enter_long'].sum()} entry signals")
+print(f"Generated {df['buy'].sum()} buy signals")
 data = df.set_index('date', drop=False)
 data.tail()
 ```
@ -157,7 +129,7 @@ print(stats['strategy_comparison'])
 trades = load_backtest_data(backtest_dir)

 # Show value-counts per pair
-trades.groupby("pair")["exit_reason"].value_counts()
+trades.groupby("pair")["sell_reason"].value_counts()
 ```

 ## Plotting daily profit / equity line
@ -210,7 +182,7 @@ from freqtrade.data.btanalysis import load_trades_from_db
 trades = load_trades_from_db("sqlite:///tradesv3.sqlite")

 # Display results
-trades.groupby("pair")["exit_reason"].value_counts()
+trades.groupby("pair")["sell_reason"].value_counts()
 ```

 ## Analyze the loaded trades for trade parallelism
@ -258,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")

 ```
@ -272,7 +244,7 @@ import plotly.figure_factory as ff
 hist_data = [trades.profit_ratio]
 group_labels = ['profit_ratio']  # name of the dataset

-fig = ff.create_distplot(hist_data, group_labels, bin_size=0.01)
+fig = ff.create_distplot(hist_data, group_labels,bin_size=0.01)
 fig.show()

 ```
--- a/docs/strategy_migration.md
+++ b/docs/strategy_migration.md
@ -1,730 +0,0 @@
-# Strategy Migration between V2 and V3
-
-To support new markets and trade-types (namely short trades / trades with leverage), some things had to change in the interface.
-If you intend on using markets other than spot markets, please migrate your strategy to the new format.
-
-We have put a great effort into keeping compatibility with existing strategies, so if you just want to continue using freqtrade in __spot markets__, there should be no changes necessary for now.
-
-You can use the quick summary as checklist. Please refer to the detailed sections below for full migration details.
-
-## Quick summary / migration checklist
-
-Note : `forcesell`, `forcebuy`, `emergencysell` are changed to `force_exit`, `force_enter`, `emergency_exit` respectively.
-
-* Strategy methods:
-  * [`populate_buy_trend()` -> `populate_entry_trend()`](#populate_buy_trend)
-  * [`populate_sell_trend()` -> `populate_exit_trend()`](#populate_sell_trend)
-  * [`custom_sell()` -> `custom_exit()`](#custom_sell)
-  * [`check_buy_timeout()` -> `check_entry_timeout()`](#custom_entry_timeout)
-  * [`check_sell_timeout()` -> `check_exit_timeout()`](#custom_entry_timeout)
-  * New `side` argument to callbacks without trade object
-    * [`custom_stake_amount`](#custom_stake_amount)
-    * [`confirm_trade_entry`](#confirm_trade_entry)
-    * [`custom_entry_price`](#custom_entry_price)
-  * [Changed argument name in `confirm_trade_exit`](#confirm_trade_exit)
-* Dataframe columns:
-  * [`buy` -> `enter_long`](#populate_buy_trend)
-  * [`sell` -> `exit_long`](#populate_sell_trend)
-  * [`buy_tag` -> `enter_tag` (used for both long and short trades)](#populate_buy_trend)
-  * [New column `enter_short` and corresponding new column `exit_short`](#populate_sell_trend)
-* trade-object now has the following new properties:
-  * `is_short`
-  * `entry_side`
-  * `exit_side`
-  * `trade_direction`
-  * renamed: `sell_reason` -> `exit_reason`
-* [Renamed `trade.nr_of_successful_buys` to `trade.nr_of_successful_entries` (mostly relevant for `adjust_trade_position()`)](#adjust-trade-position-changes)
-* Introduced new [`leverage` callback](strategy-callbacks.md#leverage-callback).
-* Informative pairs can now pass a 3rd element in the Tuple, defining the candle type.
-* `@informative` decorator now takes an optional `candle_type` argument.
-* [helper methods](#helper-methods) `stoploss_from_open` and `stoploss_from_absolute` now take `is_short` as additional argument.
-* `INTERFACE_VERSION` should be set to 3.
-* [Strategy/Configuration settings](#strategyconfiguration-settings).
-  * `order_time_in_force` buy -> entry, sell -> exit.
-  * `order_types` buy -> entry, sell -> exit.
-  * `unfilledtimeout` buy -> entry, sell -> exit.
-  * `ignore_buying_expired_candle_after` -> moved to root level instead of "ask_strategy/exit_pricing"
-* Terminology changes
-  * Sell reasons changed to reflect the new naming of "exit" instead of sells. Be careful in your strategy if you're using `exit_reason` checks and eventually update your strategy.
-    * `sell_signal` -> `exit_signal`
-    * `custom_sell` -> `custom_exit`
-    * `force_sell` -> `force_exit`
-    * `emergency_sell` -> `emergency_exit`
-  * Order pricing
-    * `bid_strategy` -> `entry_pricing`
-    * `ask_strategy` -> `exit_pricing`
-    * `ask_last_balance` -> `price_last_balance`
-    * `bid_last_balance` -> `price_last_balance`
-  * Webhook terminology changed from "sell" to "exit", and from "buy" to entry
-    * `webhookbuy` -> `entry`
-    * `webhookbuyfill` -> `entry_fill`
-    * `webhookbuycancel` -> `entry_cancel`
-    * `webhooksell` -> `exit`
-    * `webhooksellfill` -> `exit_fill`
-    * `webhooksellcancel` -> `exit_cancel`
-  * Telegram notification settings
-    * `buy` -> `entry`
-    * `buy_fill` -> `entry_fill`
-    * `buy_cancel` -> `entry_cancel`
-    * `sell` -> `exit`
-    * `sell_fill` -> `exit_fill`
-    * `sell_cancel` -> `exit_cancel`
-  * Strategy/config settings:
-    * `use_sell_signal` -> `use_exit_signal`
-    * `sell_profit_only` -> `exit_profit_only`
-    * `sell_profit_offset` -> `exit_profit_offset`
-    * `ignore_roi_if_buy_signal` -> `ignore_roi_if_entry_signal`
-    * `forcebuy_enable` -> `force_entry_enable`
-
-## Extensive explanation
-
-### `populate_buy_trend`
-
-In `populate_buy_trend()` - you will want to change the columns you assign from `'buy`' to `'enter_long'`, as well as the method name from `populate_buy_trend` to `populate_entry_trend`.
-
-```python hl_lines="1 9"
-def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
-    dataframe.loc[
-        (
-            (qtpylib.crossed_above(dataframe['rsi'], 30)) &  # Signal: RSI crosses above 30
-            (dataframe['tema'] <= dataframe['bb_middleband']) &  # Guard
-            (dataframe['tema'] > dataframe['tema'].shift(1)) &  # Guard
-            (dataframe['volume'] > 0)  # Make sure Volume is not 0
-        ),
-        ['buy', 'buy_tag']] = (1, 'rsi_cross')
-
-    return dataframe
-```
-
-After:
-
-```python hl_lines="1 9"
-def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
-    dataframe.loc[
-        (
-            (qtpylib.crossed_above(dataframe['rsi'], 30)) &  # Signal: RSI crosses above 30
-            (dataframe['tema'] <= dataframe['bb_middleband']) &  # Guard
-            (dataframe['tema'] > dataframe['tema'].shift(1)) &  # Guard
-            (dataframe['volume'] > 0)  # Make sure Volume is not 0
-        ),
-        ['enter_long', 'enter_tag']] = (1, 'rsi_cross')
-
-    return dataframe
-```
-
-Please refer to the [Strategy documentation](strategy-customization.md#entry-signal-rules) on how to enter and exit short trades.
-
-### `populate_sell_trend`
-
-Similar to `populate_buy_trend`, `populate_sell_trend()` will be renamed to `populate_exit_trend()`.
-We'll also change the column from `'sell'` to `'exit_long'`.
-
-``` python hl_lines="1 9"
-def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
-    dataframe.loc[
-        (
-            (qtpylib.crossed_above(dataframe['rsi'], 70)) &  # Signal: RSI crosses above 70
-            (dataframe['tema'] > dataframe['bb_middleband']) &  # Guard
-            (dataframe['tema'] < dataframe['tema'].shift(1)) &  # Guard
-            (dataframe['volume'] > 0)  # Make sure Volume is not 0
-        ),
-        ['sell', 'exit_tag']] = (1, 'some_exit_tag')
-    return dataframe
-```
-
-After
-
-``` python hl_lines="1 9"
-def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
-    dataframe.loc[
-        (
-            (qtpylib.crossed_above(dataframe['rsi'], 70)) &  # Signal: RSI crosses above 70
-            (dataframe['tema'] > dataframe['bb_middleband']) &  # Guard
-            (dataframe['tema'] < dataframe['tema'].shift(1)) &  # Guard
-            (dataframe['volume'] > 0)  # Make sure Volume is not 0
-        ),
-        ['exit_long', 'exit_tag']] = (1, 'some_exit_tag')
-    return dataframe
-```
-
-Please refer to the [Strategy documentation](strategy-customization.md#exit-signal-rules) on how to enter and exit short trades.
-
-### `custom_sell`
-
-`custom_sell` has been renamed to `custom_exit`.
-It's now also being called for every iteration, independent of current profit and `exit_profit_only` settings.
-
-``` python hl_lines="2"
-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()
-        # ...
-```
-
-``` python hl_lines="2"
-class AwesomeStrategy(IStrategy):
-    def custom_exit(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()
-        # ...
-```
-
-### `custom_entry_timeout`
-
-`check_buy_timeout()` has been renamed to `check_entry_timeout()`, and `check_sell_timeout()` has been renamed to `check_exit_timeout()`.
-
-``` python hl_lines="2 6"
-class AwesomeStrategy(IStrategy):
-    def check_buy_timeout(self, pair: str, trade: 'Trade', order: dict, 
-                            current_time: datetime, **kwargs) -> bool:
-        return False
-
-    def check_sell_timeout(self, pair: str, trade: 'Trade', order: dict, 
-                            current_time: datetime, **kwargs) -> bool:
-        return False 
-```
-
-``` python hl_lines="2 6"
-class AwesomeStrategy(IStrategy):
-    def check_entry_timeout(self, pair: str, trade: 'Trade', order: 'Order', 
-                            current_time: datetime, **kwargs) -> bool:
-        return False
-
-    def check_exit_timeout(self, pair: str, trade: 'Trade', order: 'Order', 
-                            current_time: datetime, **kwargs) -> bool:
-        return False 
-```
-
-### `custom_stake_amount`
-
-New string argument `side` - which can be either `"long"` or `"short"`.
-
-``` python hl_lines="4"
-class AwesomeStrategy(IStrategy):
-    def custom_stake_amount(self, pair: str, current_time: datetime, current_rate: float,
-                            proposed_stake: float, min_stake: Optional[float], max_stake: float,
-                            entry_tag: Optional[str], **kwargs) -> float:
-        # ... 
-        return proposed_stake
-```
-
-``` python hl_lines="4"
-class AwesomeStrategy(IStrategy):
-    def custom_stake_amount(self, pair: str, current_time: datetime, current_rate: float,
-                            proposed_stake: float, min_stake: Optional[float], max_stake: float,
-                            entry_tag: Optional[str], side: str, **kwargs) -> float:
-        # ... 
-        return proposed_stake
-```
-
-### `confirm_trade_entry`
-
-New string argument `side` - which can be either `"long"` or `"short"`.
-
-``` python hl_lines="4"
-class AwesomeStrategy(IStrategy):
-    def confirm_trade_entry(self, pair: str, order_type: str, amount: float, rate: float,
-                            time_in_force: str, current_time: datetime, entry_tag: Optional[str], 
-                            **kwargs) -> bool:
-      return True
-```
-
-After: 
-
-``` python hl_lines="4"
-class AwesomeStrategy(IStrategy):
-    def confirm_trade_entry(self, pair: str, order_type: str, amount: float, rate: float,
-                            time_in_force: str, current_time: datetime, entry_tag: Optional[str], 
-                            side: str, **kwargs) -> bool:
-      return True
-```
-
-### `confirm_trade_exit`
-
-Changed argument `sell_reason` to `exit_reason`.
-For compatibility, `sell_reason` will still be provided for a limited time.
-
-``` python hl_lines="3"
-class AwesomeStrategy(IStrategy):
-    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:
-    return True
-```
-
-After:
-
-``` python hl_lines="3"
-class AwesomeStrategy(IStrategy):
-    def confirm_trade_exit(self, pair: str, trade: Trade, order_type: str, amount: float,
-                           rate: float, time_in_force: str, exit_reason: str,
-                           current_time: datetime, **kwargs) -> bool:
-    return True
-```
-
-### `custom_entry_price`
-
-New string argument `side` - which can be either `"long"` or `"short"`.
-
-``` python hl_lines="3"
-class AwesomeStrategy(IStrategy):
-    def custom_entry_price(self, pair: str, current_time: datetime, proposed_rate: float,
-                           entry_tag: Optional[str], **kwargs) -> float:
-      return proposed_rate
-```
-
-After:
-
-``` python hl_lines="3"
-class AwesomeStrategy(IStrategy):
-    def custom_entry_price(self, pair: str, current_time: datetime, proposed_rate: float,
-                           entry_tag: Optional[str], side: str, **kwargs) -> float:
-      return proposed_rate
-```
-
-### Adjust trade position changes
-
-While adjust-trade-position itself did not change, you should no longer use `trade.nr_of_successful_buys` - and instead use `trade.nr_of_successful_entries`, which will also include short entries.
-
-### Helper methods
-
-Added argument "is_short" to `stoploss_from_open` and `stoploss_from_absolute`.
-This should be given the value of `trade.is_short`.
-
-``` python hl_lines="5 7"
-    def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
-                        current_rate: float, current_profit: float, **kwargs) -> float:
-        # once the profit has risen above 10%, keep the stoploss at 7% above the open price
-        if current_profit > 0.10:
-            return stoploss_from_open(0.07, current_profit)
-
-        return stoploss_from_absolute(current_rate - (candle['atr'] * 2), current_rate)
-
-        return 1
-
-```
-
-After:
-
-``` python hl_lines="5 7"
-    def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
-                        current_rate: float, current_profit: float, **kwargs) -> float:
-        # once the profit has risen above 10%, keep the stoploss at 7% above the open price
-        if current_profit > 0.10:
-            return stoploss_from_open(0.07, current_profit, is_short=trade.is_short)
-
-        return stoploss_from_absolute(current_rate - (candle['atr'] * 2), current_rate, is_short=trade.is_short)
-
-
-```
-
-### Strategy/Configuration settings
-
-#### `order_time_in_force`
-
-`order_time_in_force` attributes changed from `"buy"` to `"entry"` and `"sell"` to `"exit"`.
-
-``` python
-    order_time_in_force: Dict = {
-        "buy": "gtc",
-        "sell": "gtc",
-    }
-```
-
-After:
-
-``` python hl_lines="2 3"
-    order_time_in_force: Dict = {
-        "entry": "GTC",
-        "exit": "GTC",
-    }
-```
-
-#### `order_types`
-
-`order_types` have changed all wordings from `buy` to `entry` - and `sell` to `exit`.
-And two words are joined with `_`. 
-
-``` python hl_lines="2-6"
-    order_types = {
-        "buy": "limit",
-        "sell": "limit",
-        "emergencysell": "market",
-        "forcesell": "market",
-        "forcebuy": "market",
-        "stoploss": "market",
-        "stoploss_on_exchange": false,
-        "stoploss_on_exchange_interval": 60
-    }
-```
-
-After:
-
-``` python hl_lines="2-6"
-    order_types = {
-        "entry": "limit",
-        "exit": "limit",
-        "emergency_exit": "market",
-        "force_exit": "market",
-        "force_entry": "market",
-        "stoploss": "market",
-        "stoploss_on_exchange": false,
-        "stoploss_on_exchange_interval": 60
-    }
-```
-
-#### Strategy level settings
-
-* `use_sell_signal` -> `use_exit_signal`
-* `sell_profit_only` -> `exit_profit_only`
-* `sell_profit_offset` -> `exit_profit_offset`
-* `ignore_roi_if_buy_signal` -> `ignore_roi_if_entry_signal`
-
-``` python hl_lines="2-5"
-    # These values can be overridden in the config.
-    use_sell_signal = True
-    sell_profit_only = True
-    sell_profit_offset: 0.01
-    ignore_roi_if_buy_signal = False
-```
-
-After:
-
-``` python hl_lines="2-5"
-    # These values can be overridden in the config.
-    use_exit_signal = True
-    exit_profit_only = True
-    exit_profit_offset: 0.01
-    ignore_roi_if_entry_signal = False
-```
-
-#### `unfilledtimeout`
-
-`unfilledtimeout` have changed all wordings from `buy` to `entry` - and `sell` to `exit`.
-
-``` python hl_lines="2-3"
-unfilledtimeout = {
-        "buy": 10,
-        "sell": 10,
-        "exit_timeout_count": 0,
-        "unit": "minutes"
-    }
-```
-
-After:
-
-``` python hl_lines="2-3"
-unfilledtimeout = {
-        "entry": 10,
-        "exit": 10,
-        "exit_timeout_count": 0,
-        "unit": "minutes"
-    }
-```
-
-#### `order pricing`
-
-Order pricing changed in 2 ways. `bid_strategy` was renamed to `entry_pricing` and `ask_strategy` was renamed to `exit_pricing`.
-The attributes `ask_last_balance` -> `price_last_balance` and `bid_last_balance` -> `price_last_balance` were renamed as well.
-Also, price-side can now be defined as `ask`, `bid`, `same` or `other`.
-Please refer to the [pricing documentation](configuration.md#prices-used-for-orders) for more information.
-
-``` json hl_lines="2-3 6 12-13 16"
-{
-    "bid_strategy": {
-        "price_side": "bid",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "ask_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "ask_strategy":{
-        "price_side": "ask",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "bid_last_balance": 0.0
-        "ignore_buying_expired_candle_after": 120
-    }
-}
-```
-
-after:
-
-``` json  hl_lines="2-3 6 12-13 16"
-{
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0
-    },
-    "ignore_buying_expired_candle_after": 120
-}
-```
-
-## FreqAI strategy
-
-The `populate_any_indicators()` method has been split into `feature_engineering_expand_all()`, `feature_engineering_expand_basic()`, `feature_engineering_standard()` and`set_freqai_targets()`.
-
-For each new function, the pair (and timeframe where necessary) will be automatically added to the column.
-As such, the definition of features becomes much simpler with the new logic.
-
-For a full explanation of each method, please go to the corresponding [freqAI documentation page](freqai-feature-engineering.md#defining-the-features)
-
-``` python linenums="1" hl_lines="12-37 39-42 63-65 67-75"
-
-def populate_any_indicators(
-        self, pair, df, tf, informative=None, set_generalized_indicators=False
-    ):
-
-        if informative is None:
-            informative = self.dp.get_pair_dataframe(pair, tf)
-
-        # first loop is automatically duplicating indicators for time periods
-        for t in self.freqai_info["feature_parameters"]["indicator_periods_candles"]:
-
-            t = int(t)
-            informative[f"%-{pair}rsi-period_{t}"] = ta.RSI(informative, timeperiod=t)
-            informative[f"%-{pair}mfi-period_{t}"] = ta.MFI(informative, timeperiod=t)
-            informative[f"%-{pair}adx-period_{t}"] = ta.ADX(informative, timeperiod=t)
-            informative[f"%-{pair}sma-period_{t}"] = ta.SMA(informative, timeperiod=t)
-            informative[f"%-{pair}ema-period_{t}"] = ta.EMA(informative, timeperiod=t)
-
-            bollinger = qtpylib.bollinger_bands(
-                qtpylib.typical_price(informative), window=t, stds=2.2
-            )
-            informative[f"{pair}bb_lowerband-period_{t}"] = bollinger["lower"]
-            informative[f"{pair}bb_middleband-period_{t}"] = bollinger["mid"]
-            informative[f"{pair}bb_upperband-period_{t}"] = bollinger["upper"]
-
-            informative[f"%-{pair}bb_width-period_{t}"] = (
-                informative[f"{pair}bb_upperband-period_{t}"]
-                - informative[f"{pair}bb_lowerband-period_{t}"]
-            ) / informative[f"{pair}bb_middleband-period_{t}"]
-            informative[f"%-{pair}close-bb_lower-period_{t}"] = (
-                informative["close"] / informative[f"{pair}bb_lowerband-period_{t}"]
-            )
-
-            informative[f"%-{pair}roc-period_{t}"] = ta.ROC(informative, timeperiod=t)
-
-            informative[f"%-{pair}relative_volume-period_{t}"] = (
-                informative["volume"] / informative["volume"].rolling(t).mean()
-            ) # (1)
-
-        informative[f"%-{pair}pct-change"] = informative["close"].pct_change()
-        informative[f"%-{pair}raw_volume"] = informative["volume"]
-        informative[f"%-{pair}raw_price"] = informative["close"]
-        # (2)
-
-        indicators = [col for col in informative if col.startswith("%")]
-        # This loop duplicates and shifts all indicators to add a sense of recency to data
-        for n in range(self.freqai_info["feature_parameters"]["include_shifted_candles"] + 1):
-            if n == 0:
-                continue
-            informative_shift = informative[indicators].shift(n)
-            informative_shift = informative_shift.add_suffix("_shift-" + str(n))
-            informative = pd.concat((informative, informative_shift), axis=1)
-
-        df = merge_informative_pair(df, informative, self.config["timeframe"], tf, ffill=True)
-        skip_columns = [
-            (s + "_" + tf) for s in ["date", "open", "high", "low", "close", "volume"]
-        ]
-        df = df.drop(columns=skip_columns)
-
-        # Add generalized indicators here (because in live, it will call this
-        # function to populate indicators during training). Notice how we ensure not to
-        # add them multiple times
-        if set_generalized_indicators:
-            df["%-day_of_week"] = (df["date"].dt.dayofweek + 1) / 7
-            df["%-hour_of_day"] = (df["date"].dt.hour + 1) / 25
-            # (3)
-
-            # user adds targets here by prepending them with &- (see convention below)
-            df["&-s_close"] = (
-                df["close"]
-                .shift(-self.freqai_info["feature_parameters"]["label_period_candles"])
-                .rolling(self.freqai_info["feature_parameters"]["label_period_candles"])
-                .mean()
-                / df["close"]
-                - 1
-            )  # (4)
-
-        return df
-```
-
-1. Features - Move to `feature_engineering_expand_all`
-2. Basic features, not expanded across `include_periods_candles` - move to`feature_engineering_expand_basic()`.
-3. Standard features which should not be expanded - move to `feature_engineering_standard()`.
-4. Targets - Move this part to `set_freqai_targets()`.
-
-### freqai - feature engineering expand all
-
-Features will now expand automatically. As such, the expansion loops, as well as the `{pair}` / `{timeframe}` parts will need to be removed.
-
-``` python linenums="1"
-    def feature_engineering_expand_all(self, dataframe, period, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        This function will automatically expand the defined features on the config defined
-        `indicator_periods_candles`, `include_timeframes`, `include_shifted_candles`, and
-        `include_corr_pairs`. In other words, a single feature defined in this function
-        will automatically expand to a total of
-        `indicator_periods_candles` * `include_timeframes` * `include_shifted_candles` *
-        `include_corr_pairs` numbers of features added to the model.
-
-        All features must be prepended with `%` to be recognized by FreqAI internals.
-
-        More details on how these config defined parameters accelerate feature engineering
-        in the documentation at:
-
-        https://www.freqtrade.io/en/latest/freqai-parameter-table/#feature-parameters
-
-        https://www.freqtrade.io/en/latest/freqai-feature-engineering/#defining-the-features
-
-        :param df: strategy dataframe which will receive the features
-        :param period: period of the indicator - usage example:
-        dataframe["%-ema-period"] = ta.EMA(dataframe, timeperiod=period)
-        """
-
-        dataframe["%-rsi-period"] = ta.RSI(dataframe, timeperiod=period)
-        dataframe["%-mfi-period"] = ta.MFI(dataframe, timeperiod=period)
-        dataframe["%-adx-period"] = ta.ADX(dataframe, timeperiod=period)
-        dataframe["%-sma-period"] = ta.SMA(dataframe, timeperiod=period)
-        dataframe["%-ema-period"] = ta.EMA(dataframe, timeperiod=period)
-
-        bollinger = qtpylib.bollinger_bands(
-            qtpylib.typical_price(dataframe), window=period, stds=2.2
-        )
-        dataframe["bb_lowerband-period"] = bollinger["lower"]
-        dataframe["bb_middleband-period"] = bollinger["mid"]
-        dataframe["bb_upperband-period"] = bollinger["upper"]
-
-        dataframe["%-bb_width-period"] = (
-            dataframe["bb_upperband-period"]
-            - dataframe["bb_lowerband-period"]
-        ) / dataframe["bb_middleband-period"]
-        dataframe["%-close-bb_lower-period"] = (
-            dataframe["close"] / dataframe["bb_lowerband-period"]
-        )
-
-        dataframe["%-roc-period"] = ta.ROC(dataframe, timeperiod=period)
-
-        dataframe["%-relative_volume-period"] = (
-            dataframe["volume"] / dataframe["volume"].rolling(period).mean()
-        )
-
-        return dataframe
-
-```
-
-### Freqai - feature engineering basic
-
-Basic features. Make sure to remove the `{pair}` part from your features.
-
-``` python linenums="1"
-    def feature_engineering_expand_basic(self, dataframe, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        This function will automatically expand the defined features on the config defined
-        `include_timeframes`, `include_shifted_candles`, and `include_corr_pairs`.
-        In other words, a single feature defined in this function
-        will automatically expand to a total of
-        `include_timeframes` * `include_shifted_candles` * `include_corr_pairs`
-        numbers of features added to the model.
-
-        Features defined here will *not* be automatically duplicated on user defined
-        `indicator_periods_candles`
-
-        All features must be prepended with `%` to be recognized by FreqAI internals.
-
-        More details on how these config defined parameters accelerate feature engineering
-        in the documentation at:
-
-        https://www.freqtrade.io/en/latest/freqai-parameter-table/#feature-parameters
-
-        https://www.freqtrade.io/en/latest/freqai-feature-engineering/#defining-the-features
-
-        :param df: strategy dataframe which will receive the features
-        dataframe["%-pct-change"] = dataframe["close"].pct_change()
-        dataframe["%-ema-200"] = ta.EMA(dataframe, timeperiod=200)
-        """
-        dataframe["%-pct-change"] = dataframe["close"].pct_change()
-        dataframe["%-raw_volume"] = dataframe["volume"]
-        dataframe["%-raw_price"] = dataframe["close"]
-        return dataframe
-```
-
-### FreqAI - feature engineering standard
-
-``` python linenums="1"
-    def feature_engineering_standard(self, dataframe, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        This optional function will be called once with the dataframe of the base timeframe.
-        This is the final function to be called, which means that the dataframe entering this
-        function will contain all the features and columns created by all other
-        freqai_feature_engineering_* functions.
-
-        This function is a good place to do custom exotic feature extractions (e.g. tsfresh).
-        This function is a good place for any feature that should not be auto-expanded upon
-        (e.g. day of the week).
-
-        All features must be prepended with `%` to be recognized by FreqAI internals.
-
-        More details about feature engineering available:
-
-        https://www.freqtrade.io/en/latest/freqai-feature-engineering
-
-        :param df: strategy dataframe which will receive the features
-        usage example: dataframe["%-day_of_week"] = (dataframe["date"].dt.dayofweek + 1) / 7
-        """
-        dataframe["%-day_of_week"] = dataframe["date"].dt.dayofweek
-        dataframe["%-hour_of_day"] = dataframe["date"].dt.hour
-        return dataframe
-```
-
-### FreqAI - set Targets
-
-Targets now get their own, dedicated method.
-
-``` python linenums="1"
-    def set_freqai_targets(self, dataframe, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        Required function to set the targets for the model.
-        All targets must be prepended with `&` to be recognized by the FreqAI internals.
-
-        More details about feature engineering available:
-
-        https://www.freqtrade.io/en/latest/freqai-feature-engineering
-
-        :param df: strategy dataframe which will receive the targets
-        usage example: dataframe["&-target"] = dataframe["close"].shift(-1) / dataframe["close"]
-        """
-        dataframe["&-s_close"] = (
-            dataframe["close"]
-            .shift(-self.freqai_info["feature_parameters"]["label_period_candles"])
-            .rolling(self.freqai_info["feature_parameters"]["label_period_candles"])
-            .mean()
-            / dataframe["close"]
-            - 1
-            )
-
-        return dataframe
-```
--- a/docs/stylesheets/ft.extra.css
+++ b/docs/stylesheets/ft.extra.css
@ -11,3 +11,18 @@
 .rst-versions .rst-other-versions {
    color: white;
 }
+
+
+#widget-wrapper {
+    height: calc(220px * 0.5625 + 18px);
+    width: 220px;
+    margin: 0 auto 16px auto;
+    border-style: solid;
+    border-color: var(--md-code-bg-color);
+    border-width: 1px;
+    border-radius: 5px;
+}
+
+@media screen and (max-width: calc(76.25em - 1px)) {
+    #widget-wrapper { display: none; }
+}
--- a/docs/telegram-usage.md
+++ b/docs/telegram-usage.md
@ -77,46 +77,40 @@ Example configuration showing the different settings:
    "enabled": true,
    "token": "your_telegram_token",
    "chat_id": "your_telegram_chat_id",
-    "allow_custom_messages": true,
    "notification_settings": {
        "status": "silent",
        "warning": "on",
        "startup": "off",
-        "entry": "silent",
-        "entry_fill": "on",
-        "entry_cancel": "silent",
-        "exit": {
+        "buy": "silent",
+        "sell": {
            "roi": "silent",
-            "emergency_exit": "on",
-            "force_exit": "on",
-            "exit_signal": "silent",
+            "emergency_sell": "on",
+            "force_sell": "on",
+            "sell_signal": "silent",
            "trailing_stop_loss": "on",
            "stop_loss": "on",
            "stoploss_on_exchange": "on",
-            "custom_exit": "silent",
-            "partial_exit": "on"
+            "custom_sell": "silent"
        },
-        "exit_cancel": "on",
-        "exit_fill": "off",
+        "buy_cancel": "silent",
+        "sell_cancel": "on",
+        "buy_fill": "off",
+        "sell_fill": "off",
        "protection_trigger": "off",
-        "protection_trigger_global": "on",
-        "strategy_msg": "off",
-        "show_candle": "off"
+        "protection_trigger_global": "on"
    },
    "reload": true,
    "balance_dust_level": 0.01
 },
 ```

-`entry` notifications are sent when the order is placed, while `entry_fill` notifications are sent when the order is filled on the exchange.
-`exit` notifications are sent when the order is placed, while `exit_fill` notifications are sent when the order is filled on the exchange.
+`buy` notifications are sent when the order is placed, while `buy_fill` notifications are sent when the order is filled on the exchange.
+`sell` notifications are sent when the order is placed, while `sell_fill` notifications are sent when the order is filled on the exchange.
 `*_fill` notifications are off by default and must be explicitly enabled.
 `protection_trigger` notifications are sent when a protection triggers and `protection_trigger_global` notifications trigger when global protections are triggered.
-`strategy_msg` - Receive notifications from the strategy, sent via `self.dp.send_msg()` from the strategy [more details](strategy-customization.md#send-notification).
-`show_candle` - show candle values as part of entry/exit messages. Only possible values are `"ohlc"` or `"off"`.
+

 `balance_dust_level` will define what the `/balance` command takes as "dust" - Currencies with a balance below this will be shown.
-`allow_custom_messages` completely disable strategy messages.
 `reload` allows you to disable reload-buttons on selected messages.

 ## Create a custom keyboard (command shortcut buttons)
@ -141,7 +135,7 @@ You can create your own keyboard in `config.json`:
      "enabled": true,
      "token": "your_telegram_token",
      "chat_id": "your_telegram_chat_id",
-      "keyboard": [
+      "keyboard": [   
          ["/daily", "/stats", "/balance", "/profit"],
          ["/status table", "/performance"],
          ["/reload_config", "/count", "/logs"]
@ -152,7 +146,7 @@ You can create your own keyboard in `config.json`:
 !!! Note "Supported Commands"
    Only the following commands are allowed. Command arguments are not supported!

-    `/start`, `/stop`, `/status`, `/status table`, `/trades`, `/profit`, `/performance`, `/daily`, `/stats`, `/count`, `/locks`, `/balance`, `/stopentry`, `/reload_config`, `/show_config`, `/logs`, `/whitelist`, `/blacklist`, `/edge`, `/help`, `/version`, `/marketdir`
+    `/start`, `/stop`, `/status`, `/status table`, `/trades`, `/profit`, `/performance`, `/daily`, `/stats`, `/count`, `/locks`, `/balance`, `/stopbuy`, `/reload_config`, `/show_config`, `/logs`, `/whitelist`, `/blacklist`, `/edge`, `/help`, `/version`

 ## Telegram commands

@ -162,46 +156,35 @@ official commands. You can ask at any moment for help with `/help`.

 |  Command | Description |
 |----------|-------------|
-| **System commands**
 | `/start` | Starts the trader
 | `/stop` | Stops the trader
-| `/stopbuy | /stopentry` | Stops the trader from opening new trades. Gracefully closes open trades according to their rules.
+| `/stopbuy` | Stops the trader from opening new trades. Gracefully closes open trades according to their rules.
 | `/reload_config` | Reloads the configuration file
 | `/show_config` | Shows part of the current configuration with relevant settings to operation
 | `/logs [limit]` | Show last log messages.
-| `/help` | Show help message
-| `/version` | Show version
-| **Status** |
 | `/status` | Lists all open trades
 | `/status <trade_id>` | Lists one or more specific trade. Separate multiple <trade_id> with a blank space.
 | `/status table` | List all open trades in a table format. Pending buy orders are marked with an asterisk (*) Pending sell orders are marked with a double asterisk (**)
 | `/trades [limit]` | List all recently closed trades in a table format.
+| `/delete <trade_id>` | Delete a specific trade from the Database. Tries to close open orders. Requires manual handling of this trade on the exchange.
 | `/count` | Displays number of trades used and available
 | `/locks` | Show currently locked pairs.
 | `/unlock <pair or lock_id>` | Remove the lock for this pair (or for this lock id).
-| `/marketdir [long | short | even | none]` | Updates the user managed variable that represents the current market direction. If no direction is provided, the currently set direction will be displayed.
-| **Modify Trade states** |
-| `/forceexit <trade_id> | /fx <tradeid>` | Instantly exits the given trade  (Ignoring `minimum_roi`).
-| `/forceexit all | /fx all` | Instantly exits all open trades (Ignoring `minimum_roi`).
-| `/fx` | alias for `/forceexit`
-| `/forcelong <pair> [rate]` | Instantly buys the given pair. Rate is optional and only applies to limit orders. (`force_entry_enable` must be set to True)
-| `/forceshort <pair> [rate]` | Instantly shorts the given pair. Rate is optional and only applies to limit orders. This will only work on non-spot markets. (`force_entry_enable` must be set to True)
-| `/delete <trade_id>` | Delete a specific trade from the Database. Tries to close open orders. Requires manual handling of this trade on the exchange.
-| `/cancel_open_order <trade_id> | /coo <trade_id>` | Cancel an open order for a trade.
-| **Metrics** |
 | `/profit [<n>]` | Display a summary of your profit/loss from close trades and some stats about your performance, over the last n days (all trades by default)
+| `/forcesell <trade_id>` | Instantly sells the given trade  (Ignoring `minimum_roi`).
+| `/forcesell all` | Instantly sells all open trades (Ignoring `minimum_roi`).
+| `/forcebuy <pair> [rate]` | Instantly buys the given pair. Rate is optional and only applies to limit orders. (`forcebuy_enable` must be set to True)
 | `/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 Exit reason as well as Avg. holding durations for buys and sells
-| `/exits` | Shows Wins / losses by Exit reason as well as Avg. holding durations for buys and sells
-| `/entries` | Shows Wins / losses by Exit reason as well as Avg. holding durations for buys and sells
-| `/whitelist [sorted] [baseonly]` | Show the current whitelist. Optionally display in alphabetical order and/or with just the base currency of each pairing.
+| `/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.
 | `/edge` | Show validated pairs by Edge if it is enabled.
-
+| `/help` | Show help message
+| `/version` | Show version

 ## Telegram commands in action

@ -233,28 +216,25 @@ Once all positions are sold, run `/stop` to completely stop the bot.
 ### /status

 For each open trade, the bot will send you the following message.
-Enter Tag is configurable via Strategy.

-> **Trade ID:** `123` `(since 1 days ago)`
-> **Current Pair:** CVC/BTC
-> **Direction:** Long
-> **Leverage:** 1.0
-> **Amount:** `26.64180098`
-> **Enter Tag:** Awesome Long Signal
-> **Open Rate:** `0.00007489`
-> **Current Rate:** `0.00007489`
-> **Unrealized Profit:** `12.95%`
-> **Stoploss:** `0.00007389 (-0.02%)`
+> **Trade ID:** `123` `(since 1 days ago)`  
+> **Current Pair:** CVC/BTC  
+> **Open Since:** `1 days ago`  
+> **Amount:** `26.64180098`  
+> **Open Rate:** `0.00007489`  
+> **Current Rate:** `0.00007489`  
+> **Current Profit:** `12.95%`  
+> **Stoploss:** `0.00007389 (-0.02%)`  

 ### /status table

 Return the status of all open trades in a table format.

 ```
-ID L/S    Pair     Since   Profit
----    --------  -------  --------
-  67 L   SC/BTC    1 d      13.33%
- 123 S   CVC/BTC   1 h      12.95%
+   ID  Pair      Since    Profit
+----  --------  -------  --------
+  67  SC/BTC    1 d      13.33%
+ 123  CVC/BTC   1 h      12.95%
 ```

 ### /count
@ -271,77 +251,63 @@ current    max

 Return a summary of your profit/loss and performance.

-> **ROI:** Close trades
->   ∙ `0.00485701 BTC (2.2%) (15.2 Σ%)`
->   ∙ `62.968 USD`
-> **ROI:** All trades
->   ∙ `0.00255280 BTC (1.5%) (6.43 Σ%)`
->   ∙ `33.095 EUR`
->
-> **Total Trade Count:** `138`
-> **Bot started:** `2022-07-11 18:40:44`
-> **First Trade opened:** `3 days ago`
-> **Latest Trade opened:** `2 minutes ago`
-> **Avg. Duration:** `2:33:45`
-> **Best Performing:** `PAY/BTC: 50.23%`
-> **Trading volume:** `0.5 BTC`
-> **Profit factor:** `1.04`
-> **Max Drawdown:** `9.23% (0.01255 BTC)`
+> **ROI:** Close trades  
+>   ∙ `0.00485701 BTC (2.2%) (15.2 Σ%)`  
+>   ∙ `62.968 USD`  
+> **ROI:** All trades  
+>   ∙ `0.00255280 BTC (1.5%) (6.43 Σ%)`  
+>   ∙ `33.095 EUR`  
+>  
+> **Total Trade Count:** `138`  
+> **First Trade opened:** `3 days ago`  
+> **Latest Trade opened:** `2 minutes ago`  
+> **Avg. Duration:** `2:33:45`  
+> **Best Performing:** `PAY/BTC: 50.23%`  

-The relative profit of `1.2%` is the average profit per trade.
+The relative profit of `1.2%` is the average profit per trade.  
 The relative profit of `15.2 Σ%` is be based on the starting capital - so in this case, the starting capital was `0.00485701 * 1.152 = 0.00738 BTC`.
 Starting capital is either taken from the `available_capital` setting, or calculated by using current wallet size - profits.
-Profit Factor is calculated as gross profits / gross losses - and should serve as an overall metric for the strategy.
-Max drawdown corresponds to the backtesting metric `Absolute Drawdown (Account)` - calculated as `(Absolute Drawdown) / (DrawdownHigh + startingBalance)`.
-Bot started date will refer to the date the bot was first started. For older bots, this will default to the first trade's open date.

-### /forceexit <trade_id>
+### /forcesell <trade_id>

-> **BINANCE:** Exiting BTC/LTC with limit `0.01650000 (profit: ~-4.07%, -0.00008168)`
+> **BITTREX:** Selling BTC/LTC with limit `0.01650000 (profit: ~-4.07%, -0.00008168)`

-!!! Tip
-    You can get a list of all open trades by calling `/forceexit` without parameter, which will show a list of buttons to simply exit a trade.
-    This command has an alias in `/fx` - which has the same capabilities, but is faster to type in "emergency" situations.
+### /forcebuy <pair> [rate]

-### /forcelong <pair> [rate] | /forceshort <pair> [rate]
+> **BITTREX:** Buying ETH/BTC with limit `0.03400000` (`1.000000 ETH`, `225.290 USD`)

-`/forcebuy <pair> [rate]` is also supported for longs but should be considered deprecated.
-
-> **BINANCE:** Long ETH/BTC with limit `0.03400000` (`1.000000 ETH`, `225.290 USD`)
-
-Omitting the pair will open a query asking for the pair to trade (based on the current whitelist).
-Trades created through `/forcelong` will have the buy-tag of `force_entry`.
+Omitting the pair will open a query asking for the pair to buy (based on the current whitelist).

 ![Telegram force-buy screenshot](assets/telegram_forcebuy.png)

-Note that for this to work, `force_entry_enable` needs to be set to true.
+Note that for this to work, `forcebuy_enable` needs to be set to true.

-[More details](configuration.md#understand-force_entry_enable)
+[More details](configuration.md#understand-forcebuy_enable)

 ### /performance

 Return the performance of each crypto-currency the bot has sold.
-> Performance:
-> 1. `RCN/BTC 0.003 BTC (57.77%) (1)`
-> 2. `PAY/BTC 0.0012 BTC (56.91%) (1)`
-> 3. `VIB/BTC 0.0011 BTC (47.07%) (1)`
-> 4. `SALT/BTC 0.0010 BTC (30.24%) (1)`
-> 5. `STORJ/BTC 0.0009 BTC (27.24%) (1)`
-> ...
+> Performance:  
+> 1. `RCN/BTC 0.003 BTC (57.77%) (1)`  
+> 2. `PAY/BTC 0.0012 BTC (56.91%) (1)`  
+> 3. `VIB/BTC 0.0011 BTC (47.07%) (1)`  
+> 4. `SALT/BTC 0.0010 BTC (30.24%) (1)`  
+> 5. `STORJ/BTC 0.0009 BTC (27.24%) (1)`  
+> ...  

 ### /balance

 Return the balance of all crypto-currency your have on the exchange.

-> **Currency:** BTC
-> **Available:** 3.05890234
-> **Balance:** 3.05890234
-> **Pending:** 0.0
+> **Currency:** BTC  
+> **Available:** 3.05890234  
+> **Balance:** 3.05890234  
+> **Pending:** 0.0  

-> **Currency:** CVC
-> **Available:** 86.64180098
-> **Balance:** 86.64180098
-> **Pending:** 0.0
+> **Currency:** CVC  
+> **Available:** 86.64180098  
+> **Balance:** 86.64180098  
+> **Pending:** 0.0  

 ### /daily <n>

@ -349,11 +315,11 @@ Per default `/daily` will return the 7 last days. The example below if for `/dai

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

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

 > **Weekly Profit over the last 3 weeks (starting from Monday):**
 ```
-Monday (count)  Profit BTC      Profit USD   Profit %
-------------  --------------  ------------    ----------
-2018-01-03 (5)  0.00224175 BTC  29,142 USD   4.98%
-2017-12-27 (1)  0.00033131 BTC   4,307 USD   0.00%
-2017-12-20 (4)  0.00269130 BTC  34.986 USD   5.12%
+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>
@ -377,18 +343,18 @@ if for `/monthly 3`:

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

-> Using whitelist `StaticPairList` with 22 pairs
+> Using whitelist `StaticPairList` with 22 pairs  
 > `IOTA/BTC, NEO/BTC, TRX/BTC, VET/BTC, ADA/BTC, ETC/BTC, NCASH/BTC, DASH/BTC, XRP/BTC, XVG/BTC, EOS/BTC, LTC/BTC, OMG/BTC, BTG/BTC, LSK/BTC, ZEC/BTC, HOT/BTC, IOTX/BTC, XMR/BTC, AST/BTC, XLM/BTC, NANO/BTC`

 ### /blacklist [pair]
@ -398,7 +364,7 @@ If Pair is set, then this pair will be added to the pairlist.
 Also supports multiple pairs, separated by a space.
 Use `/reload_config` to reset the blacklist.

-> Using blacklist `StaticPairList` with 2 pairs
+> Using blacklist `StaticPairList` with 2 pairs  
 >`DODGE/BTC`, `HOT/BTC`.

 ### /edge
@ -419,27 +385,3 @@ ARDR/ETH   0.366667      0.143059       -0.01
 ### /version

 > **Version:** `0.14.3`
-
-### /marketdir
-
-If a market direction is provided the command updates the user managed variable that represents the current market direction.
-This variable is not set to any valid market direction on bot startup and must be set by the user. The example below is for `/marketdir long`:
-
-```
-Successfully updated marketdirection from none to long.
-```
-
-If no market direction is provided the command outputs the currently set market directions. The example below is for `/marketdir`:
-
-```
-Currently set marketdirection: even
-```
-
-You can use the market direction in your strategy via `self.market_direction`.
-
-!!! Warning "Bot restarts"
-    Please note that the market direction is not persisted, and will be reset after a bot restart/reload.
-
-!!! Danger "Backtesting"
-    As this value/variable is intended to be changed manually in dry/live trading.
-    Strategies using `market_direction` will probably not produce reliable, reproducible results (changes to this variable will not be reflected for backtesting). Use at your own risk.
--- a/docs/trade-object.md
+++ b/docs/trade-object.md
@ -1,148 +0,0 @@
-# Trade Object
-
-## Trade
-
-A position freqtrade enters is stored in a `Trade` object - which is persisted to the database.
-It's a core concept of freqtrade - and something you'll come across in many sections of the documentation, which will most likely point you to this location.
-
-It will be passed to the strategy in many [strategy callbacks](strategy-callbacks.md). The object passed to the strategy cannot be modified directly. Indirect modifications may occur based on callback results.
-
-## Trade - Available attributes
-
-The following attributes / properties are available for each individual trade - and can be used with `trade.<property>` (e.g. `trade.pair`).
-
-|  Attribute | DataType | Description |
-|------------|-------------|-------------|
-`pair`| string | Pair of this trade
-`is_open`| boolean | Is the trade currently open, or has it been concluded
-`open_rate`| float | Rate this trade was entered at (Avg. entry rate in case of trade-adjustments)
-`close_rate`| float | Close rate - only set when is_open = False
-`stake_amount`| float | Amount in Stake (or Quote) currency.
-`amount`| float | Amount in Asset / Base currency that is currently owned.
-`open_date`| datetime | Timestamp when trade was opened **use `open_date_utc` instead**
-`open_date_utc`| datetime | Timestamp when trade was opened - in UTC
-`close_date`| datetime | Timestamp when trade was closed **use `close_date_utc` instead**
-`close_date_utc`| datetime | Timestamp when trade was closed - in UTC
-`close_profit`| float | Relative profit at the time of trade closure. `0.01` == 1%
-`close_profit_abs`| float | Absolute profit (in stake currency) at the time of trade closure.
-`leverage` | float | Leverage used for this trade - defaults to 1.0 in spot markets.
-`enter_tag`| string | Tag provided on entry via the `enter_tag` column in the dataframe
-`is_short` | boolean | True for short trades, False otherwise
-`orders` | Order[] | List of order objects attached to this trade (includes both filled and cancelled orders)
-`date_last_filled_utc` | datetime | Time of the last filled order
-`entry_side` | "buy" / "sell" | Order Side the trade was entered
-`exit_side` | "buy" / "sell" | Order Side that will result in a trade exit / position reduction.
-`trade_direction` | "long" / "short" | Trade direction in text - long or short.
-`nr_of_successful_entries` | int | Number of successful (filled) entry orders
-`nr_of_successful_exits` | int | Number of successful (filled) exit orders
-
-## Class methods
-
-The following are class methods - which return generic information, and usually result in an explicit query against the database.
-They can be used as `Trade.<method>` - e.g. `open_trades = Trade.get_open_trade_count()`
-
-!!! Warning "Backtesting/hyperopt"
-    Most methods will work in both backtesting / hyperopt and live/dry modes.
-    During backtesting, it's limited to usage in [strategy callbacks](strategy-callbacks.md). Usage in `populate_*()` methods is not supported and will result in wrong results.
-
-### get_trades_proxy
-
-When your strategy needs some information on existing (open or close) trades - it's best to use `Trade.get_trades_proxy()`.
-
-Usage:
-
-``` python
-from freqtrade.persistence import Trade
-from datetime import timedelta
-
-# ...
-trade_hist = Trade.get_trades_proxy(pair='ETH/USDT', is_open=False, open_date=current_date - timedelta(days=2))
-
-```
-
-`get_trades_proxy()` supports the following keyword arguments. All arguments are optional - calling `get_trades_proxy()` without arguments will return a list of all trades in the database.
-
-* `pair` e.g. `pair='ETH/USDT'`
-* `is_open` e.g. `is_open=False`
-* `open_date` e.g. `open_date=current_date - timedelta(days=2)`
-* `close_date` e.g. `close_date=current_date - timedelta(days=5)`
-
-### get_open_trade_count
-
-Get the number of currently open trades
-
-``` python
-from freqtrade.persistence import Trade
-# ...
-open_trades = Trade.get_open_trade_count()
-```
-
-### get_total_closed_profit
-
-Retrieve the total profit the bot has generated so far.
-Aggregates `close_profit_abs` for all closed trades.
-
-``` python
-from freqtrade.persistence import Trade
-
-# ...
-profit = Trade.get_total_closed_profit()
-```
-
-### total_open_trades_stakes
-
-Retrieve the total stake_amount that's currently in trades.
-
-``` python
-from freqtrade.persistence import Trade
-
-# ...
-profit = Trade.total_open_trades_stakes()
-```
-
-### get_overall_performance
-
-Retrieve the overall performance - similar to the `/performance` telegram command.
-
-``` python
-from freqtrade.persistence import Trade
-
-# ...
-if self.config['runmode'].value in ('live', 'dry_run'):
-    performance = Trade.get_overall_performance()
-```
-
-Sample return value: ETH/BTC had 5 trades, with a total profit of 1.5% (ratio of 0.015).
-
-``` json
-{"pair": "ETH/BTC", "profit": 0.015, "count": 5}
-```
-
-## Order Object
-
-An `Order` object represents an order on the exchange (or a simulated order in dry-run mode).
-An `Order` object will always be tied to it's corresponding [`Trade`](#trade-object), and only really makes sense in the context of a trade.
-
-### Order - Available attributes
-
-an Order object is typically attached to a trade.
-Most properties here can be None as they are dependant on the exchange response.
-
-|  Attribute | DataType | Description |
-|------------|-------------|-------------|
-`trade` | Trade | Trade object this order is attached to
-`ft_pair` | string | Pair this order is for
-`ft_is_open` | boolean | is the order filled?
-`order_type` | string | Order type as defined on the exchange - usually market, limit or stoploss
-`status` | string | Status as defined by ccxt. Usually open, closed, expired or canceled
-`side` | string | Buy or Sell
-`price` | float | Price the order was placed at
-`average` | float | Average price the order filled at
-`amount` | float | Amount in base currency
-`filled` | float | Filled amount (in base currency)
-`remaining` | float | Remaining amount
-`cost` | float | Cost of the order - usually average * filled
-`order_date` | datetime | Order creation date **use `order_date_utc` instead**
-`order_date_utc` | datetime | Order creation date (in UTC)
-`order_fill_date` | datetime |  Order fill date **use `order_fill_utc` instead**
-`order_fill_date_utc` | datetime | Order fill date
--- a/docs/updating.md
+++ b/docs/updating.md
@ -2,18 +2,14 @@

 To update your freqtrade installation, please use one of the below methods, corresponding to your installation method.

-!!! Note "Tracking changes"
-    Breaking changes / changed behavior will be documented in the changelog that is posted alongside every release.
-    For the develop branch, please follow PR's to avoid being surprised by changes.
-
-## docker
+## docker-compose

 !!! Note "Legacy installations using the `master` image"
    We're switching from master to stable for the release Images - please adjust your docker-file and replace `freqtradeorg/freqtrade:master` with `freqtradeorg/freqtrade:stable`

 ``` bash
-docker compose pull
-docker compose up -d
+docker-compose pull
+docker-compose up -d
 ```

 ## Installation via setup script
@ -32,17 +28,4 @@ Please ensure that you're also updating dependencies - otherwise things might br
 ``` bash
 git pull
 pip install -U -r requirements.txt
-pip install -e .
-
-# Ensure freqUI is at the latest version
-freqtrade install-ui 
 ```
-
-### Problems updating
-
-Update-problems usually come missing dependencies (you didn't follow the above instructions) - or from updated dependencies, which fail to install (for example TA-lib).
-Please refer to the corresponding installation sections (common problems linked below)
-
-Common problems and their solutions:
-
-* [ta-lib update on windows](windows_installation.md#2-install-ta-lib)
--- a/docs/utils.md
+++ b/docs/utils.md
@ -119,7 +119,6 @@ This subcommand is useful for finding problems in your environment with loading
 usage: freqtrade list-strategies [-h] [-v] [--logfile FILE] [-V] [-c PATH]
                                 [-d PATH] [--userdir PATH]
                                 [--strategy-path PATH] [-1] [--no-color]
-                                 [--recursive-strategy-search]

 optional arguments:
  -h, --help            show this help message and exit
@ -127,9 +126,6 @@ optional arguments:
  -1, --one-column      Print output in one column.
  --no-color            Disable colorization of hyperopt results. May be
                        useful if you are redirecting output to a file.
-  --recursive-strategy-search
-                        Recursively search for a strategy in the strategies
-                        folder.

 Common arguments:
  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
@ -138,10 +134,9 @@ Common arguments:
                        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.
+                        Specify configuration file (default: `config.json`).
+                        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
@ -169,43 +164,6 @@ Example: Search dedicated strategy path.
 freqtrade list-strategies --strategy-path ~/.freqtrade/strategies/
 ```

-## List freqAI models
-
-Use the `list-freqaimodels` subcommand to see all freqAI models available.
-
-This subcommand is useful for finding problems in your environment with loading freqAI models: modules with models that contain errors and failed to load are printed in red (LOAD FAILED), while models with duplicate names are printed in yellow (DUPLICATE NAME).
-
-```
-usage: freqtrade list-freqaimodels [-h] [-v] [--logfile FILE] [-V] [-c PATH]
-                                   [-d PATH] [--userdir PATH]
-                                   [--freqaimodel-path PATH] [-1] [--no-color]
-
-optional arguments:
-  -h, --help            show this help message and exit
-  --freqaimodel-path PATH
-                        Specify additional lookup path for freqaimodels.
-  -1, --one-column      Print output in one column.
-  --no-color            Disable colorization of hyperopt results. May be
-                        useful if you are redirecting output to a file.
-
-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, --data-dir PATH
-                        Path to directory with historical backtesting data.
-  --userdir PATH, --user-data-dir PATH
-                        Path to userdata directory.
-
-```
-
 ## List Exchanges

 Use the `list-exchanges` subcommand to see the exchanges available for the bot.
@ -263,6 +221,7 @@ equos            True     missing opt: fetchTicker, fetchTickers
 eterbase         True
 fcoin            True     missing opt: fetchMyTrades, fetchTickers
 fcoinjp          True     missing opt: fetchMyTrades, fetchTickers
+ftx              True
 gateio           True
 gemini           True
 gopax            True
@ -368,6 +327,7 @@ fcoin               True     missing opt: fetchMyTrades, fetchTickers
 fcoinjp             True     missing opt: fetchMyTrades, fetchTickers
 flowbtc             False    missing: fetchOrder, fetchOHLCV
 foxbit              False    missing: fetchOrder, fetchOHLCV
+ftx                 True
 gateio              True
 gemini              True
 gopax               True
@ -479,15 +439,14 @@ usage: freqtrade list-markets [-h] [-v] [--logfile FILE] [-V] [-c PATH]
                              [-d PATH] [--userdir PATH] [--exchange EXCHANGE]
                              [--print-list] [--print-json] [-1] [--print-csv]
                              [--base BASE_CURRENCY [BASE_CURRENCY ...]]
-                              [--quote QUOTE_CURRENCY [QUOTE_CURRENCY ...]] [-a]
-                              [--trading-mode {spot,margin,futures}]
+                              [--quote QUOTE_CURRENCY [QUOTE_CURRENCY ...]]
+                              [-a]

 usage: freqtrade list-pairs [-h] [-v] [--logfile FILE] [-V] [-c PATH]
                            [-d PATH] [--userdir PATH] [--exchange EXCHANGE]
                            [--print-list] [--print-json] [-1] [--print-csv]
                            [--base BASE_CURRENCY [BASE_CURRENCY ...]]
                            [--quote QUOTE_CURRENCY [QUOTE_CURRENCY ...]] [-a]
-                            [--trading-mode {spot,margin,futures}]

 optional arguments:
  -h, --help            show this help message and exit
@ -504,8 +463,6 @@ optional arguments:
                        Specify quote currency(-ies). Space-separated list.
  -a, --all             Print all pairs or market symbols. By default only
                        active ones are shown.
-  --trading-mode {spot,margin,futures}
-                        Select Trading mode

 Common arguments:
  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
@ -560,27 +517,20 @@ Requires a configuration with specified `pairlists` attribute.
 Can be used to generate static pairlists to be used during backtesting / hyperopt.

 ```
-usage: freqtrade test-pairlist [-h] [--userdir PATH] [-v] [-c PATH]
+usage: freqtrade test-pairlist [-h] [-c PATH]
                               [--quote QUOTE_CURRENCY [QUOTE_CURRENCY ...]]
-                               [-1] [--print-json] [--exchange EXCHANGE]
+                               [-1] [--print-json]

 optional arguments:
  -h, --help            show this help message and exit
-  --userdir PATH, --user-data-dir PATH
-                        Path to userdata directory.
-  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
  -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.
+                        Specify configuration file (default: `config.json`).
+                        Multiple --config options may be used. Can be set to
+                        `-` to read config from stdin.
  --quote QUOTE_CURRENCY [QUOTE_CURRENCY ...]
                        Specify quote currency(-ies). Space-separated list.
  -1, --one-column      Print output in one column.
  --print-json          Print list of pairs or market symbols in JSON format.
-  --exchange EXCHANGE   Exchange name (default: `bittrex`). Only valid if no
-                        config is provided.
-
 ```

 ### Examples
@ -591,27 +541,6 @@ Show whitelist when using a [dynamic pairlist](plugins.md#pairlists).
 freqtrade test-pairlist --config config.json --quote USDT BTC
 ```

-## Convert database
-
-`freqtrade convert-db` can be used to convert your database from one system to another (sqlite -> postgres, postgres -> other postgres), migrating all trades, orders and Pairlocks.
-
-Please refer to the [SQL cheatsheet](sql_cheatsheet.md#use-a-different-database-system) to learn about requirements for different database systems.
-
-```
-usage: freqtrade convert-db [-h] [--db-url PATH] [--db-url-from PATH]
-
-optional arguments:
-  -h, --help          show this help message and exit
-  --db-url PATH       Override trades database URL, this is useful in custom
-                      deployments (default: `sqlite:///tradesv3.sqlite` for
-                      Live Run mode, `sqlite:///tradesv3.dryrun.sqlite` for
-                      Dry Run).
-  --db-url-from PATH  Source db url to use when migrating a database.
-```
-
-!!! Warning
-    Please ensure to only use this on an empty target database. Freqtrade will perform a regular migration, but may fail if entries already existed.
-
 ## Webserver mode

 !!! Warning "Experimental"
@ -648,26 +577,6 @@ Common arguments:

 ```

-### Webserver mode - docker
-
-You can also use webserver mode via docker.
-Starting a one-off container requires the configuration of the port explicitly, as ports are not exposed by default.
-You can use `docker compose run --rm -p 127.0.0.1:8080:8080 freqtrade webserver` to start a one-off container that'll be removed once you stop it. This assumes that port 8080 is still available and no other bot is running on that port.
-
-Alternatively, you can reconfigure the docker-compose file to have the command updated:
-
-``` yml
-    command: >
-      webserver
-      --config /freqtrade/user_data/config.json
-```
-
-You can now use `docker compose up` to start the webserver.
-This assumes that the configuration has a webserver enabled and configured for docker (listening port = `0.0.0.0`).
-
-!!! Tip
-    Don't forget to reset the command back to the trade command if you want to start a live or dry-run bot. 
-
 ## Show previous Backtest results

 Allows you to show previous backtest results.
@ -708,66 +617,6 @@ Common arguments:

 ```

-## Detailed backtest analysis
-
-Advanced backtest result analysis.
-
-More details in the [Backtesting analysis](advanced-backtesting.md#analyze-the-buyentry-and-sellexit-tags) Section.
-
-```
-usage: freqtrade backtesting-analysis [-h] [-v] [--logfile FILE] [-V]
-                                      [-c PATH] [-d PATH] [--userdir PATH]
-                                      [--export-filename PATH]
-                                      [--analysis-groups {0,1,2,3,4} [{0,1,2,3,4} ...]]
-                                      [--enter-reason-list ENTER_REASON_LIST [ENTER_REASON_LIST ...]]
-                                      [--exit-reason-list EXIT_REASON_LIST [EXIT_REASON_LIST ...]]
-                                      [--indicator-list INDICATOR_LIST [INDICATOR_LIST ...]]
-                                      [--timerange YYYYMMDD-[YYYYMMDD]]
-
-optional arguments:
-  -h, --help            show this help message and exit
-  --export-filename PATH, --backtest-filename PATH
-                        Use this filename for backtest results.Requires
-                        `--export` to be set as well. Example: `--export-filen
-                        ame=user_data/backtest_results/backtest_today.json`
-  --analysis-groups {0,1,2,3,4} [{0,1,2,3,4} ...]
-                        grouping output - 0: simple wins/losses by enter tag,
-                        1: by enter_tag, 2: by enter_tag and exit_tag, 3: by
-                        pair and enter_tag, 4: by pair, enter_ and exit_tag
-                        (this can get quite large)
-  --enter-reason-list ENTER_REASON_LIST [ENTER_REASON_LIST ...]
-                        Comma separated list of entry signals to analyse.
-                        Default: all. e.g. 'entry_tag_a,entry_tag_b'
-  --exit-reason-list EXIT_REASON_LIST [EXIT_REASON_LIST ...]
-                        Comma separated list of exit signals to analyse.
-                        Default: all. e.g.
-                        'exit_tag_a,roi,stop_loss,trailing_stop_loss'
-  --indicator-list INDICATOR_LIST [INDICATOR_LIST ...]
-                        Comma separated list of indicators to analyse. e.g.
-                        'close,rsi,bb_lowerband,profit_abs'
-  --timerange YYYYMMDD-[YYYYMMDD]
-                        Timerange to filter trades for analysis, 
-                        start inclusive, end exclusive. e.g.
-                        20220101-20220201
-
-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.
@ -955,47 +804,3 @@ Print trades with id 2 and 3 as json
 ``` bash
 freqtrade show-trades --db-url sqlite:///tradesv3.sqlite --trade-ids 2 3 --print-json
 ```
-
-### Strategy-Updater
-
-Updates listed strategies or all strategies within the strategies folder to be v3 compliant.
-If the command runs without --strategy-list then all strategies inside the strategies folder will be converted.
-Your original strategy will remain available in the `user_data/strategies_orig_updater/` directory.
-
-!!! Warning "Conversion results"
-    Strategy updater will work on a "best effort" approach. Please do your due diligence and verify the results of the conversion.
-    We also recommend to run a python formatter (e.g. `black`) to format results in a sane manner.
-
-```
-usage: freqtrade strategy-updater [-h] [-v] [--logfile FILE] [-V] [-c PATH]
-                                  [-d PATH] [--userdir PATH]
-                                  [--strategy-list STRATEGY_LIST [STRATEGY_LIST ...]]
-
-options:
-  -h, --help            show this help message and exit
-  --strategy-list STRATEGY_LIST [STRATEGY_LIST ...]
-                        Provide a space-separated list of strategies to
-                        backtest. Please note that timeframe needs to be set
-                        either in config or via command line. When using this
-                        together with `--export trades`, the strategy-name is
-                        injected into the filename (so `backtest-data.json`
-                        becomes `backtest-data-SampleStrategy.json`
-
-Common arguments:
-  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
-  --logfile FILE, --log-file 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, --data-dir PATH
-                        Path to directory with historical backtesting data.
-  --userdir PATH, --user-data-dir PATH
-                        Path to userdata directory.
-
-```
--- a/docs/webhook-config.md
+++ b/docs/webhook-config.md
@ -10,37 +10,37 @@ Sample configuration (tested using IFTTT).
  "webhook": {
        "enabled": true,
        "url": "https://maker.ifttt.com/trigger/<YOUREVENT>/with/key/<YOURKEY>/",
-        "entry": {
+        "webhookbuy": {
            "value1": "Buying {pair}",
            "value2": "limit {limit:8f}",
            "value3": "{stake_amount:8f} {stake_currency}"
        },
-        "entry_cancel": {
+        "webhookbuycancel": {
            "value1": "Cancelling Open Buy Order for {pair}",
            "value2": "limit {limit:8f}",
            "value3": "{stake_amount:8f} {stake_currency}"
        },
-         "entry_fill": {
+         "webhookbuyfill": {
            "value1": "Buy Order for {pair} filled",
            "value2": "at {open_rate:8f}",
            "value3": ""
        },
-        "exit": {
-            "value1": "Exiting {pair}",
+        "webhooksell": {
+            "value1": "Selling {pair}",
            "value2": "limit {limit:8f}",
            "value3": "profit: {profit_amount:8f} {stake_currency} ({profit_ratio})"
        },
-        "exit_cancel": {
-            "value1": "Cancelling Open Exit Order for {pair}",
+        "webhooksellcancel": {
+            "value1": "Cancelling Open Sell Order for {pair}",
            "value2": "limit {limit:8f}",
            "value3": "profit: {profit_amount:8f} {stake_currency} ({profit_ratio})"
        },
-        "exit_fill": {
-            "value1": "Exit Order for {pair} filled",
+        "webhooksellfill": {
+            "value1": "Sell Order for {pair} filled",
            "value2": "at {close_rate:8f}.",
            "value3": ""
        },
-        "status": {
+        "webhookstatus": {
            "value1": "Status: {status}",
            "value2": "",
            "value3": ""
@ -57,7 +57,7 @@ You can set the POST body format to Form-Encoded (default), JSON-Encoded, or raw
        "enabled": true,
        "url": "https://<YOURSUBDOMAIN>.cloud.mattermost.com/hooks/<YOURHOOK>",
        "format": "json",
-        "status": {
+        "webhookstatus": {
            "text": "Status: {status}"
        }
    },
@ -88,37 +88,22 @@ Optional parameters are available to enable automatic retries for webhook messag
        "url": "https://<YOURHOOKURL>",
        "retries": 3,
        "retry_delay": 0.2,
-        "status": {
+        "webhookstatus": {
            "status": "Status: {status}"
        }
    },
 ```

-Custom messages can be sent to Webhook endpoints via the `self.dp.send_msg()` function from within the strategy. To enable this, set the `allow_custom_messages` option to `true`:
-
-```json
-  "webhook": {
-        "enabled": true,
-        "url": "https://<YOURHOOKURL>",
-        "allow_custom_messages": true,
-        "strategy_msg": {
-            "status": "StrategyMessage: {msg}"
-        }
-    },
-```
-
 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.

-### Entry
+### Webhookbuy

-The fields in `webhook.entry` are filled when the bot executes a long/short. Parameters are filled using string.format.
+The fields in `webhook.webhookbuy` are filled when the bot executes a buy. Parameters are filled using string.format.
 Possible parameters are:

 * `trade_id`
 * `exchange`
 * `pair`
-* `direction`
-* `leverage`
 * ~~`limit` # Deprecated - should no longer be used.~~
 * `open_rate`
 * `amount`
@ -129,18 +114,16 @@ Possible parameters are:
 * `fiat_currency`
 * `order_type`
 * `current_rate`
-* `enter_tag`
+* `buy_tag`

-### Entry cancel
+### Webhookbuycancel

-The fields in `webhook.entry_cancel` are filled when the bot cancels a long/short order. Parameters are filled using string.format.
+The fields in `webhook.webhookbuycancel` are filled when the bot cancels a buy order. Parameters are filled using string.format.
 Possible parameters are:

 * `trade_id`
 * `exchange`
 * `pair`
-* `direction`
-* `leverage`
 * `limit`
 * `amount`
 * `open_date`
@ -150,18 +133,16 @@ Possible parameters are:
 * `fiat_currency`
 * `order_type`
 * `current_rate`
-* `enter_tag`
+* `buy_tag`

-### Entry fill
+### Webhookbuyfill

-The fields in `webhook.entry_fill` are filled when the bot filled a long/short order. Parameters are filled using string.format.
+The fields in `webhook.webhookbuyfill` are filled when the bot filled a buy order. Parameters are filled using string.format.
 Possible parameters are:

 * `trade_id`
 * `exchange`
 * `pair`
-* `direction`
-* `leverage`
 * `open_rate`
 * `amount`
 * `open_date`
@ -171,18 +152,16 @@ Possible parameters are:
 * `fiat_currency`
 * `order_type`
 * `current_rate`
-* `enter_tag`
+* `buy_tag`

-### Exit
+### Webhooksell

-The fields in `webhook.exit` are filled when the bot exits a trade. Parameters are filled using string.format.
+The fields in `webhook.webhooksell` are filled when the bot sells a trade. Parameters are filled using string.format.
 Possible parameters are:

 * `trade_id`
 * `exchange`
 * `pair`
-* `direction`
-* `leverage`
 * `gain`
 * `limit`
 * `amount`
@ -192,21 +171,19 @@ Possible parameters are:
 * `stake_currency`
 * `base_currency`
 * `fiat_currency`
-* `exit_reason`
+* `sell_reason`
 * `order_type`
 * `open_date`
 * `close_date`

-### Exit fill
+### Webhooksellfill

-The fields in `webhook.exit_fill` are filled when the bot fills a exit order (closes a Trade). Parameters are filled using string.format.
+The fields in `webhook.webhooksellfill` are filled when the bot fills a sell order (closes a Trae). Parameters are filled using string.format.
 Possible parameters are:

 * `trade_id`
 * `exchange`
 * `pair`
-* `direction`
-* `leverage`
 * `gain`
 * `close_rate`
 * `amount`
@ -217,21 +194,19 @@ Possible parameters are:
 * `stake_currency`
 * `base_currency`
 * `fiat_currency`
-* `exit_reason`
+* `sell_reason`
 * `order_type`
 * `open_date`
 * `close_date`

-### Exit cancel
+### Webhooksellcancel

-The fields in `webhook.exit_cancel` are filled when the bot cancels a exit order. Parameters are filled using string.format.
+The fields in `webhook.webhooksellcancel` are filled when the bot cancels a sell order. Parameters are filled using string.format.
 Possible parameters are:

 * `trade_id`
 * `exchange`
 * `pair`
-* `direction`
-* `leverage`
 * `gain`
 * `limit`
 * `amount`
@ -242,71 +217,13 @@ Possible parameters are:
 * `stake_currency`
 * `base_currency`
 * `fiat_currency`
-* `exit_reason`
+* `sell_reason`
 * `order_type`
 * `open_date`
 * `close_date`

-### Status
+### Webhookstatus

-The fields in `webhook.status` are used for regular status messages (Started / Stopped / ...). Parameters are filled using string.format.
+The fields in `webhook.webhookstatus` are used for regular status messages (Started / Stopped / ...). Parameters are filled using string.format.

 The only possible value here is `{status}`.
-
-## Discord
-
-A special form of webhooks is available for discord.
-You can configure this as follows:
-
-```json
-"discord": {
-    "enabled": true,
-    "webhook_url": "https://discord.com/api/webhooks/<Your webhook URL ...>",
-    "exit_fill": [
-        {"Trade ID": "{trade_id}"},
-        {"Exchange": "{exchange}"},
-        {"Pair": "{pair}"},
-        {"Direction": "{direction}"},
-        {"Open rate": "{open_rate}"},
-        {"Close rate": "{close_rate}"},
-        {"Amount": "{amount}"},
-        {"Open date": "{open_date:%Y-%m-%d %H:%M:%S}"},
-        {"Close date": "{close_date:%Y-%m-%d %H:%M:%S}"},
-        {"Profit": "{profit_amount} {stake_currency}"},
-        {"Profitability": "{profit_ratio:.2%}"},
-        {"Enter tag": "{enter_tag}"},
-        {"Exit Reason": "{exit_reason}"},
-        {"Strategy": "{strategy}"},
-        {"Timeframe": "{timeframe}"},
-    ],
-    "entry_fill": [
-        {"Trade ID": "{trade_id}"},
-        {"Exchange": "{exchange}"},
-        {"Pair": "{pair}"},
-        {"Direction": "{direction}"},
-        {"Open rate": "{open_rate}"},
-        {"Amount": "{amount}"},
-        {"Open date": "{open_date:%Y-%m-%d %H:%M:%S}"},
-        {"Enter tag": "{enter_tag}"},
-        {"Strategy": "{strategy} {timeframe}"},
-    ]
-}
-```
-
-The above represents the default (`exit_fill` and `entry_fill` are optional and will default to the above configuration) - modifications are obviously possible.
-
-Available fields correspond to the fields for webhooks and are documented in the corresponding webhook sections.
-
-The notifications will look as follows by default.
-
-![discord-notification](assets/discord_notification.png)
-
-Custom messages can be sent from a strategy to Discord endpoints via the dataprovider.send_msg() function. To enable this, set the `allow_custom_messages` option to `true`:
-
-```json
-  "discord": {
-        "enabled": true,
-        "webhook_url": "https://discord.com/api/webhooks/<Your webhook URL ...>",
-        "allow_custom_messages": true,
-    },
-```
--- a/docs/windows_installation.md
+++ b/docs/windows_installation.md
@ -3,16 +3,15 @@
 We **strongly** recommend that Windows users use [Docker](docker_quickstart.md) as this will work much easier and smoother (also more secure).

 If that is not possible, try using the Windows Linux subsystem (WSL) - for which the Ubuntu instructions should work.
-Otherwise, please follow the instructions below.
+Otherwise, try the instructions below.

 ## Install freqtrade manually

-!!! Note "64bit Python version"
-    Please make sure to use 64bit Windows and 64bit Python to avoid problems with backtesting or hyperopt due to the memory constraints 32bit applications have under Windows.
-    32bit python versions are no longer supported under Windows.
+!!! Note
+    Make sure to use 64bit Windows and 64bit Python to avoid problems with backtesting or hyperopt due to the memory constraints 32bit applications have under Windows.

 !!! Hint
-    Using the [Anaconda Distribution](https://www.anaconda.com/distribution/) under Windows can greatly help with installation problems. Check out the [Anaconda installation section](installation.md#installation-with-conda) in the documentation for more information.
+    Using the [Anaconda Distribution](https://www.anaconda.com/distribution/) under Windows can greatly help with installation problems. Check out the [Anaconda installation section](installation.md#Anaconda) in this document for more information.

 ### 1. Clone the git repository

@ -24,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.25-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.24-cp38-cp38-win_amd64.whl` (make sure to use the version matching your python version).

-Freqtrade provides these dependencies for the latest 3 Python versions (3.8, 3.9, 3.10 and 3.11) and for 64bit Windows.
+Freqtrade provides these dependencies for the latest 3 Python versions (3.8, 3.9 and 3.10) and for 64bit Windows.
 Other versions must be downloaded from the above link.

 ``` powershell
@ -35,7 +34,7 @@ python -m venv .env
 .env\Scripts\activate.ps1
 # optionally install ta-lib from wheel
 # Eventually adjust the below filename to match the downloaded wheel
-pip install --find-links build_helpers\ TA-Lib -U
+pip install build_helpers/TA_Lib-0.4.19-cp38-cp38-win_amd64.whl
 pip install -r requirements.txt
 pip install -e .
 freqtrade
--- a/Show More
+++ b/Show More