Merge pull request #1777 from freqtrade/new_release

Version to 0.18.5

.coveragerc

@@ -2,4 +2,5 @@
 omit =
     scripts/*
     freqtrade/tests/*
-    freqtrade/vendor/*
+    freqtrade/vendor/*
+    freqtrade/__main__.py

.dockerignore

@@ -4,3 +4,12 @@ Dockerfile
 .dockerignore
 config.json*
 *.sqlite
+.coveragerc
+.eggs
+.github
+.pylintrc
+.travis.yml
+CONTRIBUTING.md
+MANIFEST.in
+README.md
+freqtrade.service

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,32 @@
+## Step 1: Have you search for this issue before posting it?
+
+If you have discovered a bug in the bot, please [search our issue tracker](https://github.com/freqtrade/freqtrade/issues?q=is%3Aissue). 
+If it hasn't been reported, please create a new issue.
+
+## Step 2: Describe your environment
+
+  * Python Version: _____ (`python -V`)
+  * CCXT version: _____ (`pip freeze | grep ccxt`)
+  * Branch: Master | Develop
+  * Last Commit ID: _____ (`git log --format="%H" -n 1`)
+  
+## Step 3: Describe the problem:
+
+*Explain the problem you have encountered*
+
+### Steps to reproduce:
+
+  1. _____
+  2. _____
+  3. _____
+  
+### Observed Results:
+
+  * What happened?
+  * What did you expect to happen?
+
+### Relevant code exceptions or logs:
+
+  ```
+  // paste your log here
+  ```

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,15 @@
+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
+
+Solve the issue: #___
+
+## Quick changelog
+
+- <change log #1>
+- <change log #2>
+
+## What's new?
+*Explain in details what this PR solve or improve. You can include visuals.* 

.gitignore

@@ -1,3 +1,15 @@
+# Freqtrade rules
+freqtrade/tests/testdata/*.json
+hyperopt_conf.py
+config*.json
+*.sqlite
+.hyperopt
+logfile.txt
+hyperopt_trials.pickle
+user_data/
+freqtrade-plot.html
+freqtrade-profit-plot.html
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
@@ -69,15 +81,15 @@ target/
 
 # Jupyter Notebook
 .ipynb_checkpoints
+*.ipynb
 
 # pyenv
 .python-version
 
-config.json
-preprocessor.py
-*.sqlite
-
 .env
 .venv
 .idea
 .vscode
+
+.pytest_cache/
+.mypy_cache/

.pylintrc

@@ -1,3 +1,10 @@
+[MASTER]
+extension-pkg-whitelist=numpy,talib,talib.abstract
+
 [BASIC]
 good-names=logger
-ignore=vendor
+ignore=vendor
+
+[TYPECHECK]
+ignored-modules=numpy,talib,talib.abstract
+

.pyup.yml

@@ -0,0 +1,34 @@
+# autogenerated pyup.io config file
+# see https://pyup.io/docs/configuration/ for all available options
+
+# configure updates globally
+# default: all
+# allowed: all, insecure, False
+update: all
+
+# configure dependency pinning globally
+# default: True
+# allowed: True, False
+pin: True
+
+schedule: "every day"
+
+
+search: False
+# Specify requirement files by hand, default is empty
+# default: empty
+# allowed: list
+requirements:
+  - requirements.txt
+  - requirements-dev.txt
+  - requirements-plot.txt
+  - requirements-pi.txt
+
+
+# configure the branch prefix the bot is using
+# default: pyup-
+branch_prefix: pyup/
+
+# allow to close stale PRs
+# default: True
+close_prs: True

.readthedocs.yml

@@ -0,0 +1,8 @@
+# .readthedocs.yml
+
+build:
+  image: latest
+
+python:
+  version: 3.6
+  setup_py_install: false

.travis.yml

@@ -1,12 +1,15 @@
-sudo: false
+sudo: true
 os:
 - linux
+dist: xenial
 language: python
 python:
 - 3.6
+services:
+  - docker
 env:
-  - BACKTEST=
-  - BACKTEST=true
+  global:
+    - IMAGE_NAME=freqtradeorg/freqtrade
 addons:
   apt:
     packages:
@@ -14,16 +17,43 @@ addons:
     - libdw-dev
     - binutils-dev
 install:
-- wget http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz
-- tar zxvf ta-lib-0.4.0-src.tar.gz
-- cd ta-lib && ./configure && sudo make && sudo make install && cd ..
+- cd build_helpers && ./install_ta-lib.sh; cd ..
 - export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH
-- pip install coveralls
-- pip install -r requirements.txt
-script:
-- pytest --cov=freqtrade --cov-config=.coveragerc freqtrade/tests/
-after_success:
-- coveralls
+- pip install --upgrade pytest-random-order
+- pip install -r requirements-dev.txt
+- pip install -e .
+jobs:
+
+  include:
+    - stage: tests
+      script:
+      - pytest --cov=freqtrade --cov-config=.coveragerc freqtrade/tests/
+      # Allow failure for coveralls
+      - coveralls || true
+      name: pytest
+    - script:
+      - cp config.json.example config.json
+      - python freqtrade --datadir freqtrade/tests/testdata backtesting
+      name: backtest
+    - script:
+      - cp config.json.example config.json
+      - python freqtrade --datadir freqtrade/tests/testdata hyperopt -e 5
+      name: hyperopt
+    - script: flake8 freqtrade scripts
+      name: flake8
+    - script: mypy freqtrade scripts
+      name: mypy
+
+    - stage: docker
+      if: branch in (master, develop, feat/improve_travis) AND (type in (push, cron))
+      script:
+        - build_helpers/publish_docker.sh
+      name: "Build and test and push docker image"
+
 notifications:
   slack:
     secure: bKLXmOrx8e2aPZl7W8DA5BdPAXWGpI5UzST33oc1G/thegXcDVmHBTJrBs4sZak6bgAclQQrdZIsRd2eFYzHLalJEaw6pk7hoAw8SvLnZO0ZurWboz7qg2+aZZXfK4eKl/VUe4sM9M4e/qxjkK+yWG7Marg69c4v1ypF7ezUi1fPYILYw8u0paaiX0N5UX8XNlXy+PBlga2MxDjUY70MuajSZhPsY2pDUvYnMY1D/7XN3cFW0g+3O8zXjF0IF4q1Z/1ASQe+eYjKwPQacE+O8KDD+ZJYoTOFBAPllrtpO1jnOPFjNGf3JIbVMZw4bFjIL0mSQaiSUaUErbU3sFZ5Or79rF93XZ81V7uEZ55vD8KMfR2CB1cQJcZcj0v50BxLo0InkFqa0Y8Nra3sbpV4fV5Oe8pDmomPJrNFJnX6ULQhQ1gTCe0M5beKgVms5SITEpt4/Y0CmLUr6iHDT0CUiyMIRWAXdIgbGh1jfaWOMksybeRevlgDsIsNBjXmYI1Sw2ZZR2Eo2u4R6zyfyjOMLwYJ3vgq9IrACv2w5nmf0+oguMWHf6iWi2hiOqhlAN1W74+3HsYQcqnuM3LGOmuCnPprV1oGBqkPXjIFGpy21gNx4vHfO1noLUyJnMnlu2L7SSuN1CdLsnjJ1hVjpJjPfqB4nn8g12x87TqM1bOm+3Q=
+cache:
+  pip: True
+  directories:
+    - /usr/local/lib

CONTRIBUTING.md

@@ -0,0 +1,119 @@
+# Contributing
+
+## Contribute to freqtrade
+
+Feel like our bot is missing a feature? We welcome your pull requests! 
+
+Issues labeled [good first issue](https://github.com/freqtrade/freqtrade/labels/good%20first%20issue) can be good first contributions, and will help get you familiar with the codebase.
+
+Few pointers for contributions:
+
+- Create your PR against the `develop` branch, not `master`.
+- New features need to contain unit tests and must be PEP8 conformant (max-line-length = 100).
+
+If you are unsure, discuss the feature on our [Slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE)
+or in a [issue](https://github.com/freqtrade/freqtrade/issues) before a PR.
+
+## Getting started
+
+Best start by reading the [documentation](https://www.freqtrade.io/) to get a feel for what is possible with the bot, or head straight to the [Developer-documentation](https://www.freqtrade.io/en/latest/developer/) (WIP) which should help you getting started.
+
+## Before sending the PR:
+
+### 1. Run unit tests
+
+All unit tests must pass. If a unit test is broken, change your code to 
+make it pass. It means you have introduced a regression.
+
+#### Test the whole project
+
+```bash
+pytest freqtrade
+```
+
+#### Test only one file
+
+```bash
+pytest freqtrade/tests/test_<file_name>.py
+```
+
+#### Test only one method from one file
+
+```bash
+pytest freqtrade/tests/test_<file_name>.py::test_<method_name>
+```
+
+### 2. Test if your code is PEP8 compliant
+
+#### Run Flake8
+
+```bash
+flake8 freqtrade
+```
+
+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. 
+Guide for installing them is [here](http://flake8.pycqa.org/en/latest/user/using-hooks.html).
+
+### 3. Test if all type-hints are correct
+
+#### Run mypy
+
+``` bash
+mypy freqtrade
+```
+
+## (Core)-Committer Guide
+
+### Process: Pull Requests
+
+How to prioritize pull requests, from most to least important:
+
+1. Fixes for broken tests. Broken means broken on any supported platform or Python version.
+1. Extra tests to cover corner cases.
+1. Minor edits to docs.
+1. Bug fixes.
+1. Major edits to docs.
+1. Features.
+
+Ensure that each pull request meets all requirements in the Contributing document.
+
+### Process: Issues
+
+If an issue is a bug that needs an urgent fix, mark it for the next patch release.
+Then either fix it or mark as please-help.
+
+For other issues: encourage friendly discussion, moderate debate, offer your thoughts.
+
+### Process: Your own code changes
+
+All code changes, regardless of who does them, need to be reviewed and merged by someone else.
+This rule applies to all the core committers.
+
+Exceptions:
+
+- Minor corrections and fixes to pull requests submitted by others.
+- While making a formal release, the release manager can make necessary, appropriate changes.
+- Small documentation changes that reinforce existing subject matter. Most commonly being, but not limited to spelling and grammar corrections.
+
+### Responsibilities
+
+- Ensure cross-platform compatibility for every change that's accepted. Windows, Mac & Linux.
+- Ensure no malicious code is introduced into the core code.
+- Create issues for any major changes and enhancements that you wish to make. Discuss things transparently and get community feedback.
+- Keep feature versions as small as possible, preferably one new feature per version.
+- Be welcoming to newcomers and encourage diverse new contributors from all backgrounds. See the Python Community Code of Conduct (https://www.python.org/psf/codeofconduct/).
+
+### Becoming a Committer
+
+Contributors may be given commit privileges. Preference will be given to those with:
+
+1. Past contributions to FreqTrade and other related open-source projects. Contributions to FreqTrade include both code (both accepted and pending) and friendly participation in the issue tracker and Pull request reviews. Quantity and quality are considered.
+1. A coding style that the other core committers find simple, minimal, and clean.
+1. Access to resources for cross-platform development and testing.
+1. Time to devote to the project regularly.
+
+Beeing a Committer does not grant write permission on `develop` or `master` for security reasons (Users trust FreqTrade with their Exchange API keys).
+
+After beeing Committer for some time, a Committer may be named Core Committer and given full repository access.

Dockerfile

@@ -1,23 +1,26 @@
-FROM python:3.6.2
+FROM python:3.7.3-slim-stretch
 
-# Install TA-lib
-RUN apt-get update && apt-get -y install build-essential && apt-get clean
-RUN curl -L http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz | \
-  tar xzvf - && \
-  cd ta-lib && \
-  ./configure && make && make install && \
-  cd .. && rm -rf ta-lib
-ENV LD_LIBRARY_PATH /usr/local/lib
+RUN apt-get update \
+    && apt-get -y install curl build-essential libssl-dev \
+    && apt-get clean \
+    && pip install --upgrade pip
 
 # Prepare environment
 RUN mkdir /freqtrade
 WORKDIR /freqtrade
 
+# Install TA-lib
+COPY build_helpers/* /tmp/
+RUN cd /tmp && /tmp/install_ta-lib.sh && rm -r /tmp/*ta-lib*
+
+ENV LD_LIBRARY_PATH /usr/local/lib
+
 # Install dependencies
 COPY requirements.txt /freqtrade/
-RUN pip install -r requirements.txt
+RUN pip install numpy --no-cache-dir \
+  && pip install -r requirements.txt --no-cache-dir
 
 # Install and execute
 COPY . /freqtrade/
-RUN pip install -e .
-CMD ["freqtrade"]
+RUN pip install -e . --no-cache-dir
+ENTRYPOINT ["freqtrade"]

Dockerfile.develop

@@ -0,0 +1,9 @@
+FROM freqtradeorg/freqtrade:develop
+
+# Install dependencies
+COPY requirements-dev.txt /freqtrade/
+RUN pip install numpy --no-cache-dir \
+  && pip install -r requirements-dev.txt --no-cache-dir
+
+# Empty the ENTRYPOINT to allow all commands
+ENTRYPOINT []

Dockerfile.pi

@@ -0,0 +1,40 @@
+FROM balenalib/raspberrypi3-debian:stretch
+
+RUN [ "cross-build-start" ]
+
+RUN apt-get update \
+ && apt-get -y install wget curl build-essential libssl-dev libffi-dev \
+ && apt-get clean
+
+# Prepare environment
+RUN mkdir /freqtrade
+WORKDIR /freqtrade
+
+# Install TA-lib
+COPY build_helpers/ta-lib-0.4.0-src.tar.gz /freqtrade/
+RUN tar -xzf /freqtrade/ta-lib-0.4.0-src.tar.gz \
+ && cd /freqtrade/ta-lib/ \
+ && ./configure \
+ && make \
+ && make install \
+ && rm /freqtrade/ta-lib-0.4.0-src.tar.gz
+
+ENV LD_LIBRARY_PATH /usr/local/lib
+
+# Install berryconda
+RUN wget https://github.com/jjhelmus/berryconda/releases/download/v2.0.0/Berryconda3-2.0.0-Linux-armv7l.sh \
+ && bash ./Berryconda3-2.0.0-Linux-armv7l.sh -b \
+ && rm Berryconda3-2.0.0-Linux-armv7l.sh
+
+# Install dependencies
+COPY requirements-pi.txt /freqtrade/
+RUN ~/berryconda3/bin/conda install -y numpy pandas scipy \
+ && ~/berryconda3/bin/pip install -r requirements-pi.txt --no-cache-dir
+
+# Install and execute
+COPY . /freqtrade/
+RUN ~/berryconda3/bin/pip install -e . --no-cache-dir
+
+RUN [ "cross-build-end" ]
+
+ENTRYPOINT ["/root/berryconda3/bin/python","./freqtrade/main.py"]

Dockerfile.technical

@@ -0,0 +1,6 @@
+FROM freqtradeorg/freqtrade:develop
+
+RUN apt-get update \
+    && apt-get -y install git \
+    && apt-get clean \
+    && pip install git+https://github.com/berlinguyinca/technical

README.md

@@ -1,154 +1,199 @@
-# freqtrade
+# Freqtrade
 
-[![Build Status](https://travis-ci.org/gcarq/freqtrade.svg?branch=develop)](https://travis-ci.org/gcarq/freqtrade)
-[![Coverage Status](https://coveralls.io/repos/github/gcarq/freqtrade/badge.svg?branch=develop)](https://coveralls.io/github/gcarq/freqtrade?branch=develop)
+[![Build Status](https://travis-ci.org/freqtrade/freqtrade.svg?branch=develop)](https://travis-ci.org/freqtrade/freqtrade)
+[![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)
 
+Freqtrade is a free and open source crypto trading bot written in Python. It is designed to support all major exchanges and be controlled via Telegram. It contains backtesting, plotting and money management tools as well as strategy optimization by machine learning.
 
-Simple High frequency trading bot for crypto currencies.
-Currently supports trading on Bittrex exchange.
+![freqtrade](https://raw.githubusercontent.com/freqtrade/freqtrade/develop/docs/assets/freqtrade-screenshot.png)
 
-This software is for educational purposes only.
-Don't risk money which you are afraid to lose.
+## Disclaimer
 
-The command interface is accessible via Telegram (not required).
-Just register a new bot on https://telegram.me/BotFather
-and enter the telegram `token` and your `chat_id` in `config.json`
+This software is for educational purposes only. Do not risk money which
+you are afraid to lose. USE THE SOFTWARE AT YOUR OWN RISK. THE AUTHORS
+AND ALL AFFILIATES ASSUME NO RESPONSIBILITY FOR YOUR TRADING RESULTS.
 
-Persistence is achieved through sqlite.
+Always start by running a trading bot in Dry-run and do not engage money
+before you understand how it works and what profit/loss you should
+expect.
 
-### Telegram RPC commands:
-* /start: Starts the trader
-* /stop: Stops the trader
-* /status [table]: Lists all open trades
-* /count: Displays number of open trades
-* /profit: Lists cumulative profit from all finished trades
-* /forcesell <trade_id>: Instantly sells the given trade (Ignoring `minimum_roi`).
-* /performance: Show performance of each finished trade grouped by pair
+We strongly recommend you to have coding and Python knowledge. Do not
+hesitate to read the source code and understand the mechanism of this bot.
 
-### Config
-`minimal_roi` is a JSON object where the key is a duration
-in minutes and the value is the minimum ROI in percent.
-See the example below:
-```
-"minimal_roi": {
-    "50": 0.0,    # Sell after 30 minutes if the profit is not negative
-    "40": 0.01,   # Sell after 25 minutes if there is at least 1% profit
-    "30": 0.02,   # Sell after 15 minutes if there is at least 2% profit
-    "0":  0.045  # Sell immediately if there is at least 4.5% profit
-},
+## Exchange marketplaces supported
+
+- [X] [Bittrex](https://bittrex.com/)
+- [X] [Binance](https://www.binance.com/) ([*Note for binance users](#a-note-on-binance))
+- [ ] [113 others to tests](https://github.com/ccxt/ccxt/). _(We cannot guarantee they will work)_
+
+## Documentation
+
+We invite you to read the bot documentation to ensure you understand how the bot is working.
+
+Please find the complete documentation on our [website](https://www.freqtrade.io).
+
+## Features
+
+- [x] **Based on Python 3.6+**: For botting on any operating system - Windows, macOS and Linux.
+- [x] **Persistence**: Persistence is achieved through sqlite.
+- [x] **Dry-run**: Run the bot without playing 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] **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/latest/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.
+- [x] **Manageable via Telegram**: Manage the bot with Telegram.
+- [x] **Display profit/loss in fiat**: Display your profit/loss in 33 fiat.
+- [x] **Daily summary of profit/loss**: Provide a daily summary of your profit/loss.
+- [x] **Performance status report**: Provide a performance status of your current trades.
+
+## Quick start
+
+Freqtrade provides a Linux/macOS script to install all dependencies and help you to configure the bot.
+
+```bash
+git clone git@github.com:freqtrade/freqtrade.git
+cd freqtrade
+git checkout develop
+./setup.sh --install
 ```
 
-`stoploss` is loss in percentage that should trigger a sale.
-For example value `-0.10` will cause immediate sell if the
-profit dips below -10% for a given trade. This parameter is optional.
+For any other type of installation please refer to [Installation doc](https://www.freqtrade.io/en/latest/installation/).
 
-`initial_state` is an optional field that defines the initial application state.
-Possible values are `running` or `stopped`. (default=`running`)
-If the value is `stopped` the bot has to be started with `/start` first.
 
-`ask_last_balance` sets the bidding price. Value `0.0` will use `ask` price, `1.0` will
-use the `last` price and values between those interpolate between ask and last
-price. Using `ask` price will guarantee quick success in bid, but bot will also
-end up paying more then would probably have been necessary.
+## Basic Usage
 
-The other values should be self-explanatory,
-if not feel free to raise a github issue.
-
-### Prerequisites
-* python3.6
-* sqlite
-* [TA-lib](https://github.com/mrjbq7/ta-lib#dependencies) binaries
-
-### Install
-
-#### Arch Linux
-
-Use your favorite AUR helper and install `python-freqtrade-git`.
-
-#### Manually
-
-`master` branch contains the latest stable release.
-
-`develop` branch has often new features, but might also cause breaking changes. To use it, you are encouraged to join our [slack channel](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE).
+### Bot commands
 
 ```
-$ cd freqtrade/
-# copy example config. Dont forget to insert your api keys
-$ cp config.json.example config.json
-$ python -m venv .env
-$ source .env/bin/activate
-$ pip install -r requirements.txt
-$ pip install -e .
-$ ./freqtrade/main.py
+usage: freqtrade [-h] [-v] [--logfile FILE] [--version] [-c PATH] [-d PATH]
+                 [-s NAME] [--strategy-path PATH] [--dynamic-whitelist [INT]]
+                 [--db-url PATH] [--sd-notify]
+                 {backtesting,edge,hyperopt} ...
+
+Free, open source crypto trading bot
+
+positional arguments:
+  {backtesting,edge,hyperopt}
+    backtesting         Backtesting module.
+    edge                Edge module.
+    hyperopt            Hyperopt module.
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
+  --logfile FILE        Log to the file specified
+  --version             show program's version number and exit
+  -c PATH, --config PATH
+                        Specify configuration file (default: None). Multiple
+                        --config options may be used.
+  -d PATH, --datadir PATH
+                        Path to backtest data.
+  -s NAME, --strategy NAME
+                        Specify strategy class name (default:
+                        DefaultStrategy).
+  --strategy-path PATH  Specify additional strategy lookup path.
+  --dynamic-whitelist [INT]
+                        Dynamically generate and update whitelist based on 24h
+                        BaseVolume (default: 20). DEPRECATED.
+  --db-url PATH         Override trades database URL, this is useful if
+                        dry_run is enabled or in custom deployments (default:
+                        None).
+  --sd-notify           Notify systemd service manager.
 ```
 
-There is also an [article](https://www.sales4k.com/blockchain/high-frequency-trading-bot-tutorial/) about how to setup the bot (thanks [@gurghet](https://github.com/gurghet)).*
+### Telegram RPC commands
 
-\* *Note:* that article was written for an earlier version, so it may be outdated
+Telegram is not mandatory. However, this is a great way to control your bot. More details on our [documentation](https://www.freqtrade.io/en/latest/telegram-usage/)
 
-#### Docker
+- `/start`: Starts the trader
+- `/stop`: Stops the trader
+- `/status [table]`: Lists all open trades
+- `/count`: Displays number of open trades
+- `/profit`: Lists cumulative profit from all finished trades
+- `/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
+- `/help`: Show help message
+- `/version`: Show version
 
-Building the image:
 
-```
-$ cd freqtrade
-$ docker build -t freqtrade .
-```
+## Development branches
 
-For security reasons, your configuration file will not be included in the
-image, you will need to bind mount it. It is also advised to bind mount
-a SQLite database file (see second example) to keep it between updates.
+The project is currently setup in two main branches:
 
-You can run a one-off container that is immediately deleted upon exiting with
-the following command (config.json must be in the current working directory):
+- `develop` - This branch has often new features, but might also cause breaking changes.
+- `master` - This branch contains the latest stable release. The bot 'should' be stable on this branch, and is generally well tested.
+- `feat/*` - These are feature branches, which are being worked on heavily. Please don't use these unless you want to test a specific feature.
 
-```
-$ docker run --rm -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
-```
 
-To run a restartable instance in the background (feel free to place your
-configuration and database files wherever it feels comfortable on your
-filesystem):
+## A note on Binance
 
-```
-$ cd ~/.freq
-$ touch tradesv2.sqlite
-$ docker run -d \
-  --name freqtrade \
-  -v ~/.freq/config.json:/freqtrade/config.json \
-  -v ~/.freq/tradesv2.sqlite:/freqtrade/tradesv2.sqlite \
-  freqtrade
-```
-If you are using `dry_run=True` you need to bind `tradesv2.dry_run.sqlite` instead of `tradesv2.sqlite`.
+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 order unsellable as the expected amount is not there anymore.
 
-You can then use the following commands to monitor and manage your container:
+## Support
 
-```
-$ docker logs freqtrade
-$ docker logs -f freqtrade
-$ docker restart freqtrade
-$ docker stop freqtrade
-$ docker start freqtrade
-```
+### Help / Slack
 
-You do not need to rebuild the image for configuration
-changes, it will suffice to edit `config.json` and restart the container.
+For any questions not covered by the documentation or for further
+information about the bot, we encourage you to join our slack channel.
 
-### Execute tests
+- [Click here to join Slack channel](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE).
 
-```
-$ pytest
-```
-This will by default skip the slow running backtest set. To run backtest set:
+### [Bugs / Issues](https://github.com/freqtrade/freqtrade/issues?q=is%3Aissue)
 
-```
-$ BACKTEST=true pytest -s freqtrade/tests/test_backtesting.py
-```
+If you discover a bug in the bot, please
+[search our issue tracker](https://github.com/freqtrade/freqtrade/issues?q=is%3Aissue)
+first. If it hasn't been reported, please
+[create a new issue](https://github.com/freqtrade/freqtrade/issues/new) and
+ensure you follow the template guide so that our team can assist you as
+quickly as possible.
 
-### Contributing
+### [Feature Requests](https://github.com/freqtrade/freqtrade/labels/enhancement)
 
-Feel like our bot is missing a feature? We welcome your pull requests! Few pointers for contributions:
+Have you a great idea to improve the bot you want to share? Please,
+first search if this feature was not [already discussed](https://github.com/freqtrade/freqtrade/labels/enhancement).
+If it hasn't been requested, please
+[create a new request](https://github.com/freqtrade/freqtrade/issues/new)
+and ensure you follow the template guide so that it does not get lost
+in the bug reports.
 
-- Create your PR against the `develop` branch, not `master`.
-- New features need to contain unit tests.
-- If you are unsure, discuss the feature on [slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE) or in a [issue](https://github.com/gcarq/freqtrade/issues) before a PR.
+### [Pull Requests](https://github.com/freqtrade/freqtrade/pulls)
+
+Feel like our bot is missing a feature? We welcome your pull requests!
+
+Please read our
+[Contributing document](https://github.com/freqtrade/freqtrade/blob/develop/CONTRIBUTING.md)
+to understand the requirements before sending your pull-requests.
+
+Coding is not a neccessity to contribute - maybe start with improving our documentation?
+Issues labeled [good first issue](https://github.com/freqtrade/freqtrade/labels/good%20first%20issue) can be good first contributions, and will help get you familiar with the codebase.
+
+**Note** before starting any major new feature work, *please open an issue describing what you are planning to do* or talk to us on [Slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE). This will ensure that interested parties can give valuable feedback on the feature, and let others know that you are working on it.
+
+**Important:** Always create your PR against the `develop` branch, not `master`.
+
+## Requirements
+
+### Uptodate clock
+
+The clock must be accurate, syncronized to a NTP server very frequently to avoid problems with communication to the exchanges.
+
+### Min hardware required
+
+To run this bot we recommend you a cloud instance with a minimum of:
+
+- Minimal (advised) system requirements: 2GB RAM, 1GB disk space, 2vCPU
+
+### Software requirements
+
+- [Python 3.6.x](http://docs.python-guide.org/en/latest/starting/installation/)
+- [pip](https://pip.pypa.io/en/stable/installing/)
+- [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
+- [TA-Lib](https://mrjbq7.github.io/ta-lib/install.html)
+- [virtualenv](https://virtualenv.pypa.io/en/stable/installation/) (Recommended)
+- [Docker](https://www.docker.com/products/docker) (Recommended)

bin/freqtrade

@@ -1,4 +1,7 @@
 #!/usr/bin/env python3
 
-from freqtrade.main import main
-main()
+import sys
+
+from freqtrade.main import main, set_loggers
+set_loggers()
+main(sys.argv[1:])

build_helpers/install_ta-lib.sh

@@ -0,0 +1,11 @@
+if [ ! -f "/usr/local/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 \
+  && ./configure \
+  && make \
+  && which sudo && sudo make install || make install \
+  && cd ..
+else
+  echo "TA-lib already installed, skipping installation"
+fi

build_helpers/publish_docker.sh

@@ -0,0 +1,60 @@
+#!/bin/sh
+# - export TAG=`if [ "$TRAVIS_BRANCH" == "develop" ]; then echo "latest"; else echo $TRAVIS_BRANCH ; fi`
+# Replace / with _ to create a valid tag
+TAG=$(echo "${TRAVIS_BRANCH}" | sed -e "s/\//_/")
+
+
+# Add commit and commit_message to docker container
+echo "${TRAVIS_COMMIT} ${TRAVIS_COMMIT_MESSAGE}" > freqtrade_commit
+
+if [ "${TRAVIS_EVENT_TYPE}" = "cron" ]; then
+    echo "event ${TRAVIS_EVENT_TYPE}: full rebuild - skipping cache"
+    docker build -t freqtrade:${TAG} .
+else
+    echo "event ${TRAVIS_EVENT_TYPE}: building with cache"
+    # Pull last build to avoid rebuilding the whole image
+    docker pull ${IMAGE_NAME}:${TAG}
+    docker build --cache-from ${IMAGE_NAME}:${TAG} -t freqtrade:${TAG} .
+fi
+
+if [ $? -ne 0 ]; then
+    echo "failed building image"
+    return 1
+fi
+
+# Run backtest
+docker run --rm -it -v $(pwd)/config.json.example:/freqtrade/config.json:ro freqtrade:${TAG} --datadir freqtrade/tests/testdata backtesting
+
+if [ $? -ne 0 ]; then
+    echo "failed running backtest"
+    return 1
+fi
+
+# Tag image for upload
+docker tag freqtrade:$TAG ${IMAGE_NAME}:$TAG
+if [ $? -ne 0 ]; then
+    echo "failed tagging image"
+    return 1
+fi
+
+# Tag as latest for develop builds
+if [ "${TRAVIS_BRANCH}" = "develop" ]; then
+    docker tag freqtrade:$TAG ${IMAGE_NAME}:latest
+fi
+
+# Login
+echo "$DOCKER_PASS" | docker login -u $DOCKER_USER --password-stdin
+
+if [ $? -ne 0 ]; then
+    echo "failed login"
+    return 1
+fi
+
+# Show all available images
+docker images
+
+docker push ${IMAGE_NAME}
+if [ $? -ne 0 ]; then
+    echo "failed pushing repo"
+    return 1
+fi

config.json.example

@@ -2,37 +2,81 @@
     "max_open_trades": 3,
     "stake_currency": "BTC",
     "stake_amount": 0.05,
+    "fiat_display_currency": "USD",
+    "ticker_interval" : "5m",
     "dry_run": false,
-    "minimal_roi": {
-        "50":  0.0,
-        "40":  0.01,
-        "30":  0.02,
-        "0":  0.045
+    "trailing_stop": false,
+    "unfilledtimeout": {
+        "buy": 10,
+        "sell": 30
     },
-    "stoploss": -0.40,
     "bid_strategy": {
-        "ask_last_balance": 0.0
+        "ask_last_balance": 0.0,
+        "use_order_book": false,
+        "order_book_top": 1,
+        "check_depth_of_market": {
+            "enabled": false,
+            "bids_to_ask_delta": 1
+        }
+    },
+    "ask_strategy":{
+        "use_order_book": false,
+        "order_book_min": 1,
+        "order_book_max": 9
     },
     "exchange": {
         "name": "bittrex",
-        "key": "key",
-        "secret": "secret",
+        "key": "your_exchange_key",
+        "secret": "your_exchange_secret",
+        "ccxt_config": {"enableRateLimit": true},
+        "ccxt_async_config": {
+            "enableRateLimit": true,
+            "rateLimit": 500
+        },
         "pair_whitelist": [
-            "BTC_RLC",
-            "BTC_TKN",
-            "BTC_TRST",
-            "BTC_SWT",
-            "BTC_PIVX",
-            "BTC_MLN",
-            "BTC_XZC",
-            "BTC_TIME",
-            "BTC_LUN"
+            "ETH/BTC",
+            "LTC/BTC",
+            "ETC/BTC",
+            "DASH/BTC",
+            "ZEC/BTC",
+            "XLM/BTC",
+            "NXT/BTC",
+            "POWR/BTC",
+            "ADA/BTC",
+            "XMR/BTC"
+        ],
+        "pair_blacklist": [
+            "DOGE/BTC"
         ]
     },
+    "experimental": {
+        "use_sell_signal": false,
+        "sell_profit_only": false,
+        "ignore_roi_if_buy_signal": false
+    },
+    "edge": {
+        "enabled": false,
+        "process_throttle_secs": 3600,
+        "calculate_since_number_of_days": 7,
+        "capital_available_percentage": 0.5,
+        "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": true,
-        "token": "token",
-        "chat_id": "chat_id"
+        "token": "your_telegram_token",
+        "chat_id": "your_telegram_chat_id"
     },
-    "initial_state": "running"
-}
+    "initial_state": "running",
+    "forcebuy_enable": false,
+    "internals": {
+        "process_throttle_secs": 5
+    }
+}

config_binance.json.example

@@ -0,0 +1,84 @@
+{
+    "max_open_trades": 3,
+    "stake_currency": "BTC",
+    "stake_amount": 0.05,
+    "fiat_display_currency": "USD",
+    "ticker_interval" : "5m",
+    "dry_run": true,
+    "trailing_stop": false,
+    "unfilledtimeout": {
+        "buy": 10,
+        "sell": 30
+    },
+    "bid_strategy": {
+        "ask_last_balance": 0.0,
+        "use_order_book": false,
+        "order_book_top": 1,
+        "check_depth_of_market": {
+            "enabled": false,
+            "bids_to_ask_delta": 1
+        }
+    },
+    "ask_strategy":{
+        "use_order_book": false,
+        "order_book_min": 1,
+        "order_book_max": 9
+    },
+    "exchange": {
+        "name": "binance",
+        "key": "your_exchange_key",
+        "secret": "your_exchange_secret",
+        "ccxt_config": {"enableRateLimit": true},
+        "ccxt_async_config": {
+            "enableRateLimit": true,
+            "rateLimit": 200
+        },
+        "pair_whitelist": [
+            "AST/BTC",
+            "ETC/BTC",
+            "ETH/BTC",
+            "EOS/BTC",
+            "IOTA/BTC",
+            "LTC/BTC",
+            "MTH/BTC",
+            "NCASH/BTC",
+            "TNT/BTC",
+            "XMR/BTC",
+            "XLM/BTC",
+            "XRP/BTC"
+        ],
+        "pair_blacklist": [
+            "BNB/BTC"
+        ]
+    },
+    "experimental": {
+        "use_sell_signal": false,
+        "sell_profit_only": false,
+        "ignore_roi_if_buy_signal": false
+    },
+    "edge": {
+        "enabled": false,
+        "process_throttle_secs": 3600,
+        "calculate_since_number_of_days": 7,
+        "capital_available_percentage": 0.5,
+        "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"
+    },
+    "initial_state": "running",
+    "forcebuy_enable": false,
+    "internals": {
+        "process_throttle_secs": 5
+    }
+}

config_full.json.example

@@ -0,0 +1,118 @@
+{
+    "max_open_trades": 3,
+    "stake_currency": "BTC",
+    "stake_amount": 0.05,
+    "fiat_display_currency": "USD",
+    "amount_reserve_percent" : 0.05,
+    "dry_run": false,
+    "ticker_interval": "5m",
+    "trailing_stop": false,
+    "trailing_stop_positive": 0.005,
+    "trailing_stop_positive_offset": 0.0051,
+    "trailing_only_offset_is_reached": false,
+    "minimal_roi": {
+        "40":  0.0,
+        "30":  0.01,
+        "20":  0.02,
+        "0":  0.04
+    },
+    "stoploss": -0.10,
+    "unfilledtimeout": {
+        "buy": 10,
+        "sell": 30
+    },
+    "bid_strategy": {
+        "ask_last_balance": 0.0,
+        "use_order_book": false,
+        "order_book_top": 1,
+        "check_depth_of_market": {
+            "enabled": false,
+            "bids_to_ask_delta": 1
+        }
+    },
+    "ask_strategy":{
+        "use_order_book": false,
+        "order_book_min": 1,
+        "order_book_max": 9
+    },
+    "order_types": {
+        "buy": "limit",
+        "sell": "limit",
+        "stoploss": "market",
+        "stoploss_on_exchange": false,
+        "stoploss_on_exchange_interval": 60
+    },
+    "order_time_in_force": {
+        "buy": "gtc",
+        "sell": "gtc"
+    },
+    "pairlist": {
+        "method": "VolumePairList",
+        "config": {
+            "number_assets": 20,
+            "sort_key": "quoteVolume",
+            "precision_filter": false
+        }
+    },
+    "exchange": {
+        "name": "bittrex",
+        "key": "your_exchange_key",
+        "secret": "your_exchange_secret",
+        "ccxt_config": {"enableRateLimit": true},
+        "ccxt_async_config": {
+            "enableRateLimit": false,
+            "rateLimit": 500,
+            "aiohttp_trust_env": false
+        },
+        "pair_whitelist": [
+            "ETH/BTC",
+            "LTC/BTC",
+            "ETC/BTC",
+            "DASH/BTC",
+            "ZEC/BTC",
+            "XLM/BTC",
+            "NXT/BTC",
+            "POWR/BTC",
+            "ADA/BTC",
+            "XMR/BTC"
+        ],
+        "pair_blacklist": [
+            "DOGE/BTC"
+        ],
+        "outdated_offset": 5,
+        "markets_refresh_interval": 60
+    },
+    "edge": {
+        "enabled": false,
+        "process_throttle_secs": 3600,
+        "calculate_since_number_of_days": 7,
+        "capital_available_percentage": 0.5,
+        "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
+    },
+    "experimental": {
+        "use_sell_signal": false,
+        "sell_profit_only": false,
+        "ignore_roi_if_buy_signal": false
+    },
+    "telegram": {
+        "enabled": true,
+        "token": "your_telegram_token",
+        "chat_id": "your_telegram_chat_id"
+    },
+    "db_url": "sqlite:///tradesv3.sqlite",
+    "initial_state": "running",
+    "forcebuy_enable": false,
+    "internals": {
+        "process_throttle_secs": 5
+    },
+    "strategy": "DefaultStrategy",
+    "strategy_path": "/some/folder/"
+}

config_kraken.json.example

@@ -0,0 +1,71 @@
+{
+    "max_open_trades": 5,
+    "stake_currency": "EUR",
+    "stake_amount": 10,
+    "fiat_display_currency": "EUR",
+    "ticker_interval" : "5m",
+    "dry_run": true,
+    "db_url": "sqlite:///tradesv3.dryrun.sqlite",
+    "trailing_stop": false,
+    "unfilledtimeout": {
+        "buy": 10,
+        "sell": 30
+    },
+    "bid_strategy": {
+        "ask_last_balance": 0.0,
+        "use_order_book": false,
+        "order_book_top": 1,
+        "check_depth_of_market": {
+            "enabled": false,
+            "bids_to_ask_delta": 1
+        }
+    },
+    "ask_strategy":{
+        "use_order_book": false,
+        "order_book_min": 1,
+        "order_book_max": 9
+    },
+    "exchange": {
+        "name": "kraken",
+        "key": "",
+        "secret": "",
+        "ccxt_config": {"enableRateLimit": true},
+        "ccxt_async_config": {
+            "enableRateLimit": true,
+            "rateLimit": 1000
+        },
+        "pair_whitelist": [
+            "ETH/EUR",
+            "BTC/EUR",
+            "BCH/EUR"
+        ],
+        "pair_blacklist": [
+
+        ]
+    },
+    "edge": {
+        "enabled": false,
+        "process_throttle_secs": 3600,
+        "calculate_since_number_of_days": 7,
+        "capital_available_percentage": 0.5,
+        "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": "",
+        "chat_id": ""
+    },
+    "initial_state": "running",
+    "forcebuy_enable": false,
+    "internals": {
+        "process_throttle_secs": 5
+    }
+}

docs/backtesting.md

@@ -0,0 +1,271 @@
+# Backtesting
+
+This page explains how to validate your strategy performance by using
+Backtesting.
+
+## Test your strategy with Backtesting
+
+Now you have good Buy and Sell strategies, 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 (pair) from your config file
+and load static tickers located in
+[/freqtrade/tests/testdata](https://github.com/freqtrade/freqtrade/tree/develop/freqtrade/tests/testdata).
+If the 5 min and 1 min ticker for the crypto-currencies to test is not
+already in the `testdata` folder, backtesting will download them
+automatically. Testdata files will not be updated until you specify it.
+
+The result of backtesting will confirm you if your bot has better odds of making a profit than a loss.
+
+The backtesting is very easy with freqtrade.
+
+### Run a backtesting against the currencies listed in your config file
+#### With 5 min tickers (Per default)
+
+```bash
+python3 freqtrade backtesting
+```
+
+#### With 1 min tickers
+
+```bash
+python3 freqtrade backtesting --ticker-interval 1m
+```
+
+#### Update cached pairs with the latest data
+
+```bash
+python3 freqtrade backtesting --refresh-pairs-cached
+```
+
+#### With live data (do not alter your testdata files)
+
+```bash
+python3 freqtrade backtesting --live
+```
+
+#### Using a different on-disk ticker-data source
+
+```bash
+python3 freqtrade backtesting --datadir freqtrade/tests/testdata-20180101
+```
+
+#### With a (custom) strategy file
+
+```bash
+python3 freqtrade -s TestStrategy backtesting
+```
+
+Where `-s TestStrategy` refers to the class name within the strategy file `test_strategy.py` found in the `freqtrade/user_data/strategies` directory
+
+#### Exporting trades to file
+
+```bash
+python3 freqtrade backtesting --export trades
+```
+
+The exported trades can be used for [further analysis](#further-backtest-result-analysis), or can be used by the plotting script `plot_dataframe.py` in the scripts folder.
+
+#### Exporting trades to file specifying a custom filename
+
+```bash
+python3 freqtrade backtesting --export trades --export-filename=backtest_teststrategy.json
+```
+
+#### Running backtest with smaller testset
+
+Use the `--timerange` argument to change how much of the testset
+you want to use. The last N ticks/timeframes will be used.
+
+Example:
+
+```bash
+python3 freqtrade backtesting --timerange=-200
+```
+
+#### Advanced use of timerange
+
+Doing `--timerange=-200` will get the last 200 timeframes
+from your inputdata. You can also specify specific dates,
+or a range span indexed by start and stop.
+
+The full timerange specification:
+
+- Use last 123 tickframes of data: `--timerange=-123`
+- Use first 123 tickframes of data: `--timerange=123-`
+- Use tickframes from line 123 through 456: `--timerange=123-456`
+- Use tickframes till 2018/01/31: `--timerange=-20180131`
+- Use tickframes since 2018/01/31: `--timerange=20180131-`
+- Use tickframes since 2018/01/31 till 2018/03/01 : `--timerange=20180131-20180301`
+- Use tickframes between POSIX timestamps 1527595200 1527618600:
+                                                `--timerange=1527595200-1527618600`
+
+#### Downloading new set of ticker data
+
+To download new set of backtesting ticker data, you can use a download script.
+
+If you are using Binance for example:
+
+- create a folder `user_data/data/binance` and copy `pairs.json` in that folder.
+- update the `pairs.json` to contain the currency pairs you are interested in.
+
+```bash
+mkdir -p user_data/data/binance
+cp freqtrade/tests/testdata/pairs.json user_data/data/binance
+```
+
+Then run:
+
+```bash
+python scripts/download_backtest_data.py --exchange binance
+```
+
+This will download ticker data for all the currency pairs you defined in `pairs.json`.
+
+- To use a different folder than the exchange specific default, use `--export user_data/data/some_directory`.
+- To change the exchange used to download the tickers, use `--exchange`. Default is `bittrex`.
+- To use `pairs.json` from some other folder, use `--pairs-file some_other_dir/pairs.json`.
+- To download ticker data for only 10 days, use `--days 10`.
+- Use `--timeframes` to specify which tickers to download. Default is `--timeframes 1m 5m` which will download 1-minute and 5-minute tickers.
+
+For help about backtesting usage, please refer to [Backtesting commands](#backtesting-commands).
+
+## Understand the backtesting result
+
+The most important in the backtesting is to understand the result.
+
+A backtesting result will look like that:
+
+```
+========================================================= BACKTESTING REPORT ========================================================
+| pair     |   buy count |   avg profit % |   cum profit % |   tot profit BTC |   tot profit % | avg duration   |   profit |   loss |
+|:---------|------------:|---------------:|---------------:|-----------------:|---------------:|:---------------|---------:|-------:|
+| ADA/BTC  |          35 |          -0.11 |          -3.88 |      -0.00019428 |          -1.94 | 4:35:00        |       14 |     21 |
+| ARK/BTC  |          11 |          -0.41 |          -4.52 |      -0.00022647 |          -2.26 | 2:03:00        |        3 |      8 |
+| BTS/BTC  |          32 |           0.31 |           9.78 |       0.00048938 |           4.89 | 5:05:00        |       18 |     14 |
+| DASH/BTC |          13 |          -0.08 |          -1.07 |      -0.00005343 |          -0.53 | 4:39:00        |        6 |      7 |
+| ENG/BTC  |          18 |           1.36 |          24.54 |       0.00122807 |          12.27 | 2:50:00        |        8 |     10 |
+| EOS/BTC  |          36 |           0.08 |           3.06 |       0.00015304 |           1.53 | 3:34:00        |       16 |     20 |
+| ETC/BTC  |          26 |           0.37 |           9.51 |       0.00047576 |           4.75 | 6:14:00        |       11 |     15 |
+| ETH/BTC  |          33 |           0.30 |           9.96 |       0.00049856 |           4.98 | 7:31:00        |       16 |     17 |
+| IOTA/BTC |          32 |           0.03 |           1.09 |       0.00005444 |           0.54 | 3:12:00        |       14 |     18 |
+| LSK/BTC  |          15 |           1.75 |          26.26 |       0.00131413 |          13.13 | 2:58:00        |        6 |      9 |
+| LTC/BTC  |          32 |          -0.04 |          -1.38 |      -0.00006886 |          -0.69 | 4:49:00        |       11 |     21 |
+| NANO/BTC |          17 |           1.26 |          21.39 |       0.00107058 |          10.70 | 1:55:00        |       10 |      7 |
+| NEO/BTC  |          23 |           0.82 |          18.97 |       0.00094936 |           9.48 | 2:59:00        |       10 |     13 |
+| REQ/BTC  |           9 |           1.17 |          10.54 |       0.00052734 |           5.27 | 3:47:00        |        4 |      5 |
+| XLM/BTC  |          16 |           1.22 |          19.54 |       0.00097800 |           9.77 | 3:15:00        |        7 |      9 |
+| XMR/BTC  |          23 |          -0.18 |          -4.13 |      -0.00020696 |          -2.07 | 5:30:00        |       12 |     11 |
+| XRP/BTC  |          35 |           0.66 |          22.96 |       0.00114897 |          11.48 | 3:49:00        |       12 |     23 |
+| ZEC/BTC  |          22 |          -0.46 |         -10.18 |      -0.00050971 |          -5.09 | 2:22:00        |        7 |     15 |
+| TOTAL    |         429 |           0.36 |         152.41 |       0.00762792 |          76.20 | 4:12:00        |      186 |    243 |
+========================================================= SELL REASON STATS =========================================================
+| Sell Reason        |   Count |
+|:-------------------|--------:|
+| trailing_stop_loss |     205 |
+| stop_loss          |     166 |
+| sell_signal        |      56 |
+| force_sell         |       2 |
+====================================================== LEFT OPEN TRADES REPORT ======================================================
+| pair     |   buy count |   avg profit % |   cum profit % |   tot profit BTC |   tot profit % | avg duration   |   profit |   loss |
+|:---------|------------:|---------------:|---------------:|-----------------:|---------------:|:---------------|---------:|-------:|
+| ADA/BTC  |           1 |           0.89 |           0.89 |       0.00004434 |           0.44 | 6:00:00        |        1 |      0 |
+| LTC/BTC  |           1 |           0.68 |           0.68 |       0.00003421 |           0.34 | 2:00:00        |        1 |      0 |
+| TOTAL    |           2 |           0.78 |           1.57 |       0.00007855 |           0.78 | 4:00:00        |        2 |      0 |
+```
+
+The 1st table will contain all trades the bot made.
+
+The 2nd table will contain a recap of sell reasons.
+
+The 3rd table will contain all trades the bot had to `forcesell` at the end of the backtest period to present a full picture.
+These trades are also included in the first table, but are extracted separately for clarity.
+
+The last line will give you the overall performance of your strategy,
+here:
+
+```
+| TOTAL    |         429 |           0.36 |         152.41 |       0.00762792 |          76.20 | 4:12:00        |      186 |    243 |
+```
+
+We understand the bot has made `429` trades for an average duration of
+`4:12:00`, with a performance of `76.20%` (profit), that means it has
+earned a total of `0.00762792 BTC` starting with a capital of 0.01 BTC.
+
+The column `avg profit %` shows the average profit for all trades made while the column `cum profit %` sums all the profits/losses. 
+The column `tot profit %` shows instead the total profit % in relation to allocated capital 
+(`max_open_trades * stake_amount`). In the above results we have `max_open_trades=2 stake_amount=0.005` in config 
+so `(76.20/100) * (0.005 * 2) =~ 0.00762792 BTC`.
+
+As you will see your strategy performance will be influenced by your buy
+strategy, your sell strategy, and also by the `minimal_roi` and
+`stop_loss` you have set.
+
+As for an 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 will reach 1%).
+
+```json
+"minimal_roi": {
+    "0":  0.01
+},
+```
+
+On the other hand, if you set a too high `minimal_roi` like `"0":  0.55`
+(55%), there is a lot of chance that the bot will never reach this
+profit. Hence, keep in mind that your performance is a mix of your
+strategies, your configuration, and the crypto-currency you have set up.
+
+### Further backtest-result analysis
+
+To further analyze your backtest results, you can [export the trades](#exporting-trades-to-file).
+You can then load the trades to perform further analysis.
+
+A good way for this is using Jupyter (notebook or lab) - which provides an interactive environment to analyze the data.
+
+Freqtrade provides an easy to load the backtest results, which is `load_backtest_data` - and takes a path to the backtest-results file.
+
+``` python
+from freqtrade.data.btanalysis import load_backtest_data
+df = load_backtest_data("user_data/backtest-result.json")
+
+# Show value-counts per pair
+df.groupby("pair")["sell_reason"].value_counts()
+
+```
+
+This will allow you to drill deeper into your backtest results, and perform analysis which would make the regular backtest-output unreadable.
+
+If you have some ideas for interesting / helpful backtest data analysis ideas, please submit a PR so the community can benefit from it.
+
+## Backtesting multiple strategies
+
+To backtest multiple strategies, a list of Strategies can be provided.
+
+This is limited to 1 ticker-interval per run, however, data is only loaded once from disk so if you have multiple
+strategies you'd like to compare, this should give a nice runtime boost.
+
+All listed Strategies need to be in the same folder.
+
+``` bash
+freqtrade backtesting --timerange 20180401-20180410 --ticker-interval 5m --strategy-list Strategy001 Strategy002 --export trades
+```
+
+This will save the results to `user_data/backtest_data/backtest-result-<strategy>.json`, injecting the strategy-name into the target filename.
+There will be an additional table comparing win/losses of the different strategies (identical to the "Total" row in the first table).
+Detailed output for all strategies one after the other will be available, so make sure to scroll up.
+
+```
+=========================================================== Strategy Summary ===========================================================
+| Strategy    |   buy count |   avg profit % |   cum profit % |   tot profit BTC |   tot profit % | avg duration   |   profit |   loss |
+|:------------|------------:|---------------:|---------------:|-----------------:|---------------:|:---------------|---------:|-------:|
+| Strategy1   |         429 |           0.36 |         152.41 |       0.00762792 |          76.20 | 4:12:00        |      186 |    243 |
+| Strategy2   |        1487 |          -0.13 |        -197.58 |      -0.00988917 |         -98.79 | 4:43:00        |      662 |    825 |
+```
+
+## Next step
+
+Great, your strategy is profitable. What if the bot can give your the
+optimal parameters to use for your strategy?
+Your next step is to learn [how to find optimal parameters with Hyperopt](hyperopt.md)

docs/bot-optimization.md

@@ -0,0 +1,372 @@
+# Optimization
+
+This page explains where to customize your strategies, and add new
+indicators.
+
+## Install a custom strategy file
+
+This is very simple. Copy paste your strategy file into the folder
+`user_data/strategies`.
+
+Let assume you have a class called `AwesomeStrategy` in the file `awesome-strategy.py`:
+
+1. Move your file into `user_data/strategies` (you should have `user_data/strategies/awesome-strategy.py`
+2. Start the bot with the param `--strategy AwesomeStrategy` (the parameter is the class name)
+
+```bash
+python3 freqtrade --strategy AwesomeStrategy
+```
+
+## Change your strategy
+
+The bot includes a default strategy file. However, we recommend you to
+use your own file to not have to lose your parameters every time the default
+strategy file will be updated on Github. Put your custom strategy file
+into the folder `user_data/strategies`.
+
+Best copy the test-strategy and modify this copy to avoid having bot-updates override your changes.
+`cp  user_data/strategies/test_strategy.py user_data/strategies/awesome-strategy.py`
+
+### Anatomy of a strategy
+
+A strategy file contains all the information needed to build a good strategy:
+
+- Indicators
+- Buy strategy rules
+- Sell strategy rules
+- Minimal ROI recommended
+- Stoploss strongly recommended
+
+The bot also include a sample strategy called `TestStrategy` you can update: `user_data/strategies/test_strategy.py`.
+You can test it with the parameter: `--strategy TestStrategy`
+
+```bash
+python3 freqtrade --strategy AwesomeStrategy
+```
+
+**For the following section we will use the [user_data/strategies/test_strategy.py](https://github.com/freqtrade/freqtrade/blob/develop/user_data/strategies/test_strategy.py)
+file as reference.**
+
+!!! Note Strategies and Backtesting
+    To avoid problems and unexpected differences between Backtesting and dry/live modes, please be aware
+    that during backtesting the full time-interval is passed to the `populate_*()` methods at once.
+    It is therefore best to use vectorized operations (across the whole dataframe, not loops) and
+    avoid index referencing (`df.iloc[-1]`), but instead use `df.shift()` to get to the previous candle.
+
+### Customize Indicators
+
+Buy and sell strategies need indicators. You can add more indicators by extending the list contained in the method `populate_indicators()` from your strategy file.
+
+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.
+
+Sample:
+
+```python
+def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+    """
+    Adds several different TA indicators to the given DataFrame
+
+    Performance Note: For the best performance be frugal on the number of indicators
+    you are using. Let uncomment only the indicator you are using in your strategies
+    or your hyperopt configuration, otherwise you will waste your memory and CPU usage.
+    :param dataframe: Raw data from the exchange and parsed by parse_ticker_dataframe()
+    :param metadata: Additional information, like the currently traded pair
+    :return: a Dataframe with all mandatory indicators for the strategies
+    """
+    dataframe['sar'] = ta.SAR(dataframe)
+    dataframe['adx'] = ta.ADX(dataframe)
+    stoch = ta.STOCHF(dataframe)
+    dataframe['fastd'] = stoch['fastd']
+    dataframe['fastk'] = stoch['fastk']
+    dataframe['blower'] = ta.BBANDS(dataframe, nbdevup=2, nbdevdn=2)['lowerband']
+    dataframe['sma'] = ta.SMA(dataframe, timeperiod=40)
+    dataframe['tema'] = ta.TEMA(dataframe, timeperiod=9)
+    dataframe['mfi'] = ta.MFI(dataframe)
+    dataframe['rsi'] = ta.RSI(dataframe)
+    dataframe['ema5'] = ta.EMA(dataframe, timeperiod=5)
+    dataframe['ema10'] = ta.EMA(dataframe, timeperiod=10)
+    dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50)
+    dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100)
+    dataframe['ao'] = awesome_oscillator(dataframe)
+    macd = ta.MACD(dataframe)
+    dataframe['macd'] = macd['macd']
+    dataframe['macdsignal'] = macd['macdsignal']
+    dataframe['macdhist'] = macd['macdhist']
+    hilbert = ta.HT_SINE(dataframe)
+    dataframe['htsine'] = hilbert['sine']
+    dataframe['htleadsine'] = hilbert['leadsine']
+    dataframe['plus_dm'] = ta.PLUS_DM(dataframe)
+    dataframe['plus_di'] = ta.PLUS_DI(dataframe)
+    dataframe['minus_dm'] = ta.MINUS_DM(dataframe)
+    dataframe['minus_di'] = ta.MINUS_DI(dataframe)
+    return dataframe
+```
+
+
+!!! Note "Want more indicator examples?"
+    Look into the [user_data/strategies/test_strategy.py](https://github.com/freqtrade/freqtrade/blob/develop/user_data/strategies/test_strategy.py).<br/>
+    Then uncomment indicators you need.
+
+### Buy signal rules
+
+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 will 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/test_strategy.py`:
+
+```python
+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
+    :param metadata: Additional information, like the currently traded pair
+    :return: DataFrame with buy column
+    """
+    dataframe.loc[
+        (
+            (dataframe['adx'] > 30) &
+            (dataframe['tema'] <= dataframe['bb_middleband']) &
+            (dataframe['tema'] > dataframe['tema'].shift(1))
+        ),
+        'buy'] = 1
+
+    return dataframe
+```
+
+### Sell signal rules
+
+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 will 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/test_strategy.py`:
+
+```python
+def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> 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
+    """
+    dataframe.loc[
+        (
+            (dataframe['adx'] > 70) &
+            (dataframe['tema'] > dataframe['bb_middleband']) &
+            (dataframe['tema'] < dataframe['tema'].shift(1))
+        ),
+        'sell'] = 1
+    return dataframe
+```
+
+### Minimal ROI
+
+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.
+
+```python
+minimal_roi = {
+    "40": 0.0,
+    "30": 0.01,
+    "20": 0.02,
+    "0": 0.04
+}
+```
+
+The above configuration would therefore mean:
+
+- 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.
+
+To disable ROI completely, set it to an insanely high number:
+
+```python
+minimal_roi = {
+    "0": 100
+}
+```
+
+While technically not completely disabled, this would sell once the trade reaches 10000% Profit.
+
+### Stoploss
+
+Setting a stoploss is highly recommended to protect your capital from strong moves against you.
+
+Sample:
+
+``` python
+stoploss = -0.10
+```
+
+This would signify a stoploss of -10%.
+If your exchange supports it, it's recommended to also set `"stoploss_on_exchange"` in the order dict, so your stoploss is on the exchange and cannot be missed for network-problems (or other problems).
+
+For more information on order_types please look [here](https://github.com/freqtrade/freqtrade/blob/develop/docs/configuration.md#understand-order_types).
+
+### 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 buy/sell signals may work with one interval, but not the other.
+This setting is accessible within the strategy by using `self.ticker_interval`.
+
+### Metadata dict
+
+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.
+Instead, have a look at the section [Storing information](#Storing-information)
+
+### Storing information
+
+Storing information can be accomplished by crating a new dictionary within the strategy class.
+
+The name of the variable can be choosen at will, but should be prefixed with `cust_` to avoid naming collisions with predefined strategy variables.
+
+```python
+class Awesomestrategy(IStrategy):
+    # Create custom dictionary
+    cust_info = {}
+    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        # Check if the entry already exists
+        if "crosstime" in self.cust_info[metadata["pair"]:
+            self.cust_info[metadata["pair"]["crosstime"] += 1
+        else:
+            self.cust_info[metadata["pair"]["crosstime"] = 1
+```
+
+!!! Warning
+  The data is not persisted after a bot-restart (or config-reload). Also, the amount of data should be kept smallish (no DataFrames and such), otherwise the bot will start to consume a lot of memory and eventually run out of memory and crash.
+
+!!! Note
+  If the data is pair-specific, make sure to use pair as one of the keys in the dictionary.
+
+### Additional data (DataProvider)
+
+The strategy provides access to the `DataProvider`. This allows you to get additional data to use in your strategy.
+
+All methods return `None` in case of failure (do not raise an exception).
+
+Please always check the mode of operation to select the correct method to get data (samples see below).
+
+#### Possible options for DataProvider
+
+- `available_pairs` - Property with tuples listing cached pairs with their intervals. (pair, interval)
+- `ohlcv(pair, ticker_interval)` - Currently cached ticker data for all pairs in the whitelist, returns DataFrame or empty DataFrame
+- `historic_ohlcv(pair, ticker_interval)` - Data stored on disk
+- `runmode` - Property containing the current runmode.
+
+#### ohlcv / historic_ohlcv
+
+``` python
+if self.dp:
+    if self.dp.runmode in ('live', 'dry_run'):
+        if (f'{self.stake_currency}/BTC', self.ticker_interval) in self.dp.available_pairs:
+            data_eth = self.dp.ohlcv(pair='{self.stake_currency}/BTC',
+                                     ticker_interval=self.ticker_interval)
+    else:
+        # Get historic ohlcv data (cached on disk).
+        history_eth = self.dp.historic_ohlcv(pair='{self.stake_currency}/BTC',
+                                             ticker_interval='1h')
+```
+
+!!! Warning Warning about backtesting
+    Be carefull when using dataprovider in backtesting. `historic_ohlcv()` 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).
+
+!!! Warning Warning in hyperopt
+    This option cannot currently be used during hyperopt.
+
+#### Available Pairs
+
+``` python
+if self.dp:
+    for pair, ticker in self.dp.available_pairs:
+        print(f"available {pair}, {ticker}")
+```
+
+#### Get data for non-tradeable pairs
+
+Data for additional, informative pairs (reference pairs) can be beneficial for some strategies.
+Ohlcv data for these pairs will be downloaded as part of the regular whitelist refresh process and is available via `DataProvider` just as other pairs (see above).
+These parts will **not** be traded unless they are also specified in the pair whitelist, or have been selected by Dynamic Whitelisting.
+
+The pairs need to be specified as tuples in the format `("pair", "interval")`, with pair as the first and time interval as the second argument.
+
+Sample:
+
+``` python
+def informative_pairs(self):
+    return [("ETH/USDT", "5m"),
+            ("BTC/TUSD", "15m"),
+            ]
+```
+
+!!! Warning
+    As these pairs will be refreshed as part of the regular whitelist refresh, it's best to keep this list short.
+    All intervals and all pairs can be specified as long as they are available (and active) on the used exchange.
+    It is however better to use resampling to longer time-intervals when possible
+    to avoid hammering the exchange with too many requests and risk beeing blocked.
+
+### Additional data - Wallets
+
+The strategy provides access to the `Wallets` object. This contains the current balances on the exchange.
+
+!!! Note
+    Wallets is not available during backtesting / hyperopt.
+
+Please always check if `Wallets` is available to avoid failures during backtesting.
+
+``` python
+if self.wallets:
+    free_eth = self.wallets.get_free('ETH')
+    used_eth = self.wallets.get_used('ETH')
+    total_eth = self.wallets.get_total('ETH')
+```
+
+#### Possible options for Wallets
+
+- `get_free(asset)` - currently available balance to trade
+- `get_used(asset)` - currently tied up balance (open orders)
+- `get_total(asset)` - total available balance - sum of the 2 above
+
+### Where is the default strategy?
+
+The default buy strategy is located in the file
+[freqtrade/default_strategy.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/strategy/default_strategy.py).
+
+### Specify custom strategy location
+
+If you want to use a strategy from a different folder you can pass `--strategy-path`
+
+```bash
+python3 freqtrade --strategy AwesomeStrategy --strategy-path /some/folder
+```
+
+### Further strategy ideas
+
+To get additional Ideas for strategies, head over to our [strategy repository](https://github.com/freqtrade/freqtrade-strategies). Feel free to use them as they are - but results will depend on the current market situation, pairs used etc. - therefore please backtest the strategy for your exchange/desired pairs first, evaluate carefully, use at your own risk.
+Feel free to use any of them as inspiration for your own strategies.
+We're happy to accept Pull Requests containing new Strategies to that repo.
+
+We also got a *strategy-sharing* channel in our [Slack community](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE) which is a great place to get and/or share ideas.
+
+## Next step
+
+Now you have a perfect strategy you probably want to backtest it.
+Your next step is to learn [How to use the Backtesting](backtesting.md).

docs/bot-usage.md

@@ -0,0 +1,270 @@
+# Start the bot
+
+This page explains the different parameters of the bot and how to run it.
+
+
+## Bot commands
+
+```
+usage: freqtrade [-h] [-v] [--logfile FILE] [--version] [-c PATH] [-d PATH]
+                 [-s NAME] [--strategy-path PATH] [--dynamic-whitelist [INT]]
+                 [--db-url PATH] [--sd-notify]
+                 {backtesting,edge,hyperopt} ...
+
+Free, open source crypto trading bot
+
+positional arguments:
+  {backtesting,edge,hyperopt}
+    backtesting         Backtesting module.
+    edge                Edge module.
+    hyperopt            Hyperopt module.
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
+  --logfile FILE        Log to the file specified
+  --version             show program's version number and exit
+  -c PATH, --config PATH
+                        Specify configuration file (default: None). Multiple
+                        --config options may be used.
+  -d PATH, --datadir PATH
+                        Path to backtest data.
+  -s NAME, --strategy NAME
+                        Specify strategy class name (default:
+                        DefaultStrategy).
+  --strategy-path PATH  Specify additional strategy lookup path.
+  --dynamic-whitelist [INT]
+                        Dynamically generate and update whitelist based on 24h
+                        BaseVolume (default: 20). DEPRECATED.
+  --db-url PATH         Override trades database URL, this is useful if
+                        dry_run is enabled or in custom deployments (default:
+                        None).
+  --sd-notify           Notify systemd service manager.
+```
+
+### How to use a different configuration file?
+
+The bot allows you to select which configuration file you want to use. Per
+default, the bot will load the file `./config.json`
+
+```bash
+python3 freqtrade -c path/far/far/away/config.json
+```
+
+### How to use multiple configuration files?
+
+The bot allows you to use multiple configuration files by specifying multiple
+`-c/--config` configuration options in the command line. Configuration parameters
+defined in the last configuration file override parameters with the same name
+defined in the previous configuration file specified in the command line.
+
+For example, you can make a separate configuration file with your key and secrete
+for the Exchange you use for trading, specify default configuration file with
+empty key and secrete values while running in the Dry Mode (which does not actually
+require them):
+
+```bash
+python3 freqtrade -c ./config.json
+```
+
+and specify both configuration files when running in the normal Live Trade Mode:
+
+```bash
+python3 freqtrade -c ./config.json -c path/to/secrets/keys.config.json
+```
+
+This could help you hide your private Exchange key and Exchange secrete on you local machine
+by setting appropriate file permissions for the file which contains actual secrets and, additionally,
+prevent unintended disclosure of sensitive private data when you publish examples
+of your configuration in the project issues or in the Internet.
+
+See more details on this technique with examples in the documentation page on
+[configuration](configuration.md).
+
+### How to use **--strategy**?
+
+This parameter will allow you to load your custom strategy class.
+Per default without `--strategy` or `-s` the bot will load the
+`DefaultStrategy` included with the bot (`freqtrade/strategy/default_strategy.py`).
+
+The bot will search your strategy file within `user_data/strategies` and `freqtrade/strategy`.
+
+To load a strategy, simply pass the class name (e.g.: `CustomStrategy`) in this parameter.
+
+**Example:**
+In `user_data/strategies` you have a file `my_awesome_strategy.py` which has
+a strategy class called `AwesomeStrategy` to load it:
+
+```bash
+python3 freqtrade --strategy AwesomeStrategy
+```
+
+If the bot does not find your strategy file, it will display in an error
+message the reason (File not found, or errors in your code).
+
+Learn more about strategy file in
+[optimize your bot](bot-optimization.md).
+
+### How to use **--strategy-path**?
+
+This parameter allows you to add an additional strategy lookup path, which gets
+checked before the default locations (The passed path must be a folder!):
+```bash
+python3 freqtrade --strategy AwesomeStrategy --strategy-path /some/folder
+```
+
+#### How to install a strategy?
+
+This is very simple. Copy paste your strategy file into the folder
+`user_data/strategies` or use `--strategy-path`. And voila, the bot is ready to use it.
+
+### How to use **--dynamic-whitelist**?
+
+!!! danger "DEPRECATED"
+    This command line option is deprecated. Please move your configurations using it
+to the configurations that utilize the `StaticPairList` or `VolumePairList` methods set
+in the configuration file
+as outlined [here](configuration/#dynamic-pairlists)
+
+Description of this deprecated feature was moved to [here](deprecated.md).
+Please no longer use it.
+
+### How to use **--db-url**?
+
+When you run the bot in Dry-run mode, per default no transactions are
+stored in a database. If you want to store your bot actions in a DB
+using `--db-url`. This can also be used to specify a custom database
+in production mode. Example command:
+
+```bash
+python3 freqtrade -c config.json --db-url sqlite:///tradesv3.dry_run.sqlite
+```
+
+## Backtesting commands
+
+Backtesting also uses the config specified via `-c/--config`.
+
+```
+usage: freqtrade backtesting [-h] [-i TICKER_INTERVAL] [--timerange TIMERANGE]
+                             [--eps] [--dmmp] [-l] [-r]
+                             [--strategy-list STRATEGY_LIST [STRATEGY_LIST ...]]
+                             [--export EXPORT] [--export-filename PATH]
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -i TICKER_INTERVAL, --ticker-interval TICKER_INTERVAL
+                        Specify ticker interval (1m, 5m, 30m, 1h, 1d).
+  --timerange TIMERANGE
+                        Specify what timerange of data to use.
+  --eps, --enable-position-stacking
+                        Allow buying the same pair multiple times (position
+                        stacking).
+  --dmmp, --disable-max-market-positions
+                        Disable applying `max_open_trades` during backtest
+                        (same as setting `max_open_trades` to a very high
+                        number).
+  -l, --live            Use live data.
+  -r, --refresh-pairs-cached
+                        Refresh the pairs files in tests/testdata with the
+                        latest data from the exchange. Use it if you want to
+                        run your backtesting with up-to-date data.
+  --strategy-list STRATEGY_LIST [STRATEGY_LIST ...]
+                        Provide a commaseparated list of strategies to
+                        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-DefaultStrategy.json
+  --export EXPORT       Export backtest results, argument are: trades. Example
+                        --export=trades
+  --export-filename PATH
+                        Save backtest results to this filename requires
+                        --export to be set as well Example --export-
+                        filename=user_data/backtest_data/backtest_today.json
+                        (default: user_data/backtest_data/backtest-
+                        result.json)
+```
+
+### How to use **--refresh-pairs-cached** parameter?
+
+The first time your run Backtesting, it will take the pairs you have
+set in your config file and download data from Bittrex.
+
+If for any reason you want to update your data set, you use
+`--refresh-pairs-cached` to force Backtesting to update the data it has.
+
+!!! Note
+    Use it only if you want to update your data set. You will not be able to come back to the previous version.
+
+To test your strategy with latest data, we recommend continuing using
+the parameter `-l` or `--live`.
+
+## Hyperopt commands
+
+To optimize your strategy, you can use hyperopt parameter hyperoptimization
+to find optimal parameter values for your stategy.
+
+```
+usage: freqtrade hyperopt [-h] [-i TICKER_INTERVAL] [--timerange TIMERANGE]
+                          [--customhyperopt NAME] [--eps] [--dmmp] [-e INT]
+                          [-s {all,buy,sell,roi,stoploss} [{all,buy,sell,roi,stoploss} ...]]
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -i TICKER_INTERVAL, --ticker-interval TICKER_INTERVAL
+                        Specify ticker interval (1m, 5m, 30m, 1h, 1d).
+  --timerange TIMERANGE
+                        Specify what timerange of data to use.
+  --customhyperopt NAME
+                        Specify hyperopt class name (default:
+                        DefaultHyperOpts).
+  --eps, --enable-position-stacking
+                        Allow buying the same pair multiple times (position
+                        stacking).
+  --dmmp, --disable-max-market-positions
+                        Disable applying `max_open_trades` during backtest
+                        (same as setting `max_open_trades` to a very high
+                        number).
+  -e INT, --epochs INT  Specify number of epochs (default: 100).
+  -s {all,buy,sell,roi,stoploss} [{all,buy,sell,roi,stoploss} ...], --spaces {all,buy,sell,roi,stoploss} [{all,buy,sell,roi,stoploss} ...]
+                        Specify which parameters to hyperopt. Space separate
+                        list. Default: all.
+
+```
+
+## Edge commands
+
+To know your trade expectacny and winrate against historical data, you can use Edge.
+
+```
+usage: freqtrade edge [-h] [-i TICKER_INTERVAL] [--timerange TIMERANGE] [-r]
+                      [--stoplosses STOPLOSS_RANGE]
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -i TICKER_INTERVAL, --ticker-interval TICKER_INTERVAL
+                        Specify ticker interval (1m, 5m, 30m, 1h, 1d).
+  --timerange TIMERANGE
+                        Specify what timerange of data to use.
+  -r, --refresh-pairs-cached
+                        Refresh the pairs files in tests/testdata with the
+                        latest data from the exchange. Use it if you want to
+                        run your edge with up-to-date data.
+  --stoplosses STOPLOSS_RANGE
+                        Defines a range of stoploss against which edge will
+                        assess the strategy the format is "min,max,step"
+                        (without any space).example:
+                        --stoplosses=-0.01,-0.1,-0.001
+```
+
+To understand edge and how to read the results, please read the [edge documentation](edge.md).
+
+## A parameter missing in the configuration?
+
+All parameters for `main.py`, `backtesting`, `hyperopt` are referenced
+in [misc.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/misc.py#L84)
+
+## Next step
+
+The optimal strategy of the bot will change with time depending of the market trends. The next step is to
+[optimize your bot](bot-optimization.md).

docs/configuration.md

@@ -0,0 +1,455 @@
+# Configure the bot
+
+This page explains how to configure your `config.json` file.
+
+## Setup config.json
+
+We recommend to copy and use the `config.json.example` as a template
+for your bot configuration.
+
+The table below will list all configuration parameters.
+
+Mandatory Parameters are marked as **Required**.
+
+|  Command | Default | Description |
+|----------|---------|-------------|
+| `max_open_trades` | 3 | **Required.** Number of trades open your bot will have. If -1 then it is ignored (i.e. potentially unlimited open trades)
+| `stake_currency` | BTC | **Required.** Crypto-currency used for trading. [Strategy Override](#parameters-in-the-strategy).
+| `stake_amount` | 0.05 | **Required.** Amount of crypto-currency your bot will use for each trade. Per default, the bot will use (0.05 BTC x 3) = 0.15 BTC in total will be always engaged. Set it to `"unlimited"` to allow the bot to use all available balance. [Strategy Override](#parameters-in-the-strategy).
+| `amount_reserve_percent` | 0.05 | Reserve some amount in min pair stake amount. Default is 5%. The bot will reserve `amount_reserve_percent` + stop-loss value when calculating min pair stake amount in order to avoid possible trade refusals.
+| `ticker_interval` | [1m, 5m, 15m, 30m, 1h, 1d, ...] | The ticker interval to use (1min, 5 min, 15 min, 30 min, 1 hour or 1 day). Default is 5 minutes. [Strategy Override](#parameters-in-the-strategy).
+| `fiat_display_currency` | USD | **Required.** Fiat currency used to show your profits. More information below.
+| `dry_run` | true | **Required.** Define if the bot must be in Dry-run or production mode.
+| `dry_run_wallet` | 999.9 | Overrides the default amount of 999.9 stake currency units in the wallet used by the bot running in the Dry Run mode if you need it for any reason.
+| `process_only_new_candles` | false | If set to true indicators are processed only once a new candle arrives. 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).
+| `minimal_roi` | See below | Set the threshold in percent the bot will use to sell a trade. More information below. [Strategy Override](#parameters-in-the-strategy).
+| `stoploss` | -0.10 | Value of the stoploss in percent used by the bot. More information below. More details in the [stoploss documentation](stoploss.md). [Strategy Override](#parameters-in-the-strategy).
+| `trailing_stop` | false | Enables trailing stop-loss (based on `stoploss` in either configuration or strategy file). More details in the [stoploss documentation](stoploss.md). [Strategy Override](#parameters-in-the-strategy).
+| `trailing_stop_positive` | 0 | Changes stop-loss once profit has been reached. More details in the [stoploss documentation](stoploss.md). [Strategy Override](#parameters-in-the-strategy).
+| `trailing_stop_positive_offset` | 0 | Offset on when to apply `trailing_stop_positive`. Percentage value which should be positive. More details in the [stoploss documentation](stoploss.md). [Strategy Override](#parameters-in-the-strategy).
+| `trailing_only_offset_is_reached` | false | Only apply trailing stoploss when the offset is reached. [stoploss documentation](stoploss.md). [Strategy Override](#parameters-in-the-strategy).
+| `unfilledtimeout.buy` | 10 | **Required.** How long (in minutes) the bot will wait for an unfilled buy order to complete, after which the order will be cancelled.
+| `unfilledtimeout.sell` | 10 | **Required.** How long (in minutes) the bot will wait for an unfilled sell order to complete, after which the order will be cancelled.
+| `bid_strategy.ask_last_balance` | 0.0 | **Required.** Set the bidding price. More information [below](#understand-ask_last_balance).
+| `bid_strategy.use_order_book` | false | Allows buying of pair using the rates in Order Book Bids.
+| `bid_strategy.order_book_top` | 0 | Bot will use the top N rate in Order Book Bids. Ie. a value of 2 will allow the bot to pick the 2nd bid rate in Order Book Bids.
+| `bid_strategy. check_depth_of_market.enabled` | false | Does not buy if the % difference of buy orders and sell orders is met in Order Book.
+| `bid_strategy. check_depth_of_market.bids_to_ask_delta` | 0 | The % difference of buy orders and sell orders found in Order Book. A value lesser than 1 means sell orders is greater, while value greater than 1 means buy orders is higher.
+| `ask_strategy.use_order_book` | false | Allows selling of open traded pair using the rates in Order Book Asks.
+| `ask_strategy.order_book_min` | 0 | Bot will scan from the top min to max Order Book Asks searching for a profitable rate.
+| `ask_strategy.order_book_max` | 0 | Bot will scan from the top min to max Order Book Asks searching for a profitable rate.
+| `order_types` | None | 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).
+| `order_time_in_force` | None | Configure time in force for buy and sell orders. [More information below](#understand-order_time_in_force). [Strategy Override](#parameters-in-the-strategy).
+| `exchange.name` | bittrex | **Required.** Name of the exchange class to use. [List below](#user-content-what-values-for-exchangename).
+| `exchange.sandbox` | false | 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.
+| `exchange.key` | key | API key to use for the exchange. Only required when you are in production mode.
+| `exchange.secret` | secret | API secret to use for the exchange. Only required when you are in production mode.
+| `exchange.pair_whitelist` | [] | List of currency to use by the bot. Can be overrided with `--dynamic-whitelist` param.
+| `exchange.pair_blacklist` | [] | List of currency the bot must avoid. Useful when using `--dynamic-whitelist` param.
+| `exchange.ccxt_config` | None | Additional CCXT parameters passed to the regular ccxt instance. Parameters may differ from exchange to exchange and are documented in the [ccxt documentation](https://ccxt.readthedocs.io/en/latest/manual.html#instantiation)
+| `exchange.ccxt_async_config` | None | Additional CCXT parameters passed to the async ccxt instance. Parameters may differ from exchange to exchange  and are documented in the [ccxt documentation](https://ccxt.readthedocs.io/en/latest/manual.html#instantiation)
+| `exchange.markets_refresh_interval` | 60 | The interval in minutes in which markets are reloaded.
+| `edge` | false | Please refer to [edge configuration document](edge.md) for detailed explanation.
+| `experimental.use_sell_signal` | false | Use your sell strategy in addition of the `minimal_roi`. [Strategy Override](#parameters-in-the-strategy).
+| `experimental.sell_profit_only` | false | Waits until you have made a positive profit before taking a sell decision. [Strategy Override](#parameters-in-the-strategy).
+| `experimental.ignore_roi_if_buy_signal` | false | Does not sell if the buy-signal is still active. Takes preference over `minimal_roi` and `use_sell_signal`. [Strategy Override](#parameters-in-the-strategy).
+| `pairlist.method` | StaticPairList | Use Static whitelist. [More information below](#dynamic-pairlists).
+| `pairlist.config` | None | Additional configuration for dynamic pairlists. [More information below](#dynamic-pairlists).
+| `telegram.enabled` | true | **Required.** Enable or not the usage of Telegram.
+| `telegram.token` | token | Your Telegram bot token. Only required if `telegram.enabled` is `true`.
+| `telegram.chat_id` | chat_id | Your personal Telegram account id. Only required if `telegram.enabled` is `true`.
+| `webhook.enabled` | false | Enable usage of Webhook notifications
+| `webhook.url` | false | URL for the webhook. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details.
+| `webhook.webhookbuy` | false | Payload to send on buy. Only required if `webhook.enabled` is `true`. See the [webhook documentationV](webhook-config.md) for more details.
+| `webhook.webhooksell` | false | Payload to send on sell. Only required if `webhook.enabled` is `true`. See the [webhook documentationV](webhook-config.md) for more details.
+| `webhook.webhookstatus` | false | Payload to send on status calls. Only required if `webhook.enabled` is `true`. See the [webhook documentationV](webhook-config.md) for more details.
+| `db_url` | `sqlite:///tradesv3.sqlite`| Declares database URL to use. NOTE: This defaults to `sqlite://` if `dry_run` is `True`.
+| `initial_state` | running | Defines the initial application state. More information below.
+| `forcebuy_enable` | false | Enables the RPC Commands to force a buy. More information below.
+| `strategy` | DefaultStrategy | Defines Strategy class to use.
+| `strategy_path` | null | Adds an additional strategy lookup path (must be a folder).
+| `internals.process_throttle_secs` | 5 | **Required.** Set the process throttle. Value in second.
+| `internals.sd_notify` | false | 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.
+| `logfile` | | Specify Logfile. Uses a rolling strategy of 10 files, with 1Mb per file.
+
+### Parameters in the strategy
+
+The following parameters can be set in either configuration file or strategy.
+Values set in the configuration file always overwrite values set in the strategy.
+
+* `stake_currency`
+* `stake_amount`
+* `ticker_interval`
+* `minimal_roi`
+* `stoploss`
+* `trailing_stop`
+* `trailing_stop_positive`
+* `trailing_stop_positive_offset`
+* `process_only_new_candles`
+* `order_types`
+* `order_time_in_force`
+* `use_sell_signal` (experimental)
+* `sell_profit_only` (experimental)
+* `ignore_roi_if_buy_signal` (experimental)
+
+### Understand stake_amount
+
+The `stake_amount` configuration parameter is an amount of crypto-currency your bot will use for each trade.
+The minimal value is 0.0005. If there is not enough crypto-currency in
+the account an exception is generated.
+To allow the bot to trade all the available `stake_currency` in your account set
+
+```json
+"stake_amount" : "unlimited",
+```
+
+In this case a trade amount is calclulated as:
+
+```python
+currency_balanse / (max_open_trades - current_open_trades)
+```
+
+### Understand minimal_roi
+
+The `minimal_roi` configuration parameter is a JSON object where the key is a duration
+in minutes and the value is the minimum ROI in percent.
+See the example below:
+
+```json
+"minimal_roi": {
+    "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
+},
+```
+
+Most of the strategy files already include the optimal `minimal_roi` value.
+This parameter can be set in either Strategy or Configuration file. If you use it in the configuration file, it will override the
+`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.
+
+### Understand stoploss
+
+The `stoploss` configuration parameter is loss in percentage that should trigger a sale.
+For example, value `-0.10` will cause immediate sell if the
+profit dips below -10% for a given trade. This parameter is optional.
+
+Most of the strategy files already include the optimal `stoploss`
+value. This parameter is optional. If you use it in the configuration file, it will take over the
+`stoploss` value from the strategy file.
+
+### Understand trailing stoploss
+
+Go to the [trailing stoploss Documentation](stoploss.md) for details on trailing stoploss.
+
+### Understand initial_state
+
+The `initial_state` configuration parameter is an optional field that defines the initial application state.
+Possible values are `running` or `stopped`. (default=`running`)
+If the value is `stopped` the bot has to be started with `/start` first.
+
+### Understand forcebuy_enable
+
+The `forcebuy_enable` configuration parameter enables the usage of forcebuy commands via Telegram.
+This is disabled for security reasons by default, and will show a warning message on startup if enabled.
+For example, you can send `/forcebuy ETH/BTC` Telegram command when this feature if enabled to the bot,
+who then buys 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.
+
+See [the telegram documentation](telegram-usage.md) for details on usage.
+
+### Understand process_throttle_secs
+
+The `process_throttle_secs` configuration parameter is an optional field that defines in seconds how long the bot should wait
+before asking the strategy if we should buy or a sell an asset. After each wait period, the strategy is asked again for
+every opened trade wether or not we should sell, and for all the remaining pairs (either the dynamic list of pairs or
+the static list of pairs) if we should buy.
+
+### Understand ask_last_balance
+
+The `ask_last_balance` configuration parameter sets the bidding price. Value `0.0` will use `ask` price, `1.0` will
+use the `last` price and values between those interpolate between ask and last
+price. Using `ask` price will guarantee quick success in bid, but bot will also
+end up paying more then would probably have been necessary.
+
+### Understand order_types
+
+The `order_types` configuration parameter contains a dict mapping order-types to
+market-types as well as stoploss on or off exchange type and stoploss on exchange
+update interval in seconds. This allows to buy using limit orders, sell using
+limit-orders, and create stoploss orders using market. It also allows to set the
+stoploss "on exchange" which means stoploss order would be placed immediately once
+the buy order is fulfilled. In case stoploss on exchange and `trailing_stop` are
+both set, then the bot will use `stoploss_on_exchange_interval` to check it periodically
+and update it if necessary (e.x. in case of trailing stoploss).
+This can be set in the configuration file or in the strategy.
+Values set in the configuration file  overwrites values set in the strategy.
+
+If this is configured, all 4 values (`buy`, `sell`, `stoploss` and
+`stoploss_on_exchange`) need to be present, otherwise the bot will warn about it and fail to start.
+The below is the default which is used if this is not configured in either strategy or configuration file.
+
+```python
+"order_types": {
+    "buy": "limit",
+    "sell": "limit",
+    "stoploss": "market",
+    "stoploss_on_exchange": False,
+    "stoploss_on_exchange_interval": 60
+},
+```
+
+!!! Note
+    Not all exchanges support "market" orders.
+    The following message will be shown if your exchange does not support market orders:
+    `"Exchange <yourexchange>  does not support market orders."`
+
+!!! Note
+    Stoploss on exchange interval is not mandatory. Do not change its value if you are
+    unsure of what you are doing. For more information about how stoploss works please
+    read [the stoploss documentation](stoploss.md).
+
+!!! Note
+    In case of stoploss on exchange if the stoploss is cancelled manually then
+    the bot would recreate one.
+
+### Understand order_time_in_force
+
+The `order_time_in_force` configuration parameter defines the policy by which the order
+is executed on the exchange. Three commonly used time in force are:
+
+**GTC (Good Till Canceled):**
+
+This is most of the time the default time in force. It means the order will remain
+on exchange till it is canceled by user. It can be fully or partially fulfilled.
+If partially fulfilled, the remaining will stay on the exchange till cancelled.
+
+**FOK (Full Or Kill):**
+
+It means if the order is not executed immediately AND fully then it is canceled by the exchange.
+
+**IOC (Immediate Or Canceled):**
+
+It is the same as FOK (above) except it can be partially fulfilled. The remaining part
+is automatically cancelled by the exchange.
+
+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`.
+
+``` python
+"order_time_in_force": {
+    "buy": "gtc",
+    "sell": "gtc"
+},
+```
+
+!!! Warning
+    This is an ongoing work. For now it is supported only for binance and only for buy orders.
+    Please don't change the default value unless you know what you are doing.
+
+### Exchange configuration
+
+Freqtrade is based on [CCXT library](https://github.com/ccxt/ccxt) that supports over 100 cryptocurrency
+exchange markets and trading APIs. The complete up-to-date list can be found in the
+[CCXT repo homepage](https://github.com/ccxt/ccxt/tree/master/python). However, the bot was tested
+with only Bittrex and Binance.
+
+The bot was tested with the following exchanges:
+
+- [Bittrex](https://bittrex.com/): "bittrex"
+- [Binance](https://www.binance.com/): "binance"
+
+Feel free to test other exchanges and submit your PR to improve the bot.
+
+#### Sample exchange configuration
+
+A exchange configuration for "binance" would look as follows:
+
+```json
+"exchange": {
+    "name": "binance",
+    "key": "your_exchange_key",
+    "secret": "your_exchange_secret",
+    "ccxt_config": {"enableRateLimit": true},
+    "ccxt_async_config": {
+        "enableRateLimit": true,
+        "rateLimit": 200
+    },
+```
+
+This configuration enables binance, as well as rate limiting to avoid bans from the exchange.
+`"rateLimit": 200` defines a wait-event of 0.2s between each call. This can also be completely disabled by setting `"enableRateLimit"` to false.
+
+!!! Note
+    Optimal settings for rate limiting depend on the exchange and the size of the whitelist, so an ideal parameter will vary on many other settings.
+    We try to provide sensible defaults per exchange where possible, if you encounter bans please make sure that `"enableRateLimit"` is enabled and increase the `"rateLimit"` parameter step by step. 
+
+
+### What values can be used for fiat_display_currency?
+
+The `fiat_display_currency` configuration parameter sets the base currency to use for the
+conversion from coin to fiat in the bot Telegram reports.
+
+The valid values are:
+
+```json
+"AUD", "BRL", "CAD", "CHF", "CLP", "CNY", "CZK", "DKK", "EUR", "GBP", "HKD", "HUF", "IDR", "ILS", "INR", "JPY", "KRW", "MXN", "MYR", "NOK", "NZD", "PHP", "PKR", "PLN", "RUB", "SEK", "SGD", "THB", "TRY", "TWD", "ZAR", "USD"
+```
+
+In addition to fiat currencies, a range of cryto currencies are supported.
+
+The valid values are:
+
+```json
+"BTC", "ETH", "XRP", "LTC", "BCH", "USDT"
+```
+
+## Switch to Dry-run mode
+
+We recommend starting the bot in the Dry-run mode to see how your bot will
+behave and what is the performance of your strategy. In the Dry-run mode the
+bot does not engage your money. It only runs a live simulation without
+creating trades on the exchange.
+
+1. Edit your `config.json` configuration file.
+2. Switch `dry-run` to `true` and specify `db_url` for a persistence database.
+
+```json
+"dry_run": true,
+"db_url": "sqlite:///tradesv3.dryrun.sqlite",
+```
+
+3. Remove your Exchange API key and secrete (change them by empty values or fake credentials):
+
+```json
+"exchange": {
+        "name": "bittrex",
+        "key": "key",
+        "secret": "secret",
+        ...
+}
+```
+
+Once you will be happy with your bot performance running in the Dry-run mode,
+you can switch it to production mode.
+
+### Dynamic Pairlists
+
+Dynamic pairlists select pairs for you based on the logic configured.
+The bot runs against all pairs (with that stake) on the exchange, and a number of assets
+(`number_assets`) is selected based on the selected criteria.
+
+By default, the `StaticPairList` method is used.
+The Pairlist method is configured as `pair_whitelist` parameter under the `exchange`
+section of the configuration.
+
+**Available Pairlist methods:**
+
+* `StaticPairList`
+  * It uses configuration from `exchange.pair_whitelist` and `exchange.pair_blacklist`.
+* `VolumePairList`
+  * Formerly available as `--dynamic-whitelist [<number_assets>]`. This command line
+option is deprecated and should no longer be used.
+  * It selects `number_assets` top pairs based on `sort_key`, which can be one of
+`askVolume`, `bidVolume` and `quoteVolume`, defaults to `quoteVolume`.
+  * There is a possibility to filter low-value coins that would not allow setting a stop loss
+(set `precision_filter` parameter to `true` for this).
+
+Example:
+
+```json
+"pairlist": {
+        "method": "VolumePairList",
+        "config": {
+            "number_assets": 20,
+            "sort_key": "quoteVolume",
+            "precision_filter": false
+        }
+    },
+```
+
+## Switch to production mode
+
+In production mode, the bot will engage your money. Be careful, since a wrong
+strategy can lose all your money. Be aware of what you are doing when
+you run it in production mode.
+
+### To switch your bot in production mode
+
+**Edit your `config.json`  file.**
+
+**Switch dry-run to false and don't forget to adapt your database URL if set:**
+
+```json
+"dry_run": false,
+```
+
+**Insert your Exchange API key (change them by fake api keys):**
+
+```json
+"exchange": {
+        "name": "bittrex",
+        "key": "af8ddd35195e9dc500b9a6f799f6f5c93d89193b",
+        "secret": "08a9dc6db3d7b53e1acebd9275677f4b0a04f1a5",
+        ...
+}
+
+```
+!!! Note
+    If you have an exchange API key yet, [see our tutorial](/pre-requisite).
+
+### Using proxy with FreqTrade
+
+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_full.json.example`
+
+``` 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"
+export HTTPS_PROXY="http://addr:port"
+freqtrade
+```
+
+
+### Embedding Strategies
+
+FreqTrade provides you with with an easy way to embed the strategy into your configuration file.
+This is done by utilizing BASE64 encoding and providing this string at the strategy configuration field,
+in your chosen config file.
+
+#### Encoding a string as BASE64
+
+This is a quick example, how to generate the BASE64 string in python
+
+```python
+from base64 import urlsafe_b64encode
+
+with open(file, 'r') as f:
+    content = f.read()
+content = urlsafe_b64encode(content.encode('utf-8'))
+```
+
+The variable 'content', will contain the strategy file in a BASE64 encoded form. Which can now be set in your configurations file as following
+
+```json
+"strategy": "NameOfStrategy:BASE64String"
+```
+
+Please ensure that 'NameOfStrategy' is identical to the strategy name!
+
+## Next step
+
+Now you have configured your config.json, the next step is to [start your bot](bot-usage.md).

docs/deprecated.md

@@ -0,0 +1,31 @@
+# Deprecated features
+
+This page contains description of the command line arguments, configuration parameters
+and the bot features that were declared as DEPRECATED by the bot development team
+and are no longer supported. Please avoid their usage in your configuration.
+
+### The **--dynamic-whitelist** command line option
+
+Per default `--dynamic-whitelist` will retrieve the 20 currencies based
+on BaseVolume. This value can be changed when you run the script.
+
+**By Default**
+Get the 20 currencies based on BaseVolume.
+
+```bash
+python3 freqtrade --dynamic-whitelist
+```
+
+**Customize the number of currencies to retrieve**
+Get the 30 currencies based on BaseVolume.
+
+```bash
+python3 freqtrade --dynamic-whitelist 30
+```
+
+**Exception**
+`--dynamic-whitelist` must be greater than 0. If you enter 0 or a
+negative value (e.g -2), `--dynamic-whitelist` will use the default
+value (20).
+
+

docs/developer.md

@@ -0,0 +1,117 @@
+# Development Help
+
+This page is intended for developers of FreqTrade, people who want to contribute to the FreqTrade codebase or documentation, or people who want to understand the source code of the application they're running.
+
+All contributions, bug reports, bug fixes, documentation improvements, enhancements and ideas are welcome. We [track issues](https://github.com/freqtrade/freqtrade/issues) on [GitHub](https://github.com) and also have a dev channel in [slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE) where you can ask questions.
+
+## Documentation
+
+Documentation is available at [https://freqtrade.io](https://www.freqtrade.io/) and needs to be provided with every new feature PR.
+
+Special fields for the documentation (like Note boxes, ...) can be found [here](https://squidfunk.github.io/mkdocs-material/extensions/admonition/).
+
+## Developer setup
+
+To configure a development environment, use best use the `setup.sh` script and answer "y" when asked "Do you want to install dependencies for dev [y/N]? ".
+Alternatively (if your system is not supported by the setup.sh script), follow the manual installation process and run `pip3 install -r requirements-dev.txt`.
+
+This will install all required tools for development, including `pytest`, `flake8`, `mypy`, and `coveralls`.
+
+## Modules
+
+### Dynamic Pairlist
+
+You have a great idea for a new pair selection algorithm you would like to try out? Great.
+Hopefully you also want to contribute this back upstream.
+
+Whatever your motivations are - This should get you off the ground in trying to develop a new Pairlist provider.
+
+First of all, have a look at the [VolumePairList](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/pairlist/VolumePairList.py) provider, and best copy this file with a name of your new Pairlist Provider.
+
+This is a simple provider, which however serves as a good example on how to start developing.
+
+Next, modify the classname of the provider (ideally align this with the Filename).
+
+The base-class provides the an instance of the bot (`self._freqtrade`), as well as the configuration (`self._config`), and initiates both `_blacklist` and `_whitelist`.
+
+```python
+        self._freqtrade = freqtrade
+        self._config = config
+        self._whitelist = self._config['exchange']['pair_whitelist']
+        self._blacklist = self._config['exchange'].get('pair_blacklist', [])
+```
+
+
+Now, let's step through the methods which require actions:
+
+#### configuration
+
+Configuration for PairListProvider is done in the bot configuration file in the element `"pairlist"`.
+This Pairlist-object may contain a `"config"` dict with additional configurations for the configured pairlist.
+By convention, `"number_assets"` is used to specify the maximum number of pairs to keep in the whitelist. Please follow this to ensure a consistent user experience.
+
+Additional elements can be configured as needed. `VolumePairList` uses `"sort_key"` to specify the sorting value - however feel free to specify whatever is necessary for your great algorithm to be successfull and dynamic.
+
+#### short_desc
+
+Returns a description used for Telegram messages.
+This should contain the name of the Provider, as well as a short description containing the number of assets. Please follow the format `"PairlistName - top/bottom X pairs"`.
+
+#### refresh_pairlist
+
+Override this method and run all calculations needed in this method.
+This is called with each iteration of the bot - so consider implementing caching for compute/network heavy calculations.
+
+Assign the resulting whiteslist to `self._whitelist` and `self._blacklist` respectively. These will then be used to run the bot in this iteration. Pairs with open trades will be added to the whitelist to have the sell-methods run correctly.
+
+Please also run `self._validate_whitelist(pairs)` and to check and remove pairs with inactive markets. This function is available in the Parent class (`StaticPairList`) and should ideally not be overwritten.
+
+##### sample
+
+``` python
+    def refresh_pairlist(self) -> None:
+        # Generate dynamic whitelist
+        pairs = self._gen_pair_whitelist(self._config['stake_currency'], self._sort_key)
+        # Validate whitelist to only have active market pairs
+        self._whitelist = self._validate_whitelist(pairs)[:self._number_pairs]
+```
+
+#### _gen_pair_whitelist
+
+This is a simple method used by `VolumePairList` - however serves as a good example.
+It implements caching (`@cached(TTLCache(maxsize=1, ttl=1800))`) as well as a configuration option to allow different (but similar) strategies to work with the same PairListProvider.
+
+## Creating a release
+
+This part of the documentation is aimed at maintainers, and shows how to create a release.
+
+### create release branch
+
+``` bash
+# make sure you're in develop branch
+git checkout develop
+
+# create new branch
+git checkout -b new_release
+```
+
+* edit `freqtrade/__init__.py` and add the desired version (for example `0.18.0`)
+* Commit this part
+* push that branch to the remote and create a PR
+
+### create changelog from git commits
+
+``` bash
+# Needs to be done before merging / pulling that branch.
+git log --oneline --no-decorate --no-merges master..develop
+```
+
+### Create github release / tag
+
+* Use the version-number specified as tag. 
+* Use "master" as reference (this step comes after the above PR is merged).
+* use the above changelog as release comment (as codeblock)
+
+### After-release
+
+* update version in develop to next valid version and postfix that with `-dev` (`0.18.0 -> 0.18.1-dev`)

docs/edge.md

@@ -0,0 +1,263 @@
+#  Edge positioning
+
+This page explains how to use Edge Positioning module in your bot in order to enter into a trade only if the trade has a reasonable win rate and risk reward ratio, and consequently adjust your position size and stoploss.
+
+!!! Warning
+    Edge positioning is not compatible with dynamic whitelist. If enabled, it overrides the dynamic whitelist option.
+
+!!! Note
+    Edge does not consider anything else than buy/sell/stoploss signals. So trailing stoploss, ROI, and everything else are ignored in its calculation.
+
+## Introduction
+Trading is all about probability. No one can claim that he has a strategy working all the time. You have to assume that sometimes you lose.
+
+But it doesn't mean there is no rule, it only means rules should work "most of the time". Let's play a game: we toss a coin, heads: I give you 10$, tails: you give me 10$. Is it an interesting game? No, it's quite boring, isn't it?
+
+But let's say the probability that we have heads is 80% (because our coin has the displaced distribution of mass or other defect), and the probability that we have tails is 20%. Now it is becoming interesting...
+
+That means 10$ X 80% versus 10$ X 20%. 8$ versus 2$. That means over time you will win 8$ risking only 2$ on each toss of coin.
+
+Let's complicate it more: you win 80% of the time but only 2$, I win 20% of the time but 8$. The calculation is: 80% X 2$ versus 20% X 8$. It is becoming boring again because overtime you win $1.6$ (80% X 2$) and me $1.6 (20% X 8$) too.
+
+The question is: How do you calculate that? How do you know if you wanna play?
+
+The answer comes to two factors:
+- Win Rate
+- Risk Reward Ratio
+
+### Win Rate
+Win Rate (*W*) is is the mean over some amount of trades (*N*) what is the percentage of winning trades to total number of trades (note that we don't consider how much you gained but only if you won or not).
+
+    W = (Number of winning trades) / (Total number of trades) = (Number of winning trades) / N
+
+Complementary Loss Rate (*L*) is defined as
+
+    L = (Number of losing trades) / (Total number of trades) = (Number of losing trades) / N
+
+or, which is the same, as
+
+    L = 1 – W
+
+### Risk Reward Ratio
+Risk Reward Ratio (*R*) is a formula used to measure the expected gains of a given investment against the risk of loss. It is basically what you potentially win divided by what you potentially lose:
+
+    R = Profit / Loss
+
+Over time, on many trades, you can calculate your risk reward by dividing your average profit on winning trades by your average loss on losing trades:
+
+    Average profit = (Sum of profits) / (Number of winning trades)
+
+    Average loss = (Sum of losses) / (Number of losing trades)
+
+    R = (Average profit) / (Average loss)
+
+### Expectancy
+At this point we can combine *W* and *R* to create an expectancy ratio. This is a simple process of multiplying the risk reward ratio by the percentage of winning trades and subtracting the percentage of losing trades, which is calculated as follows:
+
+    Expectancy Ratio = (Risk Reward Ratio X Win Rate) – Loss Rate = (R X W) – L
+
+So lets say your Win rate is 28% and your Risk Reward Ratio is 5:
+
+    Expectancy = (5 X 0.28) – 0.72 = 0.68
+
+Superficially, this means that on average you expect this strategy’s trades to return .68 times the size of your loses. This is important for two reasons: First, it may seem obvious, but you know right away that you have a positive return. Second, you now have a number you can compare to other candidate systems to make decisions about which ones you employ.
+
+It is important to remember that any system with an expectancy greater than 0 is profitable using past data. The key is finding one that will be profitable in the future.
+
+You can also use this value to evaluate the effectiveness of modifications to this system.
+
+**NOTICE:** It's important to keep in mind that Edge is testing your expectancy using historical data, there's no guarantee that you will have a similar edge in the future. It's still vital to do this testing in order to build confidence in your methodology, but be wary of "curve-fitting" your approach to the historical data as things are unlikely to play out the exact same way for future trades.
+
+## How does it work?
+If enabled in config, Edge will go through historical data with a range of stoplosses in order to find buy and sell/stoploss signals. It then calculates win rate and expectancy over *N* trades for each stoploss. Here is an example:
+
+| Pair   |      Stoploss      |  Win Rate | Risk Reward Ratio | Expectancy |
+|----------|:-------------:|-------------:|------------------:|-----------:|
+| XZC/ETH  |  -0.01        |   0.50       |1.176384           | 0.088      |
+| XZC/ETH  |  -0.02        |   0.51       |1.115941           | 0.079      |
+| XZC/ETH  |  -0.03        |   0.52       |1.359670           | 0.228      |
+| XZC/ETH  |  -0.04        |   0.51       |1.234539           | 0.117      |
+
+The goal here is to find the best stoploss for the strategy in order to have the maximum expectancy. In the above example stoploss at 3% leads to the maximum expectancy according to historical data.
+
+Edge module then forces stoploss value it evaluated to your strategy dynamically.
+
+### Position size
+Edge also dictates the stake amount for each trade to the bot according to the following factors:
+
+- Allowed capital at risk
+- Stoploss
+
+Allowed capital at risk is calculated as follows:
+
+    Allowed capital at risk = (Capital available_percentage) X (Allowed risk per trade)
+
+Stoploss is calculated as described above against historical data.
+
+Your position size then will be:
+
+    Position size = (Allowed capital at risk) / Stoploss
+
+Example:
+
+Let's say the stake currency is ETH and you have 10 ETH on the exchange, your capital available percentage is 50% and you would allow 1% of risk for each trade. thus your available capital for trading is **10 x 0.5 = 5 ETH** and allowed capital at risk would be **5 x 0.01 = 0.05 ETH**.
+
+Let's assume Edge has calculated that for **XLM/ETH** market your stoploss should be at 2%. So your position size will be **0.05 / 0.02 = 2.5 ETH**.
+
+Bot takes a position of 2.5 ETH on XLM/ETH (call it trade 1). Up next, you receive another buy signal while trade 1 is still open. This time on **BTC/ETH** market. Edge calculated stoploss for this market at 4%. So your position size would be 0.05 / 0.04 = 1.25 ETH (call it trade 2).
+
+Note that available capital for trading didn’t change for trade 2 even if you had already trade 1. The available capital doesn’t mean the free amount on your wallet.
+
+Now you have two trades open. The bot receives yet another buy signal for another market: **ADA/ETH**. This time the stoploss is calculated at 1%. So your position size is **0.05 / 0.01 = 5 ETH**. But there are already 3.75 ETH blocked in two previous trades. So the position size for this third trade would be **5 – 3.75 = 1.25 ETH**.
+
+Available capital doesn’t change before a position is sold. Let’s assume that trade 1 receives a sell signal and it is sold with a profit of 1 ETH. Your total capital on exchange would be 11 ETH and the available capital for trading becomes 5.5 ETH.
+
+So the Bot receives another buy signal for trade 4 with a stoploss at 2% then your position size would be **0.055 / 0.02 = 2.75 ETH**.
+
+## Configurations
+Edge module has following configuration options:
+
+#### enabled
+If true, then Edge will run periodically.
+
+(defaults to false)
+
+#### process_throttle_secs
+How often should Edge run in seconds?
+
+(defaults to 3600 so one hour)
+
+#### calculate_since_number_of_days
+Number of days of data against which Edge calculates Win Rate, Risk Reward and Expectancy
+Note that it downloads historical data so increasing this number would lead to slowing down the bot.
+
+(defaults to 7)
+
+#### capital_available_percentage
+This is the percentage of the total capital on exchange in stake currency.
+
+As an example if you have 10 ETH available in your wallet on the exchange and this value is 0.5 (which is 50%), then the bot will use a maximum amount of 5 ETH for trading and considers it as available capital.
+
+(defaults to 0.5)
+
+#### allowed_risk
+Percentage of allowed risk per trade.
+
+(defaults to 0.01 so 1%)
+
+#### stoploss_range_min
+
+Minimum stoploss.
+
+(defaults to -0.01)
+
+#### stoploss_range_max
+
+Maximum stoploss.
+
+(defaults to -0.10)
+
+#### stoploss_range_step
+
+As an example if this is set to -0.01 then Edge will test the strategy for \[-0.01, -0,02, -0,03 ..., -0.09, -0.10\] ranges.
+Note than having a smaller step means having a bigger range which could lead to slow calculation.
+
+If you set this parameter to -0.001, you then slow down the Edge calculation by a factor of 10.
+
+(defaults to -0.01)
+
+#### minimum_winrate
+
+It filters out pairs which don't have at least minimum_winrate.
+
+This comes handy if you want to be conservative and don't comprise win rate in favour of risk reward ratio.
+
+(defaults to 0.60)
+
+#### minimum_expectancy
+
+It filters out pairs which have the expectancy lower than this number.
+
+Having an expectancy of 0.20 means if you put 10$ on a trade you expect a 12$ return.
+
+(defaults to 0.20)
+
+#### min_trade_number
+
+When calculating *W*, *R* and *E* (expectancy) against historical data, you always want to have a minimum number of trades. The more this number is the more Edge is reliable.
+
+Having a win rate of 100% on a single trade doesn't mean anything at all. But having a win rate of 70% over past 100 trades means clearly something.
+
+(defaults to 10, it is highly recommended not to decrease this number)
+
+#### max_trade_duration_minute
+
+Edge will filter out trades with long duration. If a trade is profitable after 1 month, it is hard to evaluate the strategy based on it. But if most of trades are profitable and they have maximum duration of 30 minutes, then it is clearly a good sign.
+
+**NOTICE:** While configuring this value, you should take into consideration your ticker interval. As an example filtering out trades having duration less than one day for a strategy which has 4h interval does not make sense. Default value is set assuming your strategy interval is relatively small (1m or 5m, etc.).
+
+(defaults to 1 day, i.e. to 60 * 24 = 1440 minutes)
+
+#### remove_pumps
+
+Edge will remove sudden pumps in a given market while going through historical data. However, given that pumps happen very often in crypto markets, we recommend you keep this off.
+
+(defaults to false)
+
+## Running Edge independently
+
+You can run Edge independently in order to see in details the result. Here is an example:
+
+```bash
+python3 freqtrade edge
+```
+
+An example of its output:
+
+| pair      |   stoploss |   win rate |   risk reward ratio |   required risk reward |   expectancy |   total number of trades |   average duration (min) |
+|:----------|-----------:|-----------:|--------------------:|-----------------------:|-------------:|-------------------------:|-------------------------:|
+| AGI/BTC   |      -0.02 |       0.64 |                5.86 |                   0.56 |         3.41 |                       14 |                       54 |
+| NXS/BTC   |      -0.03 |       0.64 |                2.99 |                   0.57 |         1.54 |                       11 |                       26 |
+| LEND/BTC  |      -0.02 |       0.82 |                2.05 |                   0.22 |         1.50 |                       11 |                       36 |
+| VIA/BTC   |      -0.01 |       0.55 |                3.01 |                   0.83 |         1.19 |                       11 |                       48 |
+| MTH/BTC   |      -0.09 |       0.56 |                2.82 |                   0.80 |         1.12 |                       18 |                       52 |
+| ARDR/BTC  |      -0.04 |       0.42 |                3.14 |                   1.40 |         0.73 |                       12 |                       42 |
+| BCPT/BTC  |      -0.01 |       0.71 |                1.34 |                   0.40 |         0.67 |                       14 |                       30 |
+| WINGS/BTC |      -0.02 |       0.56 |                1.97 |                   0.80 |         0.65 |                       27 |                       42 |
+| VIBE/BTC  |      -0.02 |       0.83 |                0.91 |                   0.20 |         0.59 |                       12 |                       35 |
+| MCO/BTC   |      -0.02 |       0.79 |                0.97 |                   0.27 |         0.55 |                       14 |                       31 |
+| GNT/BTC   |      -0.02 |       0.50 |                2.06 |                   1.00 |         0.53 |                       18 |                       24 |
+| HOT/BTC   |      -0.01 |       0.17 |                7.72 |                   4.81 |         0.50 |                      209 |                        7 |
+| SNM/BTC   |      -0.03 |       0.71 |                1.06 |                   0.42 |         0.45 |                       17 |                       38 |
+| APPC/BTC  |      -0.02 |       0.44 |                2.28 |                   1.27 |         0.44 |                       25 |                       43 |
+| NEBL/BTC  |      -0.03 |       0.63 |                1.29 |                   0.58 |         0.44 |                       19 |                       59 |
+
+### Update cached pairs with the latest data
+
+```bash
+python3 freqtrade edge --refresh-pairs-cached
+```
+
+### Precising stoploss range
+
+```bash
+python3 freqtrade edge --stoplosses=-0.01,-0.1,-0.001 #min,max,step
+```
+
+### Advanced use of timerange
+
+```bash
+python3 freqtrade edge --timerange=20181110-20181113
+```
+
+Doing `--timerange=-200` will get the last 200 timeframes from your inputdata. You can also specify specific dates, or a range span indexed by start and stop.
+
+The full timerange specification:
+
+* Use last 123 tickframes of data: `--timerange=-123`
+* Use first 123 tickframes of data: `--timerange=123-`
+* Use tickframes from line 123 through 456: `--timerange=123-456`
+* Use tickframes till 2018/01/31: `--timerange=-20180131`
+* Use tickframes since 2018/01/31: `--timerange=20180131-`
+* Use tickframes since 2018/01/31 till 2018/03/01 : `--timerange=20180131-20180301`
+* Use tickframes between POSIX timestamps 1527595200 1527618600: `--timerange=1527595200-1527618600`

docs/faq.md

@@ -0,0 +1,89 @@
+# Freqtrade FAQ
+
+### Freqtrade commons
+
+#### I have waited 5 minutes, why hasn't the bot made any trades yet?!
+
+Depending on the buy strategy, the amount of whitelisted coins, the
+situation of the market etc, it can take up to hours to find good entry
+position for a trade. Be patient!
+
+#### I have made 12 trades already, why is my total profit negative?!
+
+I understand your disappointment but unfortunately 12 trades is just
+not enough to say anything. If you run backtesting, you can see that our
+current algorithm does leave you on the plus side, but that is after
+thousands of trades and even there, you will be left with losses on
+specific coins that you have traded tens if not hundreds of times. We
+of course constantly aim to improve the bot but it will _always_ be a
+gamble, which should leave you with modest wins on monthly basis but
+you can't say much from few trades.
+
+#### I’d like to change the stake amount. Can I just stop the bot with /stop and then change the config.json and run it again?
+
+Not quite. Trades are persisted to a database but the configuration is
+currently only read when the bot is killed and restarted. `/stop` more
+like pauses. You can stop your bot, adjust settings and start it again.
+
+#### I want to improve the bot with a new strategy
+
+That's great. We have a nice backtesting and hyperoptimizing setup. See
+the tutorial [here|Testing-new-strategies-with-Hyperopt](bot-usage.md#hyperopt-commands).
+
+#### Is there a setting to only SELL the coins being held and not perform anymore BUYS?
+
+You can use the `/forcesell all` command from Telegram.
+
+### Hyperopt module
+
+#### How many epoch do I need to get a good Hyperopt result?
+
+Per default Hyperopts without `-e` or `--epochs` parameter will only
+run 100 epochs, means 100 evals of your triggers, guards, ... Too few
+to find a great result (unless if you are very lucky), so you probably
+have to run it for 10.000 or more. But it will take an eternity to
+compute.
+
+We recommend you to run it at least 10.000 epochs:
+
+```bash
+python3 freqtrade hyperopt -e 10000
+```
+
+or if you want intermediate result to see
+
+```bash
+for i in {1..100}; do python3 freqtrade hyperopt -e 100; done
+```
+
+#### Why it is so long to run hyperopt?
+
+Finding a great Hyperopt results takes time.
+
+If you wonder why it takes a while to find great hyperopt results
+
+This answer was written during the under the release 0.15.1, when we had:
+
+- 8 triggers
+- 9 guards: let's say we evaluate even 10 values from each
+- 1 stoploss calculation: let's say we want 10 values from that too to be evaluated
+
+The following calculation is still very rough and not very precise
+but it will give the idea. With only these triggers and guards there is
+already 8\*10^9\*10 evaluations. A roughly total of 80 billion evals.
+Did you run 100 000 evals? Congrats, you've done roughly 1 / 100 000 th
+of the search space.
+
+### Edge module
+
+#### Edge implements interesting approach for controlling position size, is there any theory behind it?
+
+The Edge module is mostly a result of brainstorming of [@mishaker](https://github.com/mishaker) and [@creslinux](https://github.com/creslinux) freqtrade team members.
+
+You can find further info on expectancy, winrate, 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/
+- http://www.lonestocktrader.com/make-money-trading-positive-expectancy/
+- https://www.babypips.com/trading/trade-expectancy-matter

docs/hyperopt.md

@@ -0,0 +1,302 @@
+# Hyperopt
+
+This page explains how to tune your strategy by finding the optimal
+parameters, a process called hyperparameter optimization. The bot uses several
+algorithms included in the `scikit-optimize` package to accomplish this. The
+search will burn all your CPU cores, make your laptop sound like a fighter jet
+and still take a long time.
+
+!!! Bug
+    Hyperopt will crash when used with only 1 CPU Core as found out in [Issue #1133](https://github.com/freqtrade/freqtrade/issues/1133)
+
+## Prepare Hyperopting
+
+Before we start digging into Hyperopt, we recommend you to take a look at
+an example hyperopt file located into [user_data/hyperopts/](https://github.com/freqtrade/freqtrade/blob/develop/user_data/hyperopts/test_hyperopt.py)
+
+Configuring hyperopt is similar to writing your own strategy, and many tasks will be similar and a lot of code can be copied across from the strategy.
+
+### Checklist on all tasks / possibilities in hyperopt
+
+Depending on the space you want to optimize, only some of the below are required.
+
+* fill `populate_indicators` - probably a copy from your strategy
+* fill `buy_strategy_generator` - for buy signal optimization
+* fill `indicator_space` - for buy signal optimzation
+* fill `sell_strategy_generator` - for sell signal optimization
+* fill `sell_indicator_space` - for sell signal optimzation
+* fill `roi_space` - for ROI optimization
+* fill `generate_roi_table` - for ROI optimization (if you need more than 3 entries)
+* fill `stoploss_space` - stoploss optimization
+* Optional but recommended
+  * copy `populate_buy_trend` from your strategy - otherwise default-strategy will be used
+  * copy `populate_sell_trend` from your strategy - otherwise default-strategy will be used
+
+### 1. Install a Custom Hyperopt File
+
+Put your hyperopt file into the folder`user_data/hyperopts`.
+
+Let assume you want a hyperopt file `awesome_hyperopt.py`:  
+Copy the file `user_data/hyperopts/sample_hyperopt.py` into `user_data/hyperopts/awesome_hyperopt.py`
+
+### 2. Configure your Guards and Triggers
+
+There are two places you need to change in your hyperopt file to add a new buy hyperopt for testing:
+
+- Inside `indicator_space()` - the parameters hyperopt shall be optimizing.
+- Inside `populate_buy_trend()` - applying the parameters.
+
+There you have two different types of indicators: 1. `guards` and 2. `triggers`.
+
+1. Guards are conditions like "never buy if ADX < 10", or never buy if current price is over EMA10.
+2. Triggers are ones that actually trigger buy in specific moment, like "buy when EMA5 crosses over EMA10" or "buy when close price touches lower bollinger band".
+
+Hyperoptimization will, for each eval round, pick one trigger and possibly
+multiple guards. The constructed strategy will be something like
+"*buy exactly when close price touches lower bollinger band, BUT only if
+ADX > 10*".
+
+If you have updated the buy strategy, ie. changed the contents of
+`populate_buy_trend()` method you have to update the `guards` and
+`triggers` hyperopts must use.
+
+#### Sell optimization
+
+Similar to the buy-signal above, sell-signals can also be optimized.
+Place the corresponding settings into the following methods
+
+* Inside `sell_indicator_space()` - the parameters hyperopt shall be optimizing.
+* Inside `populate_sell_trend()` - applying the parameters.
+
+The configuration and rules are the same than for buy signals.
+To avoid naming collisions in the search-space, please prefix all sell-spaces with `sell-`.
+
+## Solving a Mystery
+
+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.
+
+We will start by defining a search space:
+
+```python
+    def indicator_space() -> List[Dimension]:
+        """
+        Define your Hyperopt space for searching strategy parameters
+        """
+        return [
+            Integer(20, 40, name='adx-value'),
+            Integer(20, 40, name='rsi-value'),
+            Categorical([True, False], name='adx-enabled'),
+            Categorical([True, False], name='rsi-enabled'),
+            Categorical(['bb_lower', 'macd_cross_signal'], name='trigger')
+        ]
+```
+
+Above definition says: I have five parameters I want you to randomly combine
+to find the best combination. Two of them are integer values (`adx-value`
+and `rsi-value`) and I want you test in the range of values 20 to 40.
+Then we have three category variables. First two are either `True` or `False`.
+We use these to either enable or disable the ADX and RSI guards. The last
+one we call `trigger` and use it to decide which buy trigger we want to use.
+
+So let's write the buy strategy using these values:
+
+``` python
+        def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
+            conditions = []
+            # GUARDS AND TRENDS
+            if 'adx-enabled' in params and params['adx-enabled']:
+                conditions.append(dataframe['adx'] > params['adx-value'])
+            if 'rsi-enabled' in params and params['rsi-enabled']:
+                conditions.append(dataframe['rsi'] < params['rsi-value'])
+
+            # TRIGGERS
+            if 'trigger' in params:
+                if params['trigger'] == 'bb_lower':
+                    conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
+                if params['trigger'] == 'macd_cross_signal':
+                    conditions.append(qtpylib.crossed_above(
+                        dataframe['macd'], dataframe['macdsignal']
+                    ))
+
+            dataframe.loc[
+                reduce(lambda x, y: x & y, conditions),
+                'buy'] = 1
+
+            return dataframe
+
+        return populate_buy_trend
+```
+
+Hyperopting will now call this `populate_buy_trend` as many times you ask it (`epochs`)
+with different value combinations. It will then use the given historical data and make
+buys based on the buy signals generated with the above function and based on the results
+it will end with telling you which paramter combination produced the best profits.
+
+The search for best parameters starts with a few random combinations and then uses a
+regressor algorithm (currently ExtraTreesRegressor) to quickly find a parameter combination
+that minimizes the value of the objective function `calculate_loss` in `hyperopt.py`.
+
+The above setup expects to find ADX, RSI and Bollinger Bands in the populated indicators.
+When you want to test an indicator that isn't used by the bot currently, remember to
+add it to the `populate_indicators()` method in `hyperopt.py`.
+
+## Execute Hyperopt
+
+Once you have updated your hyperopt configuration you can run it.
+Because hyperopt tries a lot of combinations to find the best parameters it will take time you will have the result (more than 30 mins).
+
+We strongly recommend to use `screen` or `tmux` to prevent any connection loss.
+
+```bash
+python3 freqtrade -c config.json hyperopt --customhyperopt <hyperoptname> -e 5000 --spaces all
+```
+
+Use  `<hyperoptname>` as the name of the custom hyperopt used.
+
+The `-e` flag will set how many evaluations hyperopt will do. We recommend
+running at least several thousand evaluations.
+
+The `--spaces all` flag determines that all possible parameters should be optimized. Possibilities are listed below.
+
+!!! Warning
+    When switching parameters or changing configuration options, the file `user_data/hyperopt_results.pickle` should be removed. It's used to be able to continue interrupted calculations, but does not detect changes to settings or the hyperopt file.
+
+### Execute Hyperopt with Different Ticker-Data Source
+
+If you would like to hyperopt parameters using an alternate ticker data that
+you have on-disk, use the `--datadir PATH` option. Default hyperopt will
+use data from directory `user_data/data`.
+
+### Running Hyperopt with Smaller Testset
+
+Use the `--timerange` argument to change how much of the testset
+you want to use. The last N ticks/timeframes will be used.
+Example:
+
+```bash
+python3 freqtrade hyperopt --timerange -200
+```
+
+### Running Hyperopt with Smaller Search Space
+
+Use the `--spaces` argument to limit the search space used by hyperopt.
+Letting Hyperopt optimize everything is a huuuuge search space. Often it
+might make more sense to start by just searching for initial buy algorithm.
+Or maybe you just want to optimize your stoploss or roi table for that awesome
+new buy strategy you have.
+
+Legal values are:
+
+- `all`: optimize everything
+- `buy`: just search for a new buy strategy
+- `sell`: just search for a new sell strategy
+- `roi`: just optimize the minimal profit table for your strategy
+- `stoploss`: search for the best stoploss value
+- space-separated list of any of the above values for example `--spaces roi stoploss`
+
+## Understand the Hyperopt Result
+
+Once Hyperopt is completed you can use the result to create a new strategy.
+Given the following result from hyperopt:
+
+```
+Best result:
+   135 trades. Avg profit  0.57%. Total profit  0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins.
+with values:
+{    'adx-value': 44,
+     'rsi-value': 29,
+     'adx-enabled': False,
+     'rsi-enabled': True,
+     'trigger': 'bb_lower'}
+```
+
+You should understand this result like:
+
+- The buy trigger that worked best was `bb_lower`.
+- You should not use ADX because `adx-enabled: False`)
+- You should **consider** using the RSI indicator (`rsi-enabled: True` and the best value is `29.0` (`rsi-value: 29.0`)
+
+You have to look inside your strategy file into `buy_strategy_generator()`
+method, what those values match to.
+
+So for example you had `rsi-value: 29.0` so we would look at `rsi`-block, that translates to the following code block:
+
+```
+(dataframe['rsi'] < 29.0)
+```
+
+Translating your whole hyperopt result as the new buy-signal
+would then look like:
+
+```python
+def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
+    dataframe.loc[
+        (
+            (dataframe['rsi'] < 29.0) &  # rsi-value
+            dataframe['close'] < dataframe['bb_lowerband']  # trigger
+        ),
+        'buy'] = 1
+    return dataframe
+```
+
+### Understand Hyperopt ROI results
+
+If you are optimizing ROI, you're result will look as follows and include a ROI table.
+
+```
+Best result:
+   135 trades. Avg profit  0.57%. Total profit  0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins.
+with values:
+{   'adx-value': 44,
+    'rsi-value': 29,
+    'adx-enabled': false,
+    'rsi-enabled': True,
+    'trigger': 'bb_lower',
+    'roi_t1': 40,
+    'roi_t2': 57,
+    'roi_t3': 21,
+    'roi_p1': 0.03634636907306948,
+    'roi_p2': 0.055237357937802885,
+    'roi_p3': 0.015163796015548354,
+    'stoploss': -0.37996664668703606
+}
+ROI table:
+{   0: 0.10674752302642071,
+    21: 0.09158372701087236,
+    78: 0.03634636907306948,
+    118: 0}
+```
+
+This would translate to the following ROI table:
+
+``` python
+ minimal_roi = {
+        "118": 0,
+        "78": 0.0363463,
+        "21": 0.0915,
+        "0": 0.106
+    }
+```
+
+### Validate backtest result
+
+Once the optimized strategy has been implemented into your strategy, you should backtest this strategy to make sure everything is working as expected.
+To archive the same results (number of trades, ...) than during hyperopt, please use the command line flags `--disable-max-market-positions` and `--enable-position-stacking` for backtesting.
+
+This configuration is the default in hyperopt for performance reasons.
+
+You can overwrite position stacking in the configuration by explicitly setting `"position_stacking"=false` or by changing the relevant line in your hyperopt file [here](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/optimize/hyperopt.py#L191).
+
+Enabling the market-position for hyperopt is currently not possible.
+
+!!! Note
+    Dry/live runs will **NOT** use position stacking - therefore it does make sense to also validate the strategy without this as it's closer to reality.
+
+## Next Step
+
+Now you have a perfect bot and want to control it from Telegram. Your
+next step is to learn the [Telegram usage](telegram-usage.md).

docs/index.md

@@ -0,0 +1,67 @@
+# Freqtrade
+[![Build Status](https://travis-ci.org/freqtrade/freqtrade.svg?branch=develop)](https://travis-ci.org/freqtrade/freqtrade)
+[![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)
+
+<!-- Place this tag where you want the button to render. -->
+<a class="github-button" href="https://github.com/freqtrade/freqtrade" data-icon="octicon-star" data-size="large" aria-label="Star freqtrade/freqtrade on GitHub">Star</a>
+<!-- Place this tag where you want the button to render. -->
+<a class="github-button" href="https://github.com/freqtrade/freqtrade/fork" data-icon="octicon-repo-forked" data-size="large" aria-label="Fork freqtrade/freqtrade on GitHub">Fork</a>
+<!-- Place this tag where you want the button to render. -->
+<a class="github-button" href="https://github.com/freqtrade/freqtrade/archive/master.zip" data-icon="octicon-cloud-download" data-size="large" aria-label="Download freqtrade/freqtrade on GitHub">Download</a>
+<!-- Place this tag where you want the button to render. -->
+<a class="github-button" href="https://github.com/freqtrade" data-size="large" aria-label="Follow @freqtrade on GitHub">Follow @freqtrade</a>
+## Introduction
+Freqtrade is a cryptocurrency trading bot written in Python.
+
+!!! Danger "DISCLAIMER"
+    This software is for educational purposes only. Do not risk money which you are afraid to lose. USE THE SOFTWARE AT YOUR OWN RISK. THE AUTHORS AND ALL AFFILIATES ASSUME NO RESPONSIBILITY FOR YOUR TRADING RESULTS.
+
+    Always start by running a trading bot in Dry-run and do not engage money before you understand how it works and what profit/loss you should expect.
+
+    We strongly recommend you to have basic coding skills and Python knowledge. Do not hesitate to read the source code and understand the mechanisms of this bot, algorithms and techniques implemented in it.
+
+
+## Features
+ - Based on Python 3.6+: For botting on any operating system — Windows, macOS and Linux.
+ - Persistence: Persistence is achieved through sqlite database.
+ - Dry-run mode: Run the bot without playing money.
+ - Backtesting: Run a simulation of your buy/sell strategy with historical data.
+ - Strategy Optimization by machine learning: Use machine learning to optimize your buy/sell strategy parameters with real exchange data.
+ - 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.
+ - Whitelist crypto-currencies: Select which crypto-currency you want to trade or use dynamic whitelists based on market (pair) trade volume.
+ - Blacklist crypto-currencies: Select which crypto-currency you want to avoid.
+ - Manageable via Telegram: Manage the bot with Telegram.
+ - Display profit/loss in fiat: Display your profit/loss in any of 33 fiat currencies supported.
+ - Daily summary of profit/loss: Receive the daily summary of your profit/loss.
+ - Performance status report: Receive the performance status of your current trades.
+
+
+## Requirements
+### 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.
+
+### Hardware requirements
+To run this bot we recommend you a cloud instance with a minimum of:
+
+- 2GB RAM
+- 1GB disk space
+- 2vCPU
+
+### Software requirements
+- Python 3.6.x
+- pip (pip3)
+- git
+- TA-Lib
+- virtualenv (Recommended)
+- Docker (Recommended)
+
+
+## Support
+Help / Slack
+For any questions not covered by the documentation or for further information about the bot, we encourage you to join our Slack channel.
+
+Click [here](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE) to join Slack channel.
+
+## Ready to try?
+Begin by reading our installation guide [here](installation).

docs/installation.md

@@ -0,0 +1,496 @@
+# Installation
+This page explains how to prepare your environment for running the bot.
+
+## Prerequisite
+Before running your bot in production you will need to setup few
+external API. In production mode, the bot required valid Bittrex API
+credentials and a Telegram bot (optional but recommended).
+
+- [Setup your exchange account](#setup-your-exchange-account)
+- [Backtesting commands](#setup-your-telegram-bot)
+
+### Setup your exchange account
+*To be completed, please feel free to complete this section.*
+
+### Setup your Telegram bot
+The only things you need is a working Telegram bot and its API token.
+Below we explain how to create your Telegram Bot, and how to get your
+Telegram user id.
+
+### 1. Create your Telegram bot
+
+**1.1. Start a chat with https://telegram.me/BotFather**
+
+**1.2. Send the message `/newbot`. ** *BotFather response:*
+```
+Alright, a new bot. How are we going to call it? Please choose a name for your bot.
+```
+
+**1.3. Choose the public name of your bot (e.x. `Freqtrade bot`)**
+*BotFather response:*
+```
+Good. Now let's choose a username for your bot. It must end in `bot`. Like this, for example: TetrisBot or tetris_bot.
+```
+**1.4. Choose the name id of your bot (e.x "`My_own_freqtrade_bot`")**
+
+**1.5. Father bot will return you the token (API key)**<br/>
+Copy it and keep it you will use it for the config parameter `token`.
+*BotFather response:*
+```hl_lines="4"
+Done! Congratulations on your new bot. You will find it at t.me/My_own_freqtrade_bot. You can now add a description, about section and profile picture for your bot, see /help for a list of commands. By the way, when you've finished creating your cool bot, ping our Bot Support if you want a better username for it. Just make sure the bot is fully operational before you do this.
+
+Use this token to access the HTTP API:
+521095879:AAEcEZEL7ADJ56FtG_qD0bQJSKETbXCBCi0
+
+For a description of the Bot API, see this page: https://core.telegram.org/bots/api
+```
+**1.6. Don't forget to start the conversation with your bot, by clicking /START button**
+
+### 2. Get your user id
+**2.1. Talk to https://telegram.me/userinfobot**
+
+**2.2. Get your "Id", you will use it for the config parameter
+`chat_id`.**
+<hr/>
+## Quick start
+Freqtrade provides a Linux/MacOS script to install all dependencies and help you to configure the bot.
+
+```bash
+git clone git@github.com:freqtrade/freqtrade.git
+cd freqtrade
+git checkout develop
+./setup.sh --install
+```
+!!! Note
+    Windows installation is explained [here](#windows).
+<hr/>
+## Easy Installation - Linux Script
+
+If you are on Debian, Ubuntu or MacOS a freqtrade provides a script to Install, Update, Configure, and Reset your bot.
+
+```bash
+$ ./setup.sh
+usage:
+	-i,--install    Install freqtrade from scratch
+	-u,--update     Command git pull to update.
+	-r,--reset      Hard reset your develop/master branch.
+	-c,--config     Easy config generator (Will override your existing file).
+```
+
+** --install **
+
+This script will install everything you need to run the bot:
+
+* Mandatory software as: `Python3`, `ta-lib`, `wget`
+* Setup your virtualenv
+* Configure your `config.json` file
+
+This script is a combination of `install script` `--reset`, `--config`
+
+** --update **
+
+Update parameter will pull the last version of your current branch and update your virtualenv.
+
+** --reset **
+
+Reset parameter will hard reset your branch (only if you are on `master` or `develop`) and recreate your virtualenv.
+
+** --config **
+
+Config parameter is a `config.json` configurator. This script will ask you questions to setup your bot and create your `config.json`.
+
+------
+
+## Automatic Installation - Docker
+
+Start by downloading Docker for your platform:
+
+* [Mac](https://www.docker.com/products/docker#/mac)
+* [Windows](https://www.docker.com/products/docker#/windows)
+* [Linux](https://www.docker.com/products/docker#/linux)
+
+Once you have Docker installed, simply create the config file (e.g. `config.json`) and then create a Docker image for `freqtrade` using the Dockerfile in this repo.
+
+### 1. Prepare the Bot
+
+**1.1. Clone the git repository**
+
+Linux/Mac/Windows with WSL
+```bash
+git clone https://github.com/freqtrade/freqtrade.git
+```
+
+Windows with docker
+```bash
+git clone --config core.autocrlf=input https://github.com/freqtrade/freqtrade.git
+```
+
+**1.2. (Optional) Checkout the develop branch**
+
+```bash
+git checkout develop
+```
+
+**1.3. Go into the new directory**
+
+```bash
+cd freqtrade
+```
+
+**1.4. Copy `config.json.example` to `config.json`**
+
+```bash
+cp -n config.json.example config.json
+```
+
+> To edit the config please refer to the [Bot Configuration](configuration.md) page.
+
+**1.5. Create your database file *(optional - the bot will create it if it is missing)**
+
+Production
+
+```bash
+touch tradesv3.sqlite
+````
+
+Dry-Run
+
+```bash
+touch tradesv3.dryrun.sqlite
+```
+
+### 2. Download or build the docker image
+
+Either use the prebuilt image from docker hub - or build the image yourself if you would like more control on which version is used.
+
+Branches / tags available can be checked out on [Dockerhub](https://hub.docker.com/r/freqtradeorg/freqtrade/tags/).
+
+**2.1. Download the docker image**
+
+Pull the image from docker hub and (optionally) change the name of the image
+
+```bash
+docker pull freqtradeorg/freqtrade:develop
+# Optionally tag the repository so the run-commands remain shorter
+docker tag freqtradeorg/freqtrade:develop freqtrade
+```
+
+To update the image, simply run the above commands again and restart your running container.
+
+**2.2. Build the Docker image**
+
+```bash
+cd freqtrade
+docker build -t freqtrade .
+```
+
+If you are developing using Docker, use `Dockerfile.develop` to build a dev Docker image, which will also set up develop dependencies:
+
+```bash
+docker build -f ./Dockerfile.develop -t freqtrade-dev .
+```
+
+For security reasons, your configuration file will not be included in the image, you will need to bind mount it. It is also advised to bind mount an SQLite database file (see the "5. Run a restartable docker image" section) to keep it between  updates.
+
+### 3. Verify the Docker image
+
+After the build process you can verify that the image was created with:
+
+```bash
+docker images
+```
+
+### 4. Run the Docker image
+
+You can run a one-off container that is immediately deleted upon exiting with the following command (`config.json` must be in the current working directory):
+
+```bash
+docker run --rm -v /etc/localtime:/etc/localtime:ro -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
+```
+
+There is known issue in OSX Docker versions after 17.09.1, whereby /etc/localtime cannot be shared causing Docker to not start. A work-around for this is to start with the following cmd.
+
+```bash
+docker run --rm -e TZ=`ls -la /etc/localtime | cut -d/ -f8-9` -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
+```
+
+More information on this docker issue and work-around can be read [here](https://github.com/docker/for-mac/issues/2396).
+
+In this example, the database will be created inside the docker instance and will be lost when you will refresh your image.
+
+### 5. Run a restartable docker image
+
+To run a restartable instance in the background (feel free to place your configuration and database files wherever it feels comfortable on your filesystem).
+
+**5.1. Move your config file and database**
+
+```bash
+mkdir ~/.freqtrade
+mv config.json ~/.freqtrade
+mv tradesv3.sqlite ~/.freqtrade
+```
+
+**5.2. Run the docker image**
+
+```bash
+docker run -d \
+  --name freqtrade \
+  -v /etc/localtime:/etc/localtime:ro \
+  -v ~/.freqtrade/config.json:/freqtrade/config.json \
+  -v ~/.freqtrade/tradesv3.sqlite:/freqtrade/tradesv3.sqlite \
+  freqtrade --db-url sqlite:///tradesv3.sqlite
+```
+
+!!! Note
+    db-url defaults to `sqlite:///tradesv3.sqlite` but it defaults to `sqlite://` if `dry_run=True` is being used.
+    To override this behaviour use a custom db-url value: i.e.: `--db-url sqlite:///tradesv3.dryrun.sqlite`
+
+### 6. Monitor your Docker instance
+
+You can then use the following commands to monitor and manage your container:
+
+```bash
+docker logs freqtrade
+docker logs -f freqtrade
+docker restart freqtrade
+docker stop freqtrade
+docker start freqtrade
+```
+
+For more information on how to operate Docker, please refer to the [official Docker documentation](https://docs.docker.com/).
+
+!!! Note
+    You do not need to rebuild the image for configuration changes, it will suffice to edit `config.json` and restart the container.
+
+### 7. Backtest with docker
+
+The following assumes that the above steps (1-4) have been completed successfully.
+Also, backtest-data should be available at `~/.freqtrade/user_data/`.
+
+```bash
+docker run -d \
+  --name freqtrade \
+  -v /etc/localtime:/etc/localtime:ro \
+  -v ~/.freqtrade/config.json:/freqtrade/config.json \
+  -v ~/.freqtrade/tradesv3.sqlite:/freqtrade/tradesv3.sqlite \
+  -v ~/.freqtrade/user_data/:/freqtrade/user_data/ \
+  freqtrade --strategy AwsomelyProfitableStrategy backtesting
+```
+
+Head over to the [Backtesting Documentation](backtesting.md) for more details.
+
+!!! Note
+    Additional parameters can be appended after the image name (`freqtrade` in the above example).
+
+------
+
+## Custom Installation
+
+We've included/collected install instructions for Ubuntu 16.04, MacOS, and Windows. These are guidelines and your success may vary with other distros.
+OS Specific steps are listed first, the [Common](#common) section below is necessary for all systems.
+
+### Requirements
+
+Click each one for install guide:
+
+* [Python >= 3.6.x](http://docs.python-guide.org/en/latest/starting/installation/)
+* [pip](https://pip.pypa.io/en/stable/installing/)
+* [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
+* [virtualenv](https://virtualenv.pypa.io/en/stable/installation/) (Recommended)
+* [TA-Lib](https://mrjbq7.github.io/ta-lib/install.html)
+
+### Linux - Ubuntu 16.04
+
+#### Install Python 3.6, Git, and wget
+
+```bash
+sudo add-apt-repository ppa:jonathonf/python-3.6
+sudo apt-get update
+sudo apt-get install python3.6 python3.6-venv python3.6-dev build-essential autoconf libtool pkg-config make wget git
+```
+
+#### Raspberry Pi / Raspbian
+
+Before installing FreqTrade on a Raspberry Pi running the official Raspbian Image, make sure you have at least Python 3.6 installed. The default image only provides Python 3.5. Probably the easiest way to get a recent version of python is [miniconda](https://repo.continuum.io/miniconda/).
+
+The following assumes that miniconda3 is installed and available in your environment. Last miniconda3 installation file use python 3.4, we will update to python 3.6 on this installation.
+It's recommended to use (mini)conda for this as installation/compilation of `numpy`, `scipy` and `pandas` takes a long time.
+
+Additional package to install on your Raspbian, `libffi-dev` required by cryptography (from python-telegram-bot).
+
+``` bash
+conda config --add channels rpi
+conda install python=3.6
+conda create -n freqtrade python=3.6
+conda activate freqtrade
+conda install scipy pandas numpy
+
+sudo apt install libffi-dev
+python3 -m pip install -r requirements-pi.txt
+python3 -m pip install -e .
+```
+
+### MacOS
+
+#### Install Python 3.6, git and wget
+
+```bash
+brew install python3 git wget
+```
+
+### Common
+
+#### 1. Install TA-Lib
+
+Official webpage: https://mrjbq7.github.io/ta-lib/install.html
+
+```bash
+wget http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz
+tar xvzf 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
+./configure --prefix=/usr/local
+make
+sudo make install
+cd ..
+rm -rf ./ta-lib*
+```
+
+!!! Note
+    An already downloaded version of ta-lib is included in the repository, as the sourceforge.net source seems to have problems frequently.
+
+#### 2. Setup your Python virtual environment (virtualenv)
+
+!!! Note
+    This step is optional but strongly recommended to keep your system organized
+
+```bash
+python3 -m venv .env
+source .env/bin/activate
+```
+
+#### 3. Install FreqTrade
+
+Clone the git repository:
+
+```bash
+git clone https://github.com/freqtrade/freqtrade.git
+
+```
+
+Optionally checkout the stable/master branch:
+
+```bash
+git checkout master
+```
+
+#### 4. Initialize the configuration
+
+```bash
+cd freqtrade
+cp config.json.example config.json
+```
+
+> *To edit the config please refer to [Bot Configuration](configuration.md).*
+
+#### 5. Install python dependencies
+
+``` bash
+pip3 install --upgrade pip
+pip3 install -r requirements.txt
+pip3 install -e .
+```
+
+#### 6. Run the Bot
+
+If this is the first time you run the bot, ensure you are running it in Dry-run `"dry_run": true,` otherwise it will start to buy and sell coins.
+
+```bash
+python3.6 freqtrade -c config.json
+```
+
+*Note*: If you run the bot on a server, you should consider using [Docker](#automatic-installation---docker) a terminal multiplexer like `screen` or [`tmux`](https://en.wikipedia.org/wiki/Tmux) to avoid that the bot is stopped on logout.
+
+#### 7. [Optional] Configure `freqtrade` as a `systemd` service
+
+From the freqtrade repo... copy `freqtrade.service` to your systemd user directory (usually `~/.config/systemd/user`) and update `WorkingDirectory` and `ExecStart` to match your setup.
+
+After that you can start the daemon with:
+
+```bash
+systemctl --user start freqtrade
+```
+
+For this to be persistent (run when user is logged out) you'll need to enable `linger` for your freqtrade user.
+
+```bash
+sudo loginctl enable-linger "$USER"
+```
+
+If you run the bot as a service, you can use systemd service manager as a software watchdog monitoring freqtrade bot 
+state and restarting it in the case of failures. If the `internals.sd_notify` parameter is set to true in the 
+configuration or the `--sd-notify` command line option is used, the bot will send keep-alive ping messages to systemd 
+using the sd_notify (systemd notifications) protocol and will also tell systemd its current state (Running or Stopped) 
+when it changes. 
+
+The `freqtrade.service.watchdog` file contains an example of the service unit configuration file which uses systemd 
+as the watchdog.
+
+!!! Note 
+  The sd_notify communication between the bot and the systemd service manager will not work if the bot runs in a 
+  Docker container.
+
+------
+
+## Windows
+
+We recommend that Windows users use [Docker](#docker) 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.
+If that is not available on your system, feel free to try the instructions below, which led to success for some.
+
+### Install freqtrade manually
+
+#### Clone the git repository
+
+```bash
+git clone https://github.com/freqtrade/freqtrade.git
+```
+
+copy paste `config.json` to ``\path\freqtrade-develop\freqtrade`
+
+#### Install ta-lib
+
+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 precompiled windows Wheels [here](https://www.lfd.uci.edu/~gohlke/pythonlibs/#ta-lib), which needs to be downloaded and installed using `pip install TA_Lib‑0.4.17‑cp36‑cp36m‑win32.whl` (make sure to use the version matching your python version)
+
+```cmd
+>cd \path\freqtrade-develop
+>python -m venv .env
+>cd .env\Scripts
+>activate.bat
+>cd \path\freqtrade-develop
+REM optionally install ta-lib from wheel
+REM >pip install TA_Lib‑0.4.17‑cp36‑cp36m‑win32.whl
+>pip install -r requirements.txt
+>pip install -e .
+>python freqtrade\main.py
+```
+
+> Thanks [Owdr](https://github.com/Owdr) for the commands. Source: [Issue #222](https://github.com/freqtrade/freqtrade/issues/222)
+
+#### Error during installation under Windows
+
+``` bash
+error: Microsoft Visual C++ 14.0 is required. Get it with "Microsoft Visual C++ Build Tools": http://landinghub.visualstudio.com/visual-cpp-build-tools
+```
+
+Unfortunately, many packages requiring compilation don't provide a pre-build wheel. It is therefore mandatory to have a C/C++ compiler installed and available for your python environment to use.
+
+The easiest way is to download install Microsoft Visual Studio Community [here](https://visualstudio.microsoft.com/downloads/) and make sure to install "Common Tools for Visual C++" to enable building c code on Windows. Unfortunately, this is a heavy download / dependency (~4Gb) so you might want to consider WSL or docker first.
+
+---
+
+Now you have an environment ready, the next step is
+[Bot Configuration](configuration.md).

docs/partials/header.html

@@ -0,0 +1,52 @@
+<header class="md-header" data-md-component="header">
+    <nav class="md-header-nav md-grid">
+        <div class="md-flex">
+            <div class="md-flex__cell md-flex__cell--shrink">
+                <a href="{{ config.site_url | default(nav.homepage.url, true) | url }}" title="{{ config.site_name }}"
+                    class="md-header-nav__button md-logo">
+                    {% if config.theme.logo.icon %}
+                    <i class="md-icon">{{ config.theme.logo.icon }}</i>
+                    {% else %}
+                    <img src="{{ config.theme.logo | url }}" width="24" height="24">
+                    {% endif %}
+                </a>
+            </div>
+            <div class="md-flex__cell md-flex__cell--shrink">
+                <label class="md-icon md-icon--menu md-header-nav__button" for="__drawer"></label>
+            </div>
+            <div class="md-flex__cell md-flex__cell--stretch">
+                <div class="md-flex__ellipsis md-header-nav__title" data-md-component="title">
+                    {% block site_name %}
+                    {% if config.site_name == page.title %}
+                    {{ config.site_name }}
+                    {% else %}
+                    <span class="md-header-nav__topic">
+                        {{ config.site_name }}
+                    </span>
+                    <span class="md-header-nav__topic">
+                        {{ page.title }}
+                    </span>
+                    {% endif %}
+                    {% endblock %}
+                </div>
+            </div>
+            <div class="md-flex__cell md-flex__cell--shrink">
+                {% block search_box %}
+                {% if "search" in config["plugins"] %}
+                <label class="md-icon md-icon--search md-header-nav__button" for="__search"></label>
+                {% include "partials/search.html" %}
+                {% endif %}
+                {% endblock %}
+            </div>
+            {% if config.repo_url %}
+            <div class="md-flex__cell md-flex__cell--shrink">
+                <div class="md-header-nav__source">
+                    {% include "partials/source.html" %}
+                </div>
+            </div>
+            {% endif %}
+        </div>
+    </nav>
+    <!-- Place this tag in your head or just before your close body tag. -->
+    <script async defer src="https://buttons.github.io/buttons.js"></script>
+</header>

docs/plotting.md

@@ -0,0 +1,88 @@
+# Plotting
+This page explains how to plot prices, indicator, profits.
+
+## Installation
+
+Plotting scripts use Plotly library. Install/upgrade it with:
+
+```
+pip install --upgrade plotly
+```
+
+At least version 2.3.0 is required.
+
+## Plot price and indicators
+Usage for the price plotter:
+
+```
+script/plot_dataframe.py [-h] [-p pairs] [--live]
+```
+
+Example
+```
+python scripts/plot_dataframe.py -p BTC/ETH
+```
+
+The `-p` pairs argument, can be used to specify
+pairs you would like to plot.
+
+**Advanced use**
+
+To plot multiple pairs, separate them with a comma:
+```
+python scripts/plot_dataframe.py -p BTC/ETH,XRP/ETH
+```
+
+To plot the current live price use the `--live` flag:
+```
+python scripts/plot_dataframe.py -p BTC/ETH --live
+```
+
+To plot a timerange (to zoom in):
+```
+python scripts/plot_dataframe.py -p BTC/ETH --timerange=100-200
+```
+Timerange doesn't work with live data.
+
+To plot trades stored in a database use `--db-url` argument:
+```
+python scripts/plot_dataframe.py --db-url sqlite:///tradesv3.dry_run.sqlite -p BTC/ETH
+```
+
+To plot a test strategy the strategy should have first be backtested.
+The results may then be plotted with the -s argument:
+```
+python scripts/plot_dataframe.py -s Strategy_Name -p BTC/ETH --datadir user_data/data/<exchange_name>/
+```
+
+## Plot profit
+
+The profit plotter show a picture with three plots:
+1) Average closing price for all pairs
+2) The summarized profit made by backtesting.
+   Note that this is not the real-world profit, but
+   more of an estimate.
+3) Each pair individually profit
+
+The first graph is good to get a grip of how the overall market
+progresses.
+
+The second graph will show how you algorithm works or doesnt.
+Perhaps you want an algorithm that steadily makes small profits,
+or one that acts less seldom, but makes big swings.
+
+The third graph can be useful to spot outliers, events in pairs
+that makes profit spikes.
+
+Usage for the profit plotter:
+
+```
+script/plot_profit.py [-h] [-p pair] [--datadir directory] [--ticker_interval num]
+```
+
+The `-p` pair argument, can be used to plot a single pair
+
+Example
+```
+python3 scripts/plot_profit.py --datadir ../freqtrade/freqtrade/tests/testdata-20171221/ -p LTC/BTC
+```

docs/requirements-docs.txt

@@ -0,0 +1 @@
+mkdocs-material==3.1.0

docs/sandbox-testing.md

@@ -0,0 +1,141 @@
+# Sandbox API testing
+
+Where an exchange provides a sandbox for risk-free integration, or end-to-end, testing CCXT provides access to these.
+
+This document is a *light overview of configuring Freqtrade and GDAX sandbox.
+This can be useful to developers and trader alike as Freqtrade is quite customisable.
+
+When testing your API connectivity, make sure to use the following URLs.
+***Website**
+https://public.sandbox.gdax.com
+***REST API**
+https://api-public.sandbox.gdax.com
+
+---
+
+# Configure a Sandbox account on Gdax
+
+Aim of this document section
+
+- An sanbox account
+- create 2FA (needed to create an API)
+- Add test 50BTC to account 
+- Create :
+- - API-KEY
+- - API-Secret
+- - API Password
+
+## Acccount
+
+This link will redirect to the sandbox main page to login / create account dialogues:
+https://public.sandbox.pro.coinbase.com/orders/
+
+After registration and Email confimation you wil be redirected into your sanbox account.  It is easy to verify you're in sandbox by checking the URL bar.
+> https://public.sandbox.pro.coinbase.com/
+
+## Enable 2Fa (a prerequisite to creating sandbox API Keys)
+
+From within sand box site select your profile, top right.
+>Or as a direct link: https://public.sandbox.pro.coinbase.com/profile
+
+From the menu panel to the left of the screen select
+
+> Security: "*View or Update*"
+
+In the new site select "enable authenticator" as typical google Authenticator.
+
+- open Google Authenticator on your phone
+- scan barcode
+- enter your generated 2fa
+
+## Enable API Access
+
+From within sandbox select profile>api>create api-keys
+>or as a direct link: https://public.sandbox.pro.coinbase.com/profile/api
+
+Click on "create one" and ensure  **view** and **trade**  are "checked" and sumbit your 2FA
+
+- **Copy and paste the Passphase** into a notepade this will be needed later
+- **Copy and paste the API Secret** popup into a notepad this will needed later
+- **Copy and paste the API Key** into a notepad this will needed later
+
+## Add 50 BTC test funds
+
+To add funds, use the web interface deposit and withdraw buttons.
+
+To begin select 'Wallets' from the top menu.
+> Or as a direct link: https://public.sandbox.pro.coinbase.com/wallets
+
+- Deposits (bottom left of screen)
+- - Deposit Funds Bitcoin
+- - - Coinbase BTC Wallet
+- - - - Max (50 BTC)
+- - - - - Deposit
+
+*This process may be repeated for other currencies, ETH as example*
+
+---
+
+# Configure Freqtrade to use Gax Sandbox 
+
+The aim of this document section
+
+- Enable sandbox URLs in Freqtrade
+- Configure API
+- - secret
+- - key
+- - passphrase
+ 
+## Sandbox URLs
+
+Freqtrade makes use of CCXT which in turn provides a list of URLs to Freqtrade.
+These include `['test']` and `['api']`.
+
+- `[Test]` if available will point to an Exchanges sandbox. 
+- `[Api]` normally used, and resolves to live API target on the exchange 
+
+To make use of sandbox / test add "sandbox": true, to your config.json
+
+```json
+  "exchange": {
+        "name": "gdax",
+        "sandbox": true,
+        "key": "5wowfxemogxeowo;heiohgmd",
+        "secret": "/ZMH1P62rCVmwefewrgcewX8nh4gob+lywxfwfxwwfxwfNsH1ySgvWCUR/w==",
+        "password": "1bkjfkhfhfu6sr",
+        "outdated_offset": 5
+        "pair_whitelist": [
+            "BTC/USD"
+```
+
+Also insert your 
+
+- api-key  (noted earlier)
+- api-secret (noted earlier)
+- password (the passphrase - noted earlier)
+
+---
+
+## You should now be ready to test your sandbox
+
+Ensure Freqtrade logs show the sandbox URL, and trades made are shown in sandbox.
+** Typically the  BTC/USD has the most activity in sandbox to test against.
+
+## GDAX - Old Candles problem
+
+It is my experience that GDAX sandbox candles may be 20+- minutes out of date. This can cause trades to fail as one of Freqtrades safety checks.
+
+To disable this check, add / change the `"outdated_offset"` parameter in the exchange section of your configuration to adjust for this delay.
+Example based on the above configuration:
+
+```json
+  "exchange": {
+        "name": "gdax",
+        "sandbox": true,
+        "key": "5wowfxemogxeowo;heiohgmd",
+        "secret": "/ZMH1P62rCVmwefewrgcewX8nh4gob+lywxfwfxwwfxwfNsH1ySgvWCUR/w==",
+        "password": "1bkjfkhfhfu6sr",
+        "outdated_offset": 30
+        "pair_whitelist": [
+            "BTC/USD"
+```

docs/sql_cheatsheet.md

@@ -0,0 +1,108 @@
+# SQL Helper
+This page contains some help if you want to edit your sqlite db.
+
+## Install sqlite3
+**Ubuntu/Debian installation**
+```bash
+sudo apt-get install sqlite3
+```
+
+## Open the DB
+```bash
+sqlite3
+.open <filepath>
+```
+
+## Table structure
+
+### List tables
+```bash
+.tables
+```
+
+### Display table structure
+```bash
+.schema <table_name>
+```
+
+### Trade table structure
+```sql
+CREATE TABLE trades (
+	id INTEGER NOT NULL,
+	exchange VARCHAR NOT NULL,
+	pair VARCHAR NOT NULL,
+	is_open BOOLEAN NOT NULL,
+	fee_open FLOAT NOT NULL,
+	fee_close FLOAT NOT NULL,
+	open_rate FLOAT,
+	open_rate_requested FLOAT,
+	close_rate FLOAT,
+	close_rate_requested FLOAT,
+	close_profit FLOAT,
+	stake_amount FLOAT NOT NULL,
+	amount FLOAT,
+	open_date DATETIME NOT NULL,
+	close_date DATETIME,
+	open_order_id VARCHAR,
+	stop_loss FLOAT,
+	initial_stop_loss FLOAT,
+	stoploss_order_id VARCHAR,
+	stoploss_last_update DATETIME,
+	max_rate FLOAT,
+	sell_reason VARCHAR,
+	strategy VARCHAR,
+	ticker_interval INTEGER,
+	PRIMARY KEY (id),
+	CHECK (is_open IN (0, 1))
+);
+```
+
+## Get all trades in the table
+
+```sql
+SELECT * FROM trades;
+```
+
+## 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, 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 /forcesell, as forcesell orders are closed automatically by the bot on the next iteration.
+
+```sql
+UPDATE trades
+SET is_open=0, close_date=<close_date>, close_rate=<close_rate>, close_profit=close_rate/open_rate-1, sell_reason=<sell_reason>  
+WHERE id=<trade_ID_to_update>;
+```
+
+##### Example
+
+```sql
+UPDATE trades
+SET is_open=0, close_date='2017-12-20 03:08:45.103418', close_rate=0.19638016, close_profit=0.0496, sell_reason='force_sell'  
+WHERE id=31;
+```
+
+## Insert manually a new trade
+
+```sql
+INSERT INTO trades (exchange, pair, is_open, fee_open, fee_close, open_rate, stake_amount, amount, open_date)
+VALUES ('bittrex', 'ETH/BTC', 1, 0.0025, 0.0025, <open_rate>, <stake_amount>, <amount>, '<datetime>')
+```
+
+##### Example:
+
+```sql
+INSERT INTO trades (exchange, pair, is_open, fee_open, fee_close, open_rate, stake_amount, amount, open_date)
+VALUES ('bittrex', 'ETH/BTC', 1, 0.0025, 0.0025, 0.00258580, 0.002, 0.7715262081, '2017-11-28 12:44:24.000000')
+```
+
+## Fix wrong fees in the table
+If your DB was created before [PR#200](https://github.com/freqtrade/freqtrade/pull/200) was merged (before 12/23/17).
+
+```sql
+UPDATE trades SET fee=0.0025 WHERE fee=0.005;
+```

docs/stoploss.md

@@ -0,0 +1,65 @@
+# Stop Loss support
+
+At this stage the bot contains the following stoploss support modes:
+
+1. static stop loss, defined in either the strategy or configuration.
+2. trailing stop loss, defined in the configuration.
+3. trailing stop loss, custom positive loss, defined in configuration.
+
+!!! Note
+    All stoploss properties can be configured in either Strategy or configuration. Configuration values override strategy values.
+
+Those stoploss modes can be *on exchange* or *off exchange*. If the stoploss is *on exchange* it means a stoploss limit order is placed on the exchange immediately after buy order happens successfuly. This will protect you against sudden crashes in market as the order will be in the queue immediately and if market goes down then the order has more chance of being fulfilled.
+
+In case of stoploss on exchange there is another parameter called `stoploss_on_exchange_interval`. This configures the interval in seconds at which the bot will check the stoploss and update it if necessary. As an example in case of trailing stoploss if the order is on the exchange and the market is going up then the bot automatically cancels the previous stoploss order and put a new one with a stop value higher than previous one. It is clear that the bot cannot do it every 5 seconds otherwise it gets banned. So this parameter will tell the bot how often it should update the stoploss order. The default value is 60 (1 minute).
+
+!!! Note
+    Stoploss on exchange is only supported for Binance as of now.
+
+
+## Static Stop Loss
+
+This is very simple, basically you define a stop loss of x in your strategy file or alternative in the configuration, which
+will overwrite the strategy definition. This will basically try to sell your asset, the second the loss exceeds the defined loss.
+
+## Trail Stop Loss
+
+The initial value for this stop loss, is defined in your strategy or configuration. Just as you would define your Stop Loss normally.
+To enable this Feauture all you have to do is to define the configuration element:
+
+``` json
+"trailing_stop" : True
+```
+
+This will now activate an algorithm, which automatically moves your stop loss up every time the price of your asset increases.
+
+For example, simplified math,
+
+* you buy an asset at a price of 100$
+* your stop loss is defined at 2%
+* which means your stop loss, gets triggered once your asset dropped below 98$
+* assuming your asset now increases to 102$
+* your stop loss, will now be 2% of 102$ or 99.96$
+* now your asset drops in value to 101$, your stop loss, will still be 99.96$
+
+basically what this means is that your stop loss will be adjusted to be always be 2% of the highest observed price
+
+### Custom positive loss
+
+Due to demand, it is possible to have a default stop loss, when you are in the red with your buy, but once your profit surpasses a certain percentage,
+the system will utilize a new stop loss, which can be a different value. For example your default stop loss is 5%, but once you have 1.1% profit,
+it will be changed to be only a 1% stop loss, which trails the green candles until it goes below them.
+
+Both values can be configured in the main configuration file and requires `"trailing_stop": true` to be set to true.
+
+``` json
+    "trailing_stop_positive":  0.01,
+    "trailing_stop_positive_offset":  0.011,
+    "trailing_only_offset_is_reached": false
+```
+
+The 0.01 would translate to a 1% stop loss, once you hit 1.1% profit.
+
+You should also make sure to have this value (`trailing_stop_positive_offset`) lower than your minimal ROI, otherwise minimal ROI will apply first and sell your trade.
+
+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`.

docs/telegram-usage.md

@@ -0,0 +1,198 @@
+# Telegram usage
+
+## Prerequisite
+
+To control your bot with Telegram, you need first to
+[set up a Telegram bot](installation.md)
+and add your Telegram API keys into your config file.
+
+## Telegram commands
+
+Per default, the Telegram bot shows predefined commands. Some commands
+are only available by sending them to the bot. The table below list the
+official commands. You can ask at any moment for help with `/help`.
+
+|  Command | Default | Description |
+|----------|---------|-------------|
+| `/start` | | Starts the trader
+| `/stop` | | Stops the trader
+| `/stopbuy` | | Stops the trader from opening new trades. Gracefully closes open trades according to their rules.
+| `/reload_conf` | | Reloads the configuration file
+| `/status` | | Lists all open trades
+| `/status table` | | List all open trades in a table format
+| `/count` | | Displays number of trades used and available
+| `/profit` | | Display a summary of your profit/loss from close trades and some stats about your performance
+| `/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>` | 7 | Shows profit or loss per day, over the last n days
+| `/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
+
+Below, example of Telegram message you will receive for each command.
+
+### /start
+
+> **Status:** `running`
+
+### /stop
+
+> `Stopping trader ...`
+> **Status:** `stopped`
+
+### /stopbuy
+
+> **status:** `Setting max_open_trades to 0. Run /reload_conf to reset.`
+
+Prevents the bot from opening new trades by temporarily setting "max_open_trades" to 0. Open trades will be handled via their regular rules (ROI / Sell-signal, stoploss, ...).
+
+After this, give the bot time to close off open trades (can be checked via `/status table`).
+Once all positions are sold, run `/stop` to completely stop the bot.
+
+`/reload_conf` resets "max_open_trades" to the value set in the configuration and resets this command. 
+
+!!! warning
+   The stop-buy signal is ONLY active while the bot is running, and is not persisted anyway, so restarting the bot will cause this to reset.
+
+### /status
+
+For each open trade, the bot will send you the following message.
+
+> **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  Pair      Since    Profit
+----  --------  -------  --------
+  67  SC/BTC    1 d      13.33%
+ 123  CVC/BTC   1 h      12.95%
+```
+
+### /count
+
+Return the number of trades used and available.
+```
+current    max
+---------  -----
+     2     10
+```
+
+### /profit
+
+Return a summary of your profit/loss and performance.
+
+> **ROI:** Close trades  
+>   ∙ `0.00485701 BTC (258.45%)`  
+>   ∙ `62.968 USD`  
+> **ROI:** All trades  
+>   ∙ `0.00255280 BTC (143.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%`  
+
+### /forcesell <trade_id>
+
+> **BITTREX:** Selling BTC/LTC with limit `0.01650000 (profit: ~-4.07%, -0.00008168)`
+
+### /forcebuy <pair>
+
+> **BITTREX**: Buying ETH/BTC with limit `0.03400000` (`1.000000 ETH`, `225.290 USD`)
+
+Note that for this to work, `forcebuy_enable` needs to be set to true.
+
+[More details](configuration.md/#understand-forcebuy_enable)
+
+### /performance
+
+Return the performance of each crypto-currency the bot has sold.
+> Performance:
+> 1. `RCN/BTC 57.77%`  
+> 2. `PAY/BTC 56.91%`  
+> 3. `VIB/BTC 47.07%`  
+> 4. `SALT/BTC 30.24%`  
+> 5. `STORJ/BTC 27.24%`  
+> ...  
+
+### /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:** CVC  
+> **Available:** 86.64180098  
+> **Balance:** 86.64180098  
+> **Pending:** 0.0  
+
+### /daily <n>
+
+Per default `/daily` will return the 7 last days.
+The example below if for `/daily 3`:
+
+> **Daily Profit over the last 3 days:**
+```
+Day         Profit BTC      Profit USD
+----------  --------------  ------------
+2018-01-03  0.00224175 BTC  29,142 USD
+2018-01-02  0.00033131 BTC   4,307 USD
+2018-01-01  0.00269130 BTC  34.986 USD
+```
+
+### /whitelist
+
+Shows the current whitelist
+
+> 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]
+
+Shows the current blacklist.
+If Pair is set, then this pair will be added to the pairlist.
+Also supports multiple pairs, seperated by a space.
+Use `/reload_conf` to reset the blacklist.
+
+> Using blacklist `StaticPairList` with 2 pairs  
+>`DODGE/BTC`, `HOT/BTC`.
+
+### /edge
+
+Shows pairs validated by Edge along with their corresponding winrate, expectancy and stoploss values.
+
+> **Edge only validated following pairs:**
+```
+Pair        Winrate    Expectancy    Stoploss
+--------  ---------  ------------  ----------
+DOCK/ETH   0.522727      0.881821       -0.03
+PHX/ETH    0.677419      0.560488       -0.03
+HOT/ETH    0.733333      0.490492       -0.03
+HC/ETH     0.588235      0.280988       -0.02
+ARDR/ETH   0.366667      0.143059       -0.01
+```
+
+### /version
+
+> **Version:** `0.14.3`

docs/webhook-config.md

@@ -0,0 +1,69 @@
+# Webhook usage
+
+## Configuration
+
+Enable webhooks by adding a webhook-section to your configuration file, and setting `webhook.enabled` to `true`.
+
+Sample configuration (tested using IFTTT).
+
+```json
+  "webhook": {
+        "enabled": true,
+        "url": "https://maker.ifttt.com/trigger/<YOUREVENT>/with/key/<YOURKEY>/",
+        "webhookbuy": {
+            "value1": "Buying {pair}",
+            "value2": "limit {limit:8f}",
+            "value3": "{stake_amount:8f} {stake_currency}"
+        },
+        "webhooksell": {
+            "value1": "Selling {pair}",
+            "value2": "limit {limit:8f}",
+            "value3": "profit: {profit_amount:8f} {stake_currency}"
+        },
+        "webhookstatus": {
+            "value1": "Status: {status}",
+            "value2": "",
+            "value3": ""
+        }
+    },
+```
+
+The url in `webhook.url` should point to the correct url for your webhook. If you're using [IFTTT](https://ifttt.com) (as shown in the sample above) please insert our event and key to the url.
+
+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.
+
+### Webhookbuy
+
+The fields in `webhook.webhookbuy` are filled when the bot executes a buy. Parameters are filled using string.format.
+Possible parameters are:
+
+* `exchange`
+* `pair`
+* `limit`
+* `stake_amount`
+* `stake_currency`
+* `fiat_currency`
+
+### Webhooksell
+
+The fields in `webhook.webhooksell` are filled when the bot sells a trade. Parameters are filled using string.format.
+Possible parameters are:
+
+* `exchange`
+* `pair`
+* `gain`
+* `limit`
+* `amount`
+* `open_rate`
+* `current_rate`
+* `profit_amount`
+* `profit_percent`
+* `stake_currency`
+* `fiat_currency`
+* `sell_reason`
+
+### Webhookstatus
+
+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}`.

freqtrade.service

@@ -0,0 +1,14 @@
+[Unit]
+Description=Freqtrade Daemon
+After=network.target
+
+[Service]
+# Set WorkingDirectory and ExecStart to your file paths accordingly
+# NOTE: %h will be resolved to /home/<username>
+WorkingDirectory=%h/freqtrade
+ExecStart=/usr/bin/freqtrade
+Restart=on-failure
+
+[Install]
+WantedBy=default.target
+

freqtrade.service.watchdog

@@ -0,0 +1,30 @@
+[Unit]
+Description=Freqtrade Daemon
+After=network.target
+
+[Service]
+# Set WorkingDirectory and ExecStart to your file paths accordingly
+# NOTE: %h will be resolved to /home/<username>
+WorkingDirectory=%h/freqtrade
+ExecStart=/usr/bin/freqtrade --sd-notify
+
+Restart=always
+#Restart=on-failure
+
+# Note that we use Type=notify here
+Type=notify
+
+# Currently required if Type=notify
+NotifyAccess=all
+
+StartLimitInterval=1min
+StartLimitBurst=5
+
+TimeoutStartSec=1min
+
+# Use here (process_throttle_secs * 2) or longer time interval
+WatchdogSec=20
+
+[Install]
+WantedBy=default.target
+

freqtrade/__init__.py

@@ -1,3 +1,33 @@
-__version__ = '0.14.1'
+""" FreqTrade bot """
+__version__ = '0.18.5'
 
-from . import main
+
+class DependencyException(BaseException):
+    """
+    Indicates that a assumed dependency is not met.
+    This could happen when there is currently not enough money on the account.
+    """
+
+
+class OperationalException(BaseException):
+    """
+    Requires manual intervention.
+    This happens when an exchange returns an unexpected error during runtime
+    or given configuration is invalid.
+    """
+
+
+class InvalidOrderException(BaseException):
+    """
+    This is returned when the order is not valid. Example:
+    If stoploss on exchange order is hit, then trying to cancel the order
+    should return this exception.
+    """
+
+
+class TemporaryError(BaseException):
+    """
+    Temporary network or exchange related error.
+    This could happen when an exchange is congested, unavailable, or the user
+    has networking problems. Usually resolves itself after a time.
+    """

freqtrade/__main__.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""
+__main__.py for Freqtrade
+To launch Freqtrade as a module
+
+> python -m freqtrade (with Python >= 3.6)
+"""
+
+import sys
+
+from freqtrade import main
+
+if __name__ == '__main__':
+    main.set_loggers()
+    main.main(sys.argv[1:])

freqtrade/analyze.py

@@ -1,115 +0,0 @@
-import logging
-from datetime import timedelta
-
-import arrow
-import talib.abstract as ta
-from pandas import DataFrame, to_datetime
-
-from freqtrade.exchange import get_ticker_history
-from freqtrade.vendor.qtpylib.indicators import awesome_oscillator
-
-logging.basicConfig(level=logging.DEBUG,
-                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-
-def parse_ticker_dataframe(ticker: list) -> DataFrame:
-    """
-    Analyses the trend for the given ticker history
-    :param ticker: See exchange.get_ticker_history
-    :return: DataFrame
-    """
-    columns = {'C': 'close', 'V': 'volume', 'O': 'open', 'H': 'high', 'L': 'low', 'T': 'date'}
-    frame = DataFrame(ticker) \
-        .drop('BV', 1) \
-        .rename(columns=columns)
-    frame['date'] = to_datetime(frame['date'], utc=True, infer_datetime_format=True)
-    frame.sort_values('date', inplace=True)
-    return frame
-
-
-def populate_indicators(dataframe: DataFrame) -> DataFrame:
-    """
-    Adds several different TA indicators to the given DataFrame
-    """
-    dataframe['sar'] = ta.SAR(dataframe)
-    dataframe['adx'] = ta.ADX(dataframe)
-    stoch = ta.STOCHF(dataframe)
-    dataframe['fastd'] = stoch['fastd']
-    dataframe['fastk'] = stoch['fastk']
-    dataframe['blower'] = ta.BBANDS(dataframe, nbdevup=2, nbdevdn=2)['lowerband']
-    dataframe['sma'] = ta.SMA(dataframe, timeperiod=40)
-    dataframe['tema'] = ta.TEMA(dataframe, timeperiod=9)
-    dataframe['mfi'] = ta.MFI(dataframe)
-    dataframe['cci'] = ta.CCI(dataframe)
-    dataframe['rsi'] = ta.RSI(dataframe)
-    dataframe['mom'] = ta.MOM(dataframe)
-    dataframe['ema5'] = ta.EMA(dataframe, timeperiod=5)
-    dataframe['ema10'] = ta.EMA(dataframe, timeperiod=10)
-    dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50)
-    dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100)
-    dataframe['ao'] = awesome_oscillator(dataframe)
-    macd = ta.MACD(dataframe)
-    dataframe['macd'] = macd['macd']
-    dataframe['macdsignal'] = macd['macdsignal']
-    dataframe['macdhist'] = macd['macdhist']
-    return dataframe
-
-
-def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
-    """
-    Based on TA indicators, populates the buy trend for the given dataframe
-    :param dataframe: DataFrame
-    :return: DataFrame with buy column
-    """
-    dataframe.ix[
-        (dataframe['close'] < dataframe['sma']) &
-        (dataframe['tema'] <= dataframe['blower']) &
-        (dataframe['mfi'] < 25) &
-        (dataframe['fastd'] < 25) &
-        (dataframe['adx'] > 30),
-        'buy'] = 1
-    dataframe.ix[dataframe['buy'] == 1, 'buy_price'] = dataframe['close']
-
-    return dataframe
-
-
-def analyze_ticker(pair: str) -> DataFrame:
-    """
-    Get ticker data for given currency pair, push it to a DataFrame and
-    add several TA indicators and buy signal to it
-    :return DataFrame with ticker data and indicator data
-    """
-    data = get_ticker_history(pair)
-    dataframe = parse_ticker_dataframe(data)
-
-    if dataframe.empty:
-        logger.warning('Empty dataframe for pair %s', pair)
-        return dataframe
-
-    dataframe = populate_indicators(dataframe)
-    dataframe = populate_buy_trend(dataframe)
-    return dataframe
-
-
-def get_buy_signal(pair: str) -> bool:
-    """
-    Calculates a buy signal based several technical analysis indicators
-    :param pair: pair in format BTC_ANT or BTC-ANT
-    :return: True if pair is good for buying, False otherwise
-    """
-    dataframe = analyze_ticker(pair)
-
-    if dataframe.empty:
-        return False
-
-    latest = dataframe.iloc[-1]
-
-    # Check if dataframe is out of date
-    signal_date = arrow.get(latest['date'])
-    if signal_date < arrow.now() - timedelta(minutes=10):
-        return False
-
-    signal = latest['buy'] == 1
-    logger.debug('buy_trigger: %s (pair=%s, signal=%s)', latest['date'], pair, signal)
-    return signal

freqtrade/arguments.py

@@ -0,0 +1,456 @@
+"""
+This module contains the argument manager class
+"""
+
+import argparse
+import os
+import re
+from typing import List, NamedTuple, Optional
+import arrow
+from freqtrade import __version__, constants
+
+
+class TimeRange(NamedTuple):
+    """
+    NamedTuple Defining timerange inputs.
+    [start/stop]type defines if [start/stop]ts shall be used.
+    if *type is none, don't use corresponding startvalue.
+    """
+    starttype: Optional[str] = None
+    stoptype: Optional[str] = None
+    startts: int = 0
+    stopts: int = 0
+
+
+class Arguments(object):
+    """
+    Arguments Class. Manage the arguments received by the cli
+    """
+
+    def __init__(self, args: List[str], description: str) -> None:
+        self.args = args
+        self.parsed_arg: Optional[argparse.Namespace] = None
+        self.parser = argparse.ArgumentParser(description=description)
+
+    def _load_args(self) -> None:
+        self.common_args_parser()
+        self._build_subcommands()
+
+    def get_parsed_arg(self) -> argparse.Namespace:
+        """
+        Return the list of arguments
+        :return: List[str] List of arguments
+        """
+        if self.parsed_arg is None:
+            self._load_args()
+            self.parsed_arg = self.parse_args()
+
+        return self.parsed_arg
+
+    def parse_args(self) -> argparse.Namespace:
+        """
+        Parses given arguments and returns an argparse Namespace instance.
+        """
+        parsed_arg = self.parser.parse_args(self.args)
+
+        # Workaround issue in argparse with action='append' and default value
+        # (see https://bugs.python.org/issue16399)
+        if parsed_arg.config is None:
+            parsed_arg.config = [constants.DEFAULT_CONFIG]
+
+        return parsed_arg
+
+    def common_args_parser(self) -> None:
+        """
+        Parses given common arguments and returns them as a parsed object.
+        """
+        self.parser.add_argument(
+            '-v', '--verbose',
+            help='Verbose mode (-vv for more, -vvv to get all messages).',
+            action='count',
+            dest='loglevel',
+            default=0,
+        )
+        self.parser.add_argument(
+            '--logfile',
+            help='Log to the file specified',
+            dest='logfile',
+            type=str,
+            metavar='FILE'
+        )
+        self.parser.add_argument(
+            '--version',
+            action='version',
+            version=f'%(prog)s {__version__}'
+        )
+        self.parser.add_argument(
+            '-c', '--config',
+            help='Specify configuration file (default: %(default)s). '
+                 'Multiple --config options may be used.',
+            dest='config',
+            action='append',
+            type=str,
+            metavar='PATH',
+        )
+        self.parser.add_argument(
+            '-d', '--datadir',
+            help='Path to backtest data.',
+            dest='datadir',
+            default=None,
+            type=str,
+            metavar='PATH',
+        )
+        self.parser.add_argument(
+            '-s', '--strategy',
+            help='Specify strategy class name (default: %(default)s).',
+            dest='strategy',
+            default='DefaultStrategy',
+            type=str,
+            metavar='NAME',
+        )
+        self.parser.add_argument(
+            '--strategy-path',
+            help='Specify additional strategy lookup path.',
+            dest='strategy_path',
+            type=str,
+            metavar='PATH',
+        )
+        self.parser.add_argument(
+            '--dynamic-whitelist',
+            help='Dynamically generate and update whitelist'
+                 ' based on 24h BaseVolume (default: %(const)s).'
+                 ' DEPRECATED.',
+            dest='dynamic_whitelist',
+            const=constants.DYNAMIC_WHITELIST,
+            type=int,
+            metavar='INT',
+            nargs='?',
+        )
+        self.parser.add_argument(
+            '--db-url',
+            help='Override trades database URL, this is useful if dry_run is enabled'
+                 ' or in custom deployments (default: %(default)s).',
+            dest='db_url',
+            type=str,
+            metavar='PATH',
+        )
+        self.parser.add_argument(
+            '--sd-notify',
+            help='Notify systemd service manager.',
+            action='store_true',
+            dest='sd_notify',
+        )
+
+    @staticmethod
+    def backtesting_options(parser: argparse.ArgumentParser) -> None:
+        """
+        Parses given arguments for Backtesting scripts.
+        """
+        parser.add_argument(
+            '--eps', '--enable-position-stacking',
+            help='Allow buying the same pair multiple times (position stacking).',
+            action='store_true',
+            dest='position_stacking',
+            default=False
+        )
+        parser.add_argument(
+            '--dmmp', '--disable-max-market-positions',
+            help='Disable applying `max_open_trades` during backtest '
+                 '(same as setting `max_open_trades` to a very high number).',
+            action='store_false',
+            dest='use_max_market_positions',
+            default=True
+        )
+        parser.add_argument(
+            '-l', '--live',
+            help='Use live data.',
+            action='store_true',
+            dest='live',
+        )
+        parser.add_argument(
+            '-r', '--refresh-pairs-cached',
+            help='Refresh the pairs files in tests/testdata with the latest data from the '
+                 'exchange. Use it if you want to run your backtesting with up-to-date data.',
+            action='store_true',
+            dest='refresh_pairs',
+        )
+        parser.add_argument(
+            '--strategy-list',
+            help='Provide a commaseparated list of strategies to 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-DefaultStrategy.json',
+            nargs='+',
+            dest='strategy_list',
+        )
+        parser.add_argument(
+            '--export',
+            help='Export backtest results, argument are: trades. '
+                 'Example --export=trades',
+            type=str,
+            default=None,
+            dest='export',
+        )
+        parser.add_argument(
+            '--export-filename',
+            help='Save backtest results to this filename \
+                  requires --export to be set as well\
+                  Example --export-filename=user_data/backtest_data/backtest_today.json\
+                  (default: %(default)s)',
+            type=str,
+            default=os.path.join('user_data', 'backtest_data', 'backtest-result.json'),
+            dest='exportfilename',
+            metavar='PATH',
+        )
+
+    @staticmethod
+    def edge_options(parser: argparse.ArgumentParser) -> None:
+        """
+        Parses given arguments for Backtesting scripts.
+        """
+        parser.add_argument(
+            '-r', '--refresh-pairs-cached',
+            help='Refresh the pairs files in tests/testdata with the latest data from the '
+                 'exchange. Use it if you want to run your edge with up-to-date data.',
+            action='store_true',
+            dest='refresh_pairs',
+        )
+        parser.add_argument(
+            '--stoplosses',
+            help='Defines a range of stoploss against which edge will assess the strategy '
+                 'the format is "min,max,step" (without any space).'
+                 'example: --stoplosses=-0.01,-0.1,-0.001',
+            type=str,
+            dest='stoploss_range',
+        )
+
+    @staticmethod
+    def optimizer_shared_options(parser: argparse.ArgumentParser) -> None:
+        """
+        Parses given common arguments for Backtesting and Hyperopt scripts.
+        :param parser:
+        :return:
+        """
+        parser.add_argument(
+            '-i', '--ticker-interval',
+            help='Specify ticker interval (1m, 5m, 30m, 1h, 1d).',
+            dest='ticker_interval',
+            type=str,
+        )
+
+        parser.add_argument(
+            '--timerange',
+            help='Specify what timerange of data to use.',
+            default=None,
+            type=str,
+            dest='timerange',
+        )
+
+        parser.add_argument(
+            '--max_open_trades',
+            help='Specify max_open_trades to use.',
+            default=None,
+            type=int,
+            dest='max_open_trades',
+        )
+
+        parser.add_argument(
+            '--stake_amount',
+            help='Specify stake_amount.',
+            default=None,
+            type=float,
+            dest='stake_amount',
+        )
+
+    @staticmethod
+    def hyperopt_options(parser: argparse.ArgumentParser) -> None:
+        """
+        Parses given arguments for Hyperopt scripts.
+        """
+        parser.add_argument(
+            '--customhyperopt',
+            help='Specify hyperopt class name (default: %(default)s).',
+            dest='hyperopt',
+            default=constants.DEFAULT_HYPEROPT,
+            type=str,
+            metavar='NAME',
+        )
+        parser.add_argument(
+            '--eps', '--enable-position-stacking',
+            help='Allow buying the same pair multiple times (position stacking).',
+            action='store_true',
+            dest='position_stacking',
+            default=False
+        )
+
+        parser.add_argument(
+            '--dmmp', '--disable-max-market-positions',
+            help='Disable applying `max_open_trades` during backtest '
+                 '(same as setting `max_open_trades` to a very high number).',
+            action='store_false',
+            dest='use_max_market_positions',
+            default=True
+        )
+        parser.add_argument(
+            '-e', '--epochs',
+            help='Specify number of epochs (default: %(default)d).',
+            dest='epochs',
+            default=constants.HYPEROPT_EPOCH,
+            type=int,
+            metavar='INT',
+        )
+        parser.add_argument(
+            '-s', '--spaces',
+            help='Specify which parameters to hyperopt. Space separate list. \
+                  Default: %(default)s.',
+            choices=['all', 'buy', 'sell', 'roi', 'stoploss'],
+            default='all',
+            nargs='+',
+            dest='spaces',
+        )
+
+    def _build_subcommands(self) -> None:
+        """
+        Builds and attaches all subcommands
+        :return: None
+        """
+        from freqtrade.optimize import backtesting, hyperopt, edge_cli
+
+        subparsers = self.parser.add_subparsers(dest='subparser')
+
+        # Add backtesting subcommand
+        backtesting_cmd = subparsers.add_parser('backtesting', help='Backtesting module.')
+        backtesting_cmd.set_defaults(func=backtesting.start)
+        self.optimizer_shared_options(backtesting_cmd)
+        self.backtesting_options(backtesting_cmd)
+
+        # Add edge subcommand
+        edge_cmd = subparsers.add_parser('edge', help='Edge module.')
+        edge_cmd.set_defaults(func=edge_cli.start)
+        self.optimizer_shared_options(edge_cmd)
+        self.edge_options(edge_cmd)
+
+        # Add hyperopt subcommand
+        hyperopt_cmd = subparsers.add_parser('hyperopt', help='Hyperopt module.')
+        hyperopt_cmd.set_defaults(func=hyperopt.start)
+        self.optimizer_shared_options(hyperopt_cmd)
+        self.hyperopt_options(hyperopt_cmd)
+
+    @staticmethod
+    def parse_timerange(text: Optional[str]) -> TimeRange:
+        """
+        Parse the value of the argument --timerange to determine what is the range desired
+        :param text: value from --timerange
+        :return: Start and End range period
+        """
+        if text is None:
+            return TimeRange(None, None, 0, 0)
+        syntax = [(r'^-(\d{8})$', (None, 'date')),
+                  (r'^(\d{8})-$', ('date', None)),
+                  (r'^(\d{8})-(\d{8})$', ('date', 'date')),
+                  (r'^-(\d{10})$', (None, 'date')),
+                  (r'^(\d{10})-$', ('date', None)),
+                  (r'^(\d{10})-(\d{10})$', ('date', 'date')),
+                  (r'^(-\d+)$', (None, 'line')),
+                  (r'^(\d+)-$', ('line', None)),
+                  (r'^(\d+)-(\d+)$', ('index', 'index'))]
+        for rex, stype in syntax:
+            # Apply the regular expression to text
+            match = re.match(rex, text)
+            if match:  # Regex has matched
+                rvals = match.groups()
+                index = 0
+                start: int = 0
+                stop: int = 0
+                if stype[0]:
+                    starts = rvals[index]
+                    if stype[0] == 'date' and len(starts) == 8:
+                        start = arrow.get(starts, 'YYYYMMDD').timestamp
+                    else:
+                        start = int(starts)
+                    index += 1
+                if stype[1]:
+                    stops = rvals[index]
+                    if stype[1] == 'date' and len(stops) == 8:
+                        stop = arrow.get(stops, 'YYYYMMDD').timestamp
+                    else:
+                        stop = int(stops)
+                return TimeRange(stype[0], stype[1], start, stop)
+        raise Exception('Incorrect syntax for timerange "%s"' % text)
+
+    def scripts_options(self) -> None:
+        """
+        Parses given arguments for scripts.
+        """
+        self.parser.add_argument(
+            '-p', '--pairs',
+            help='Show profits for only this pairs. Pairs are comma-separated.',
+            dest='pairs',
+            default=None
+        )
+
+    def testdata_dl_options(self) -> None:
+        """
+        Parses given arguments for testdata download
+        """
+        self.parser.add_argument(
+            '--pairs-file',
+            help='File containing a list of pairs to download.',
+            dest='pairs_file',
+            default=None,
+            metavar='PATH',
+        )
+
+        self.parser.add_argument(
+            '--export',
+            help='Export files to given dir.',
+            dest='export',
+            default=None,
+            metavar='PATH',
+        )
+
+        self.parser.add_argument(
+            '-c', '--config',
+            help='Specify configuration file (default: %(default)s). '
+                 'Multiple --config options may be used.',
+            dest='config',
+            action='append',
+            type=str,
+            metavar='PATH',
+        )
+
+        self.parser.add_argument(
+            '--days',
+            help='Download data for given number of days.',
+            dest='days',
+            type=int,
+            metavar='INT',
+            default=None
+        )
+
+        self.parser.add_argument(
+            '--exchange',
+            help='Exchange name (default: %(default)s). Only valid if no config is provided.',
+            dest='exchange',
+            type=str,
+            default='bittrex'
+        )
+
+        self.parser.add_argument(
+            '-t', '--timeframes',
+            help='Specify which tickers to download. Space separated list. \
+                  Default: %(default)s.',
+            choices=['1m', '3m', '5m', '15m', '30m', '1h', '2h', '4h',
+                     '6h', '8h', '12h', '1d', '3d', '1w'],
+            default=['1m', '5m'],
+            nargs='+',
+            dest='timeframes',
+        )
+
+        self.parser.add_argument(
+            '--erase',
+            help='Clean all existing data for the selected exchange/pairs/timeframes.',
+            dest='erase',
+            action='store_true'
+        )

freqtrade/configuration.py

@@ -0,0 +1,398 @@
+"""
+This module contains the configuration class
+"""
+import json
+import logging
+import os
+import sys
+from argparse import Namespace
+from logging.handlers import RotatingFileHandler
+from typing import Any, Dict, List, Optional
+
+import ccxt
+from jsonschema import Draft4Validator, validate
+from jsonschema.exceptions import ValidationError, best_match
+
+from freqtrade import OperationalException, constants
+from freqtrade.misc import deep_merge_dicts
+from freqtrade.state import RunMode
+
+logger = logging.getLogger(__name__)
+
+
+def set_loggers(log_level: int = 0) -> None:
+    """
+    Set the logger level for Third party libs
+    :return: None
+    """
+
+    logging.getLogger('requests').setLevel(logging.INFO if log_level <= 1 else logging.DEBUG)
+    logging.getLogger("urllib3").setLevel(logging.INFO if log_level <= 1 else logging.DEBUG)
+    logging.getLogger('ccxt.base.exchange').setLevel(
+        logging.INFO if log_level <= 2 else logging.DEBUG)
+    logging.getLogger('telegram').setLevel(logging.INFO)
+
+
+class Configuration(object):
+    """
+    Class to read and init the bot configuration
+    Reuse this class for the bot, backtesting, hyperopt and every script that required configuration
+    """
+
+    def __init__(self, args: Namespace, runmode: RunMode = None) -> None:
+        self.args = args
+        self.config: Optional[Dict[str, Any]] = None
+        self.runmode = runmode
+
+    def load_config(self) -> Dict[str, Any]:
+        """
+        Extract information for sys.argv and load the bot configuration
+        :return: Configuration dictionary
+        """
+        config: Dict[str, Any] = {}
+        # Now expecting a list of config filenames here, not a string
+        for path in self.args.config:
+            logger.info('Using config: %s ...', path)
+            # Merge config options, overwriting old values
+            config = deep_merge_dicts(self._load_config_file(path), config)
+
+        if 'internals' not in config:
+            config['internals'] = {}
+
+        logger.info('Validating configuration ...')
+        self._validate_config_schema(config)
+        self._validate_config_consistency(config)
+
+        # Set strategy if not specified in config and or if it's non default
+        if self.args.strategy != constants.DEFAULT_STRATEGY or not config.get('strategy'):
+            config.update({'strategy': self.args.strategy})
+
+        if self.args.strategy_path:
+            config.update({'strategy_path': self.args.strategy_path})
+
+        # Load Common configuration
+        config = self._load_common_config(config)
+
+        # Load Backtesting
+        config = self._load_backtesting_config(config)
+
+        # Load Edge
+        config = self._load_edge_config(config)
+
+        # Load Hyperopt
+        config = self._load_hyperopt_config(config)
+
+        # Set runmode
+        if not self.runmode:
+            # Handle real mode, infer dry/live from config
+            self.runmode = RunMode.DRY_RUN if config.get('dry_run', True) else RunMode.LIVE
+
+        config.update({'runmode': self.runmode})
+
+        return config
+
+    def _load_config_file(self, path: str) -> Dict[str, Any]:
+        """
+        Loads a config file from the given path
+        :param path: path as str
+        :return: configuration as dictionary
+        """
+        try:
+            with open(path) as file:
+                conf = json.load(file)
+        except FileNotFoundError:
+            raise OperationalException(
+                f'Config file "{path}" not found!'
+                ' Please create a config file or check whether it exists.')
+
+        return conf
+
+    def _load_common_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Extract information for sys.argv and load common configuration
+        :return: configuration as dictionary
+        """
+
+        # Log level
+        if 'loglevel' in self.args and self.args.loglevel:
+            config.update({'verbosity': self.args.loglevel})
+        else:
+            config.update({'verbosity': 0})
+
+        # Log to stdout, not stderr
+        log_handlers: List[logging.Handler] = [logging.StreamHandler(sys.stdout)]
+        if 'logfile' in self.args and self.args.logfile:
+            config.update({'logfile': self.args.logfile})
+
+        # Allow setting this as either configuration or argument
+        if 'logfile' in config:
+            log_handlers.append(RotatingFileHandler(config['logfile'],
+                                                    maxBytes=1024 * 1024,  # 1Mb
+                                                    backupCount=10))
+
+        logging.basicConfig(
+            level=logging.INFO if config['verbosity'] < 1 else logging.DEBUG,
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+            handlers=log_handlers
+        )
+        set_loggers(config['verbosity'])
+        logger.info('Verbosity set to %s', config['verbosity'])
+
+        # Support for sd_notify
+        if self.args.sd_notify:
+            config['internals'].update({'sd_notify': True})
+
+        # Add dynamic_whitelist if found
+        if 'dynamic_whitelist' in self.args and self.args.dynamic_whitelist:
+            # Update to volumePairList (the previous default)
+            config['pairlist'] = {'method': 'VolumePairList',
+                                  'config': {'number_assets': self.args.dynamic_whitelist}
+                                  }
+            logger.warning(
+                'Parameter --dynamic-whitelist has been deprecated, '
+                'and will be completely replaced by the whitelist dict in the future. '
+                'For now: using dynamically generated whitelist based on VolumePairList. '
+                '(not applicable with Backtesting and Hyperopt)'
+            )
+
+        if self.args.db_url and self.args.db_url != constants.DEFAULT_DB_PROD_URL:
+            config.update({'db_url': self.args.db_url})
+            logger.info('Parameter --db-url detected ...')
+
+        if config.get('dry_run', False):
+            logger.info('Dry run is enabled')
+            if config.get('db_url') in [None, constants.DEFAULT_DB_PROD_URL]:
+                # Default to in-memory db for dry_run if not specified
+                config['db_url'] = constants.DEFAULT_DB_DRYRUN_URL
+        else:
+            if not config.get('db_url', None):
+                config['db_url'] = constants.DEFAULT_DB_PROD_URL
+            logger.info('Dry run is disabled')
+
+        if config.get('forcebuy_enable', False):
+            logger.warning('`forcebuy` RPC message enabled.')
+
+        # Setting max_open_trades to infinite if -1
+        if config.get('max_open_trades') == -1:
+            config['max_open_trades'] = float('inf')
+
+        logger.info(f'Using DB: "{config["db_url"]}"')
+
+        # Check if the exchange set by the user is supported
+        self.check_exchange(config)
+
+        return config
+
+    def _create_datadir(self, config: Dict[str, Any], datadir: Optional[str] = None) -> str:
+        if not datadir:
+            # set datadir
+            exchange_name = config.get('exchange', {}).get('name').lower()
+            datadir = os.path.join('user_data', 'data', exchange_name)
+
+        if not os.path.isdir(datadir):
+            os.makedirs(datadir)
+            logger.info(f'Created data directory: {datadir}')
+        return datadir
+
+    def _load_backtesting_config(self, config: Dict[str, Any]) -> Dict[str, Any]:  # noqa: C901
+        """
+        Extract information for sys.argv and load Backtesting configuration
+        :return: configuration as dictionary
+        """
+
+        # If -i/--ticker-interval is used we override the configuration parameter
+        # (that will override the strategy configuration)
+        if 'ticker_interval' in self.args and self.args.ticker_interval:
+            config.update({'ticker_interval': self.args.ticker_interval})
+            logger.info('Parameter -i/--ticker-interval detected ...')
+            logger.info('Using ticker_interval: %s ...', config.get('ticker_interval'))
+
+        # If -l/--live is used we add it to the configuration
+        if 'live' in self.args and self.args.live:
+            config.update({'live': True})
+            logger.info('Parameter -l/--live detected ...')
+
+        # If --enable-position-stacking is used we add it to the configuration
+        if 'position_stacking' in self.args and self.args.position_stacking:
+            config.update({'position_stacking': True})
+            logger.info('Parameter --enable-position-stacking detected ...')
+
+        # If --disable-max-market-positions or --max_open_trades is used we update configuration
+        if 'use_max_market_positions' in self.args and not self.args.use_max_market_positions:
+            config.update({'use_max_market_positions': False})
+            logger.info('Parameter --disable-max-market-positions detected ...')
+            logger.info('max_open_trades set to unlimited ...')
+        elif 'max_open_trades' in self.args and self.args.max_open_trades:
+            config.update({'max_open_trades': self.args.max_open_trades})
+            logger.info('Parameter --max_open_trades detected, '
+                        'overriding max_open_trades to: %s ...', config.get('max_open_trades'))
+        else:
+            logger.info('Using max_open_trades: %s ...', config.get('max_open_trades'))
+
+        # If --stake_amount is used we update configuration
+        if 'stake_amount' in self.args and self.args.stake_amount:
+            config.update({'stake_amount': self.args.stake_amount})
+            logger.info('Parameter --stake_amount detected, overriding stake_amount to: %s ...',
+                        config.get('stake_amount'))
+
+        # If --timerange is used we add it to the configuration
+        if 'timerange' in self.args and self.args.timerange:
+            config.update({'timerange': self.args.timerange})
+            logger.info('Parameter --timerange detected: %s ...', self.args.timerange)
+
+        # If --datadir is used we add it to the configuration
+        if 'datadir' in self.args and self.args.datadir:
+            config.update({'datadir': self._create_datadir(config, self.args.datadir)})
+        else:
+            config.update({'datadir': self._create_datadir(config, None)})
+        logger.info('Using data folder: %s ...', config.get('datadir'))
+
+        # If -r/--refresh-pairs-cached is used we add it to the configuration
+        if 'refresh_pairs' in self.args and self.args.refresh_pairs:
+            config.update({'refresh_pairs': True})
+            logger.info('Parameter -r/--refresh-pairs-cached detected ...')
+
+        if 'strategy_list' in self.args and self.args.strategy_list:
+            config.update({'strategy_list': self.args.strategy_list})
+            logger.info('Using strategy list of %s Strategies', len(self.args.strategy_list))
+
+        if 'ticker_interval' in self.args and self.args.ticker_interval:
+            config.update({'ticker_interval': self.args.ticker_interval})
+            logger.info('Overriding ticker interval with Command line argument')
+
+        # If --export is used we add it to the configuration
+        if 'export' in self.args and self.args.export:
+            config.update({'export': self.args.export})
+            logger.info('Parameter --export detected: %s ...', self.args.export)
+
+        # If --export-filename is used we add it to the configuration
+        if 'export' in config and 'exportfilename' in self.args and self.args.exportfilename:
+            config.update({'exportfilename': self.args.exportfilename})
+            logger.info('Storing backtest results to %s ...', self.args.exportfilename)
+
+        return config
+
+    def _load_edge_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Extract information for sys.argv and load Edge configuration
+        :return: configuration as dictionary
+        """
+
+        # If --timerange is used we add it to the configuration
+        if 'timerange' in self.args and self.args.timerange:
+            config.update({'timerange': self.args.timerange})
+            logger.info('Parameter --timerange detected: %s ...', self.args.timerange)
+
+        # If --timerange is used we add it to the configuration
+        if 'stoploss_range' in self.args and self.args.stoploss_range:
+            txt_range = eval(self.args.stoploss_range)
+            config['edge'].update({'stoploss_range_min': txt_range[0]})
+            config['edge'].update({'stoploss_range_max': txt_range[1]})
+            config['edge'].update({'stoploss_range_step': txt_range[2]})
+            logger.info('Parameter --stoplosses detected: %s ...', self.args.stoploss_range)
+
+        # If -r/--refresh-pairs-cached is used we add it to the configuration
+        if 'refresh_pairs' in self.args and self.args.refresh_pairs:
+            config.update({'refresh_pairs': True})
+            logger.info('Parameter -r/--refresh-pairs-cached detected ...')
+
+        return config
+
+    def _load_hyperopt_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Extract information for sys.argv and load Hyperopt configuration
+        :return: configuration as dictionary
+        """
+
+        if "hyperopt" in self.args:
+            # Add the hyperopt file to use
+            config.update({'hyperopt': self.args.hyperopt})
+
+        # If --epochs is used we add it to the configuration
+        if 'epochs' in self.args and self.args.epochs:
+            config.update({'epochs': self.args.epochs})
+            logger.info('Parameter --epochs detected ...')
+            logger.info('Will run Hyperopt with for %s epochs ...', config.get('epochs'))
+
+        # If --spaces is used we add it to the configuration
+        if 'spaces' in self.args and self.args.spaces:
+            config.update({'spaces': self.args.spaces})
+            logger.info('Parameter -s/--spaces detected: %s', config.get('spaces'))
+
+        return config
+
+    def _validate_config_schema(self, conf: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Validate the configuration follow the Config Schema
+        :param conf: Config in JSON format
+        :return: Returns the config if valid, otherwise throw an exception
+        """
+        try:
+            validate(conf, constants.CONF_SCHEMA, Draft4Validator)
+            return conf
+        except ValidationError as exception:
+            logger.critical(
+                'Invalid configuration. See config.json.example. Reason: %s',
+                exception
+            )
+            raise ValidationError(
+                best_match(Draft4Validator(constants.CONF_SCHEMA).iter_errors(conf)).message
+            )
+
+    def _validate_config_consistency(self, conf: Dict[str, Any]) -> None:
+        """
+        Validate the configuration consistency
+        :param conf: Config in JSON format
+        :return: Returns None if everything is ok, otherwise throw an OperationalException
+        """
+
+        # validating trailing stoploss
+        self._validate_trailing_stoploss(conf)
+
+    def _validate_trailing_stoploss(self, conf: Dict[str, Any]) -> None:
+        # Skip if trailing stoploss is not activated
+        if not conf.get('trailing_stop', False):
+            return
+
+        tsl_positive = float(conf.get('trailing_stop_positive', 0))
+        tsl_offset = float(conf.get('trailing_stop_positive_offset', 0))
+        tsl_only_offset = conf.get('trailing_only_offset_is_reached', False)
+
+        if tsl_only_offset:
+            if tsl_positive == 0.0:
+                raise OperationalException(
+                    f'The config trailing_only_offset_is_reached needs '
+                    'trailing_stop_positive_offset to be more than 0 in your config.')
+        if tsl_positive > 0 and 0 < tsl_offset <= tsl_positive:
+            raise OperationalException(
+                f'The config trailing_stop_positive_offset needs '
+                'to be greater than trailing_stop_positive_offset in your config.')
+
+    def get_config(self) -> Dict[str, Any]:
+        """
+        Return the config. Use this method to get the bot config
+        :return: Dict: Bot config
+        """
+        if self.config is None:
+            self.config = self.load_config()
+
+        return self.config
+
+    def check_exchange(self, config: Dict[str, Any]) -> bool:
+        """
+        Check if the exchange name in the config file is supported by Freqtrade
+        :return: True or raised an exception if the exchange if not supported
+        """
+        exchange = config.get('exchange', {}).get('name').lower()
+        if exchange not in ccxt.exchanges:
+
+            exception_msg = f'Exchange "{exchange}" not supported.\n' \
+                            f'The following exchanges are supported: {", ".join(ccxt.exchanges)}'
+
+            logger.critical(exception_msg)
+            raise OperationalException(
+                exception_msg
+            )
+
+        logger.debug('Exchange "%s" supported', exchange)
+        return True

freqtrade/constants.py

@@ -0,0 +1,235 @@
+# pragma pylint: disable=too-few-public-methods
+
+"""
+bot constants
+"""
+DEFAULT_CONFIG = 'config.json'
+DYNAMIC_WHITELIST = 20  # pairs
+PROCESS_THROTTLE_SECS = 5  # sec
+DEFAULT_TICKER_INTERVAL = 5  # min
+HYPEROPT_EPOCH = 100  # epochs
+RETRY_TIMEOUT = 30  # sec
+DEFAULT_STRATEGY = 'DefaultStrategy'
+DEFAULT_HYPEROPT = 'DefaultHyperOpts'
+DEFAULT_DB_PROD_URL = 'sqlite:///tradesv3.sqlite'
+DEFAULT_DB_DRYRUN_URL = 'sqlite://'
+UNLIMITED_STAKE_AMOUNT = 'unlimited'
+DEFAULT_AMOUNT_RESERVE_PERCENT = 0.05
+REQUIRED_ORDERTIF = ['buy', 'sell']
+REQUIRED_ORDERTYPES = ['buy', 'sell', 'stoploss', 'stoploss_on_exchange']
+ORDERTYPE_POSSIBILITIES = ['limit', 'market']
+ORDERTIF_POSSIBILITIES = ['gtc', 'fok', 'ioc']
+AVAILABLE_PAIRLISTS = ['StaticPairList', 'VolumePairList']
+DRY_RUN_WALLET = 999.9
+
+TICKER_INTERVALS = [
+    '1m', '3m', '5m', '15m', '30m',
+    '1h', '2h', '4h', '6h', '8h', '12h',
+    '1d', '3d', '1w',
+]
+
+SUPPORTED_FIAT = [
+    "AUD", "BRL", "CAD", "CHF", "CLP", "CNY", "CZK", "DKK",
+    "EUR", "GBP", "HKD", "HUF", "IDR", "ILS", "INR", "JPY",
+    "KRW", "MXN", "MYR", "NOK", "NZD", "PHP", "PKR", "PLN",
+    "RUB", "SEK", "SGD", "THB", "TRY", "TWD", "ZAR", "USD",
+    "BTC", "XBT", "ETH", "XRP", "LTC", "BCH", "USDT"
+]
+
+# Required json-schema for user specified config
+CONF_SCHEMA = {
+    'type': 'object',
+    'properties': {
+        'max_open_trades': {'type': 'integer', 'minimum': -1},
+        'ticker_interval': {'type': 'string', 'enum': TICKER_INTERVALS},
+        'stake_currency': {'type': 'string', 'enum': ['BTC', 'XBT', 'ETH', 'USDT', 'EUR', 'USD']},
+        'stake_amount': {
+            "type": ["number", "string"],
+            "minimum": 0.0005,
+            "pattern": UNLIMITED_STAKE_AMOUNT
+        },
+        'fiat_display_currency': {'type': 'string', 'enum': SUPPORTED_FIAT},
+        'dry_run': {'type': 'boolean'},
+        'dry_run_wallet': {'type': 'number'},
+        'process_only_new_candles': {'type': 'boolean'},
+        'minimal_roi': {
+            'type': 'object',
+            'patternProperties': {
+                '^[0-9.]+$': {'type': 'number'}
+            },
+            'minProperties': 1
+        },
+        'amount_reserve_percent': {'type': 'number', 'minimum': 0.0, 'maximum': 0.5},
+        'stoploss': {'type': 'number', 'maximum': 0, 'exclusiveMaximum': True},
+        'trailing_stop': {'type': 'boolean'},
+        'trailing_stop_positive': {'type': 'number', 'minimum': 0, 'maximum': 1},
+        'trailing_stop_positive_offset': {'type': 'number', 'minimum': 0, 'maximum': 1},
+        'trailing_only_offset_is_reached': {'type': 'boolean'},
+        'unfilledtimeout': {
+            'type': 'object',
+            'properties': {
+                'buy': {'type': 'number', 'minimum': 3},
+                'sell': {'type': 'number', 'minimum': 10}
+            }
+        },
+        'bid_strategy': {
+            'type': 'object',
+            'properties': {
+                'ask_last_balance': {
+                    'type': 'number',
+                    'minimum': 0,
+                    'maximum': 1,
+                    'exclusiveMaximum': False,
+                    'use_order_book': {'type': 'boolean'},
+                    'order_book_top': {'type': 'number', 'maximum': 20, 'minimum': 1},
+                    'check_depth_of_market': {
+                        'type': 'object',
+                        'properties': {
+                            'enabled': {'type': 'boolean'},
+                            'bids_to_ask_delta': {'type': 'number', 'minimum': 0},
+                        }
+                    },
+                },
+            },
+            'required': ['ask_last_balance']
+        },
+        'ask_strategy': {
+            'type': 'object',
+            'properties': {
+                'use_order_book': {'type': 'boolean'},
+                'order_book_min': {'type': 'number', 'minimum': 1},
+                'order_book_max': {'type': 'number', 'minimum': 1, 'maximum': 50}
+            }
+        },
+        'order_types': {
+            'type': 'object',
+            'properties': {
+                'buy': {'type': 'string', 'enum': ORDERTYPE_POSSIBILITIES},
+                'sell': {'type': 'string', 'enum': ORDERTYPE_POSSIBILITIES},
+                'stoploss': {'type': 'string', 'enum': ORDERTYPE_POSSIBILITIES},
+                'stoploss_on_exchange': {'type': 'boolean'},
+                'stoploss_on_exchange_interval': {'type': 'number'}
+            },
+            'required': ['buy', 'sell', 'stoploss', 'stoploss_on_exchange']
+        },
+        'order_time_in_force': {
+            'type': 'object',
+            'properties': {
+                'buy': {'type': 'string', 'enum': ORDERTIF_POSSIBILITIES},
+                'sell': {'type': 'string', 'enum': ORDERTIF_POSSIBILITIES}
+            },
+            'required': ['buy', 'sell']
+        },
+        'exchange': {'$ref': '#/definitions/exchange'},
+        'edge': {'$ref': '#/definitions/edge'},
+        'experimental': {
+            'type': 'object',
+            'properties': {
+                'use_sell_signal': {'type': 'boolean'},
+                'sell_profit_only': {'type': 'boolean'},
+                'ignore_roi_if_buy_signal_true': {'type': 'boolean'}
+            }
+        },
+        'pairlist': {
+            'type': 'object',
+            'properties': {
+                'method': {'type': 'string', 'enum': AVAILABLE_PAIRLISTS},
+                'config': {'type': 'object'}
+            },
+            'required': ['method']
+        },
+        'telegram': {
+            'type': 'object',
+            'properties': {
+                'enabled': {'type': 'boolean'},
+                'token': {'type': 'string'},
+                'chat_id': {'type': 'string'},
+            },
+            'required': ['enabled', 'token', 'chat_id']
+        },
+        'webhook': {
+            'type': 'object',
+            'properties': {
+                'enabled': {'type': 'boolean'},
+                'webhookbuy': {'type': 'object'},
+                'webhooksell': {'type': 'object'},
+                'webhookstatus': {'type': 'object'},
+            },
+        },
+        'db_url': {'type': 'string'},
+        'initial_state': {'type': 'string', 'enum': ['running', 'stopped']},
+        'forcebuy_enable': {'type': 'boolean'},
+        'internals': {
+            'type': 'object',
+            'properties': {
+                'process_throttle_secs': {'type': 'number'},
+                'interval': {'type': 'integer'},
+                'sd_notify': {'type': 'boolean'},
+            }
+        }
+    },
+    'definitions': {
+        'exchange': {
+            'type': 'object',
+            'properties': {
+                'name': {'type': 'string'},
+                'sandbox': {'type': 'boolean'},
+                'key': {'type': 'string'},
+                'secret': {'type': 'string'},
+                'password': {'type': 'string'},
+                'uid': {'type': 'string'},
+                'pair_whitelist': {
+                    'type': 'array',
+                    'items': {
+                        'type': 'string',
+                        'pattern': '^[0-9A-Z]+/[0-9A-Z]+$'
+                    },
+                    'uniqueItems': True
+                },
+                'pair_blacklist': {
+                    'type': 'array',
+                    'items': {
+                        'type': 'string',
+                        'pattern': '^[0-9A-Z]+/[0-9A-Z]+$'
+                    },
+                    'uniqueItems': True
+                },
+                'outdated_offset': {'type': 'integer', 'minimum': 1},
+                'markets_refresh_interval': {'type': 'integer'},
+                'ccxt_config': {'type': 'object'},
+                'ccxt_async_config': {'type': 'object'}
+            },
+            'required': ['name', 'key', 'secret', 'pair_whitelist']
+        },
+        'edge': {
+            'type': 'object',
+            'properties': {
+                "enabled": {'type': 'boolean'},
+                "process_throttle_secs": {'type': 'integer', 'minimum': 600},
+                "calculate_since_number_of_days": {'type': 'integer'},
+                "allowed_risk": {'type': 'number'},
+                "capital_available_percentage": {'type': 'number'},
+                "stoploss_range_min": {'type': 'number'},
+                "stoploss_range_max": {'type': 'number'},
+                "stoploss_range_step": {'type': 'number'},
+                "minimum_winrate": {'type': 'number'},
+                "minimum_expectancy": {'type': 'number'},
+                "min_trade_number": {'type': 'number'},
+                "max_trade_duration_minute": {'type': 'integer'},
+                "remove_pumps": {'type': 'boolean'}
+            },
+            'required': ['process_throttle_secs', 'allowed_risk', 'capital_available_percentage']
+        }
+    },
+    'anyOf': [
+        {'required': ['exchange']}
+    ],
+    'required': [
+        'max_open_trades',
+        'stake_currency',
+        'stake_amount',
+        'dry_run',
+        'bid_strategy',
+        'telegram'
+    ]
+}

freqtrade/data/__init__.py

@@ -0,0 +1,8 @@
+"""
+Module to handle data operations for freqtrade
+"""
+
+# limit what's imported when using `from freqtrad.data import *``
+__all__ = [
+    'converter'
+]

freqtrade/data/btanalysis.py

@@ -0,0 +1,67 @@
+"""
+Helpers when analyzing backtest data
+"""
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+from freqtrade.misc import json_load
+
+# must align with columns in backtest.py
+BT_DATA_COLUMNS = ["pair", "profitperc", "open_time", "close_time", "index", "duration",
+                   "open_rate", "close_rate", "open_at_end", "sell_reason"]
+
+
+def load_backtest_data(filename) -> pd.DataFrame:
+    """
+    Load backtest data file.
+    :param filename: pathlib.Path object, or string pointing to the file.
+    :return a dataframe with the analysis results
+    """
+    if isinstance(filename, str):
+        filename = Path(filename)
+
+    if not filename.is_file():
+        raise ValueError("File {filename} does not exist.")
+
+    with filename.open() as file:
+        data = json_load(file)
+
+    df = pd.DataFrame(data, columns=BT_DATA_COLUMNS)
+
+    df['open_time'] = pd.to_datetime(df['open_time'],
+                                     unit='s',
+                                     utc=True,
+                                     infer_datetime_format=True
+                                     )
+    df['close_time'] = pd.to_datetime(df['close_time'],
+                                      unit='s',
+                                      utc=True,
+                                      infer_datetime_format=True
+                                      )
+    df['profitabs'] = df['close_rate'] - df['open_rate']
+    df = df.sort_values("open_time").reset_index(drop=True)
+    return df
+
+
+def evaluate_result_multi(results: pd.DataFrame, freq: str, max_open_trades: int) -> pd.DataFrame:
+    """
+    Find overlapping trades by expanding each trade once per period it was open
+    and then counting overlaps
+    :param results: Results Dataframe - can be loaded
+    :param freq: Frequency used for the backtest
+    :param max_open_trades: parameter max_open_trades used during backtest run
+    :return: dataframe with open-counts per time-period in freq
+    """
+    dates = [pd.Series(pd.date_range(row[1].open_time, row[1].close_time, freq=freq))
+             for row in results[['open_time', 'close_time']].iterrows()]
+    deltas = [len(x) for x in dates]
+    dates = pd.Series(pd.concat(dates).values, name='date')
+    df2 = pd.DataFrame(np.repeat(results.values, deltas, axis=0), columns=results.columns)
+
+    df2 = df2.astype(dtype={"open_time": "datetime64", "close_time": "datetime64"})
+    df2 = pd.concat([dates, df2], axis=1)
+    df2 = df2.set_index('date')
+    df_final = df2.resample(freq)[['pair']].count()
+    return df_final[df_final['pair'] > max_open_trades]

freqtrade/data/converter.py

@@ -0,0 +1,106 @@
+"""
+Functions to convert data from one format to another
+"""
+import logging
+import pandas as pd
+from pandas import DataFrame, to_datetime
+from freqtrade.misc import timeframe_to_minutes
+
+
+logger = logging.getLogger(__name__)
+
+
+def parse_ticker_dataframe(ticker: list, ticker_interval: str,
+                           fill_missing: bool = True) -> DataFrame:
+    """
+    Converts a ticker-list (format ccxt.fetch_ohlcv) to a Dataframe
+    :param ticker: ticker list, as returned by exchange.async_get_candle_history
+    :param ticker_interval: ticker_interval (e.g. 5m). Used to fill up eventual missing data
+    :param fill_missing: fill up missing candles with 0 candles
+                         (see ohlcv_fill_up_missing_data for details)
+    :return: DataFrame
+    """
+    logger.debug("Parsing tickerlist to dataframe")
+    cols = ['date', 'open', 'high', 'low', 'close', 'volume']
+    frame = DataFrame(ticker, columns=cols)
+
+    frame['date'] = to_datetime(frame['date'],
+                                unit='ms',
+                                utc=True,
+                                infer_datetime_format=True)
+
+    # Some exchanges return int values for volume and even for ohlc.
+    # Convert them since TA-LIB indicators used in the strategy assume floats
+    # and fail with exception...
+    frame = frame.astype(dtype={'open': 'float', 'high': 'float', 'low': 'float', 'close': 'float',
+                                'volume': 'float'})
+
+    # group by index and aggregate results to eliminate duplicate ticks
+    frame = frame.groupby(by='date', as_index=False, sort=True).agg({
+        'open': 'first',
+        'high': 'max',
+        'low': 'min',
+        'close': 'last',
+        'volume': 'max',
+    })
+    frame.drop(frame.tail(1).index, inplace=True)     # eliminate partial candle
+    logger.debug('Dropping last candle')
+
+    if fill_missing:
+        return ohlcv_fill_up_missing_data(frame, ticker_interval)
+    else:
+        return frame
+
+
+def ohlcv_fill_up_missing_data(dataframe: DataFrame, ticker_interval: str) -> DataFrame:
+    """
+    Fills up missing data with 0 volume rows,
+    using the previous close as price for "open", "high" "low" and "close", volume is set to 0
+
+    """
+    ohlc_dict = {
+        'open': 'first',
+        'high': 'max',
+        'low': 'min',
+        'close': 'last',
+        'volume': 'sum'
+    }
+    ticker_minutes = timeframe_to_minutes(ticker_interval)
+    # Resample to create "NAN" values
+    df = dataframe.resample(f'{ticker_minutes}min', on='date').agg(ohlc_dict)
+
+    # Forwardfill close for missing columns
+    df['close'] = df['close'].fillna(method='ffill')
+    # Use close for "open, high, low"
+    df.loc[:, ['open', 'high', 'low']] = df[['open', 'high', 'low']].fillna(
+        value={'open': df['close'],
+               'high': df['close'],
+               'low': df['close'],
+               })
+    df.reset_index(inplace=True)
+    logger.debug(f"Missing data fillup: before: {len(dataframe)} - after: {len(df)}")
+    return df
+
+
+def order_book_to_dataframe(bids: list, asks: list) -> DataFrame:
+    """
+    Gets order book list, returns dataframe with below format per suggested by creslin
+    -------------------------------------------------------------------
+     b_sum       b_size       bids       asks       a_size       a_sum
+    -------------------------------------------------------------------
+    """
+    cols = ['bids', 'b_size']
+
+    bids_frame = DataFrame(bids, columns=cols)
+    # add cumulative sum column
+    bids_frame['b_sum'] = bids_frame['b_size'].cumsum()
+    cols2 = ['asks', 'a_size']
+    asks_frame = DataFrame(asks, columns=cols2)
+    # add cumulative sum column
+    asks_frame['a_sum'] = asks_frame['a_size'].cumsum()
+
+    frame = pd.concat([bids_frame['b_sum'], bids_frame['b_size'], bids_frame['bids'],
+                       asks_frame['asks'], asks_frame['a_size'], asks_frame['a_sum']], axis=1,
+                      keys=['b_sum', 'b_size', 'bids', 'asks', 'a_size', 'a_sum'])
+    # logger.info('order book %s', frame )
+    return frame

freqtrade/data/dataprovider.py

@@ -0,0 +1,97 @@
+"""
+Dataprovider
+Responsible to provide data to the bot
+including Klines, tickers, historic data
+Common Interface for bot and strategy to access data.
+"""
+import logging
+from pathlib import Path
+from typing import List, Tuple
+
+from pandas import DataFrame
+
+from freqtrade.data.history import load_pair_history
+from freqtrade.exchange import Exchange
+from freqtrade.state import RunMode
+
+logger = logging.getLogger(__name__)
+
+
+class DataProvider(object):
+
+    def __init__(self, config: dict, exchange: Exchange) -> None:
+        self._config = config
+        self._exchange = exchange
+
+    def refresh(self,
+                pairlist: List[Tuple[str, str]],
+                helping_pairs: List[Tuple[str, str]] = None) -> None:
+        """
+        Refresh data, called with each cycle
+        """
+        if helping_pairs:
+            self._exchange.refresh_latest_ohlcv(pairlist + helping_pairs)
+        else:
+            self._exchange.refresh_latest_ohlcv(pairlist)
+
+    @property
+    def available_pairs(self) -> List[Tuple[str, str]]:
+        """
+        Return a list of tuples containing pair, ticker_interval for which data is currently cached.
+        Should be whitelist + open trades.
+        """
+        return list(self._exchange._klines.keys())
+
+    def ohlcv(self, pair: str, ticker_interval: str = None, copy: bool = True) -> DataFrame:
+        """
+        get ohlcv data for the given pair as DataFrame
+        Please check `available_pairs` to verify which pairs are currently cached.
+        :param pair: pair to get the data for
+        :param ticker_interval: ticker_interval to get pair for
+        :param copy: copy dataframe before returning.
+                     Use false only for RO operations (where the dataframe is not modified)
+        """
+        if self.runmode in (RunMode.DRY_RUN, RunMode.LIVE):
+            if ticker_interval:
+                pairtick = (pair, ticker_interval)
+            else:
+                pairtick = (pair, self._config['ticker_interval'])
+
+            return self._exchange.klines(pairtick, copy=copy)
+        else:
+            return DataFrame()
+
+    def historic_ohlcv(self, pair: str, ticker_interval: str) -> DataFrame:
+        """
+        get stored historic ohlcv data
+        :param pair: pair to get the data for
+        :param ticker_interval: ticker_interval to get pair for
+        """
+        return load_pair_history(pair=pair,
+                                 ticker_interval=ticker_interval,
+                                 refresh_pairs=False,
+                                 datadir=Path(self._config['datadir']) if self._config.get(
+                                     'datadir') else None
+                                 )
+
+    def ticker(self, pair: str):
+        """
+        Return last ticker data
+        """
+        # TODO: Implement me
+        pass
+
+    def orderbook(self, pair: str, max: int):
+        """
+        return latest orderbook data
+        """
+        # TODO: Implement me
+        pass
+
+    @property
+    def runmode(self) -> RunMode:
+        """
+        Get runmode of the bot
+        can be "live", "dry-run", "backtest", "edgecli", "hyperopt" or "other".
+        """
+        return RunMode(self._config.get('runmode', RunMode.OTHER))

freqtrade/data/history.py

@@ -0,0 +1,237 @@
+"""
+Handle historic data (ohlcv).
+includes:
+* load data for a pair (or a list of pairs) from disk
+* download data from exchange and store to disk
+"""
+
+import logging
+from pathlib import Path
+from typing import Optional, List, Dict, Tuple, Any
+
+import arrow
+from pandas import DataFrame
+
+from freqtrade import misc, OperationalException
+from freqtrade.arguments import TimeRange
+from freqtrade.data.converter import parse_ticker_dataframe
+from freqtrade.exchange import Exchange
+from freqtrade.misc import timeframe_to_minutes
+
+
+logger = logging.getLogger(__name__)
+
+
+def trim_tickerlist(tickerlist: List[Dict], timerange: TimeRange) -> List[Dict]:
+    """
+    Trim tickerlist based on given timerange
+    """
+    if not tickerlist:
+        return tickerlist
+
+    start_index = 0
+    stop_index = len(tickerlist)
+
+    if timerange.starttype == 'line':
+        stop_index = timerange.startts
+    if timerange.starttype == 'index':
+        start_index = timerange.startts
+    elif timerange.starttype == 'date':
+        while (start_index < len(tickerlist) and
+               tickerlist[start_index][0] < timerange.startts * 1000):
+            start_index += 1
+
+    if timerange.stoptype == 'line':
+        start_index = len(tickerlist) + timerange.stopts
+    if timerange.stoptype == 'index':
+        stop_index = timerange.stopts
+    elif timerange.stoptype == 'date':
+        while (stop_index > 0 and
+               tickerlist[stop_index-1][0] > timerange.stopts * 1000):
+            stop_index -= 1
+
+    if start_index > stop_index:
+        raise ValueError(f'The timerange [{timerange.startts},{timerange.stopts}] is incorrect')
+
+    return tickerlist[start_index:stop_index]
+
+
+def load_tickerdata_file(
+        datadir: Optional[Path], pair: str,
+        ticker_interval: str,
+        timerange: Optional[TimeRange] = None) -> Optional[list]:
+    """
+    Load a pair from file, either .json.gz or .json
+    :return tickerlist or None if unsuccesful
+    """
+    path = make_testdata_path(datadir)
+    pair_s = pair.replace('/', '_')
+    file = path.joinpath(f'{pair_s}-{ticker_interval}.json')
+
+    pairdata = misc.file_load_json(file)
+
+    if not pairdata:
+        return None
+
+    if timerange:
+        pairdata = trim_tickerlist(pairdata, timerange)
+    return pairdata
+
+
+def load_pair_history(pair: str,
+                      ticker_interval: str,
+                      datadir: Optional[Path],
+                      timerange: TimeRange = TimeRange(None, None, 0, 0),
+                      refresh_pairs: bool = False,
+                      exchange: Optional[Exchange] = None,
+                      fill_up_missing: bool = True
+                      ) -> DataFrame:
+    """
+    Loads cached ticker history for the given pair.
+    :return: DataFrame with ohlcv data
+    """
+
+    # If the user force the refresh of pairs
+    if refresh_pairs:
+        if not exchange:
+            raise OperationalException("Exchange needs to be initialized when "
+                                       "calling load_data with refresh_pairs=True")
+
+        logger.info('Download data for pair and store them in %s', datadir)
+        download_pair_history(datadir=datadir,
+                              exchange=exchange,
+                              pair=pair,
+                              ticker_interval=ticker_interval,
+                              timerange=timerange)
+
+    pairdata = load_tickerdata_file(datadir, pair, ticker_interval, timerange=timerange)
+
+    if pairdata:
+        if timerange.starttype == 'date' and pairdata[0][0] > timerange.startts * 1000:
+            logger.warning('Missing data at start for pair %s, data starts at %s',
+                           pair, arrow.get(pairdata[0][0] // 1000).strftime('%Y-%m-%d %H:%M:%S'))
+        if timerange.stoptype == 'date' and pairdata[-1][0] < timerange.stopts * 1000:
+            logger.warning('Missing data at end for pair %s, data ends at %s',
+                           pair,
+                           arrow.get(pairdata[-1][0] // 1000).strftime('%Y-%m-%d %H:%M:%S'))
+        return parse_ticker_dataframe(pairdata, ticker_interval, fill_up_missing)
+    else:
+        logger.warning('No data for pair: "%s", Interval: %s. '
+                       'Use --refresh-pairs-cached to download the data',
+                       pair, ticker_interval)
+        return None
+
+
+def load_data(datadir: Optional[Path],
+              ticker_interval: str,
+              pairs: List[str],
+              refresh_pairs: bool = False,
+              exchange: Optional[Exchange] = None,
+              timerange: TimeRange = TimeRange(None, None, 0, 0),
+              fill_up_missing: bool = True) -> Dict[str, DataFrame]:
+    """
+    Loads ticker history data for a list of pairs the given parameters
+    :return: dict(<pair>:<tickerlist>)
+    """
+    result = {}
+
+    for pair in pairs:
+        hist = load_pair_history(pair=pair, ticker_interval=ticker_interval,
+                                 datadir=datadir, timerange=timerange,
+                                 refresh_pairs=refresh_pairs,
+                                 exchange=exchange,
+                                 fill_up_missing=fill_up_missing)
+        if hist is not None:
+            result[pair] = hist
+    return result
+
+
+def make_testdata_path(datadir: Optional[Path]) -> Path:
+    """Return the path where testdata files are stored"""
+    return datadir or (Path(__file__).parent.parent / "tests" / "testdata").resolve()
+
+
+def load_cached_data_for_updating(filename: Path, ticker_interval: str,
+                                  timerange: Optional[TimeRange]) -> Tuple[List[Any],
+                                                                           Optional[int]]:
+    """
+    Load cached data and choose what part of the data should be updated
+    """
+
+    since_ms = None
+
+    # user sets timerange, so find the start time
+    if timerange:
+        if timerange.starttype == 'date':
+            since_ms = timerange.startts * 1000
+        elif timerange.stoptype == 'line':
+            num_minutes = timerange.stopts * timeframe_to_minutes(ticker_interval)
+            since_ms = arrow.utcnow().shift(minutes=num_minutes).timestamp * 1000
+
+    # read the cached file
+    if filename.is_file():
+        with open(filename, "rt") as file:
+            data = misc.json_load(file)
+        # remove the last item, could be incomplete candle
+        if data:
+            data.pop()
+    else:
+        data = []
+
+    if data:
+        if since_ms and since_ms < data[0][0]:
+            # Earlier data than existing data requested, redownload all
+            data = []
+        else:
+            # a part of the data was already downloaded, so download unexist data only
+            since_ms = data[-1][0] + 1
+
+    return (data, since_ms)
+
+
+def download_pair_history(datadir: Optional[Path],
+                          exchange: Exchange,
+                          pair: str,
+                          ticker_interval: str = '5m',
+                          timerange: Optional[TimeRange] = None) -> bool:
+    """
+    Download the latest ticker intervals from the exchange for the pair passed in parameters
+    The data is downloaded starting from the last correct ticker interval data that
+    exists in a cache. If timerange starts earlier than the data in the cache,
+    the full data will be redownloaded
+
+    Based on @Rybolov work: https://github.com/rybolov/freqtrade-data
+    :param pair: pair to download
+    :param ticker_interval: ticker interval
+    :param timerange: range of time to download
+    :return: bool with success state
+
+    """
+    try:
+        path = make_testdata_path(datadir)
+        filepair = pair.replace("/", "_")
+        filename = path.joinpath(f'{filepair}-{ticker_interval}.json')
+
+        logger.info('Download the pair: "%s", Interval: %s', pair, ticker_interval)
+
+        data, since_ms = load_cached_data_for_updating(filename, ticker_interval, timerange)
+
+        logger.debug("Current Start: %s", misc.format_ms_time(data[1][0]) if data else 'None')
+        logger.debug("Current End: %s", misc.format_ms_time(data[-1][0]) if data else 'None')
+
+        # Default since_ms to 30 days if nothing is given
+        new_data = exchange.get_history(pair=pair, ticker_interval=ticker_interval,
+                                        since_ms=since_ms if since_ms
+                                        else
+                                        int(arrow.utcnow().shift(days=-30).float_timestamp) * 1000)
+        data.extend(new_data)
+
+        logger.debug("New Start: %s", misc.format_ms_time(data[0][0]))
+        logger.debug("New End: %s", misc.format_ms_time(data[-1][0]))
+
+        misc.file_dump_json(filename, data)
+        return True
+    except BaseException:
+        logger.info('Failed to download the pair: "%s", Interval: %s',
+                    pair, ticker_interval)
+        return False

freqtrade/edge/__init__.py

@@ -0,0 +1,459 @@
+# pragma pylint: disable=W0603
+""" Edge positioning package """
+import logging
+from pathlib import Path
+from typing import Any, Dict, NamedTuple
+
+import arrow
+import numpy as np
+import utils_find_1st as utf1st
+from pandas import DataFrame
+
+from freqtrade import constants, OperationalException
+from freqtrade.arguments import Arguments
+from freqtrade.arguments import TimeRange
+from freqtrade.data import history
+from freqtrade.optimize import get_timeframe
+from freqtrade.strategy.interface import SellType
+
+
+logger = logging.getLogger(__name__)
+
+
+class PairInfo(NamedTuple):
+    stoploss: float
+    winrate: float
+    risk_reward_ratio: float
+    required_risk_reward: float
+    expectancy: float
+    nb_trades: int
+    avg_trade_duration: float
+
+
+class Edge():
+    """
+    Calculates Win Rate, Risk Reward Ratio, Expectancy
+    against historical data for a give set of markets and a strategy
+    it then adjusts stoploss and position size accordingly
+    and force it into the strategy
+    Author: https://github.com/mishaker
+    """
+
+    config: Dict = {}
+    _cached_pairs: Dict[str, Any] = {}  # Keeps a list of pairs
+
+    def __init__(self, config: Dict[str, Any], exchange, strategy) -> None:
+
+        self.config = config
+        self.exchange = exchange
+        self.strategy = strategy
+        self.ticker_interval = self.strategy.ticker_interval
+        self.tickerdata_to_dataframe = self.strategy.tickerdata_to_dataframe
+        self.get_timeframe = get_timeframe
+        self.advise_sell = self.strategy.advise_sell
+        self.advise_buy = self.strategy.advise_buy
+
+        self.edge_config = self.config.get('edge', {})
+        self._cached_pairs: Dict[str, Any] = {}  # Keeps a list of pairs
+        self._final_pairs: list = []
+
+        # checking max_open_trades. it should be -1 as with Edge
+        # the number of trades is determined by position size
+        if self.config['max_open_trades'] != float('inf'):
+            logger.critical('max_open_trades should be -1 in config !')
+
+        if self.config['stake_amount'] != constants.UNLIMITED_STAKE_AMOUNT:
+            raise OperationalException('Edge works only with unlimited stake amount')
+
+        self._capital_percentage: float = self.edge_config.get('capital_available_percentage')
+        self._allowed_risk: float = self.edge_config.get('allowed_risk')
+        self._since_number_of_days: int = self.edge_config.get('calculate_since_number_of_days', 14)
+        self._last_updated: int = 0  # Timestamp of pairs last updated time
+        self._refresh_pairs = True
+
+        self._stoploss_range_min = float(self.edge_config.get('stoploss_range_min', -0.01))
+        self._stoploss_range_max = float(self.edge_config.get('stoploss_range_max', -0.05))
+        self._stoploss_range_step = float(self.edge_config.get('stoploss_range_step', -0.001))
+
+        # calculating stoploss range
+        self._stoploss_range = np.arange(
+            self._stoploss_range_min,
+            self._stoploss_range_max,
+            self._stoploss_range_step
+        )
+
+        self._timerange: TimeRange = Arguments.parse_timerange("%s-" % arrow.now().shift(
+            days=-1 * self._since_number_of_days).format('YYYYMMDD'))
+
+        self.fee = self.exchange.get_fee()
+
+    def calculate(self) -> bool:
+        pairs = self.config['exchange']['pair_whitelist']
+        heartbeat = self.edge_config.get('process_throttle_secs')
+
+        if (self._last_updated > 0) and (
+                self._last_updated + heartbeat > arrow.utcnow().timestamp):
+            return False
+
+        data: Dict[str, Any] = {}
+        logger.info('Using stake_currency: %s ...', self.config['stake_currency'])
+        logger.info('Using local backtesting data (using whitelist in given config) ...')
+
+        data = history.load_data(
+            datadir=Path(self.config['datadir']) if self.config.get('datadir') else None,
+            pairs=pairs,
+            ticker_interval=self.ticker_interval,
+            refresh_pairs=self._refresh_pairs,
+            exchange=self.exchange,
+            timerange=self._timerange
+        )
+
+        if not data:
+            # Reinitializing cached pairs
+            self._cached_pairs = {}
+            logger.critical("No data found. Edge is stopped ...")
+            return False
+
+        preprocessed = self.tickerdata_to_dataframe(data)
+
+        # Print timeframe
+        min_date, max_date = self.get_timeframe(preprocessed)
+        logger.info(
+            'Measuring data from %s up to %s (%s days) ...',
+            min_date.isoformat(),
+            max_date.isoformat(),
+            (max_date - min_date).days
+        )
+        headers = ['date', 'buy', 'open', 'close', 'sell', 'high', 'low']
+
+        trades: list = []
+        for pair, pair_data in preprocessed.items():
+            # Sorting dataframe by date and reset index
+            pair_data = pair_data.sort_values(by=['date'])
+            pair_data = pair_data.reset_index(drop=True)
+
+            ticker_data = self.advise_sell(
+                self.advise_buy(pair_data, {'pair': pair}), {'pair': pair})[headers].copy()
+
+            trades += self._find_trades_for_stoploss_range(ticker_data, pair, self._stoploss_range)
+
+        # If no trade found then exit
+        if len(trades) == 0:
+            return False
+
+        # Fill missing, calculable columns, profit, duration , abs etc.
+        trades_df = self._fill_calculable_fields(DataFrame(trades))
+        self._cached_pairs = self._process_expectancy(trades_df)
+        self._last_updated = arrow.utcnow().timestamp
+
+        return True
+
+    def stake_amount(self, pair: str, free_capital: float,
+                     total_capital: float, capital_in_trade: float) -> float:
+        stoploss = self.stoploss(pair)
+        available_capital = (total_capital + capital_in_trade) * self._capital_percentage
+        allowed_capital_at_risk = available_capital * self._allowed_risk
+        max_position_size = abs(allowed_capital_at_risk / stoploss)
+        position_size = min(max_position_size, free_capital)
+        if pair in self._cached_pairs:
+            logger.info(
+                'winrate: %s, expectancy: %s, position size: %s, pair: %s,'
+                ' capital in trade: %s, free capital: %s, total capital: %s,'
+                ' stoploss: %s, available capital: %s.',
+                self._cached_pairs[pair].winrate,
+                self._cached_pairs[pair].expectancy,
+                position_size, pair,
+                capital_in_trade, free_capital, total_capital,
+                stoploss, available_capital
+            )
+        return round(position_size, 15)
+
+    def stoploss(self, pair: str) -> float:
+        if pair in self._cached_pairs:
+            return self._cached_pairs[pair].stoploss
+        else:
+            logger.warning('tried to access stoploss of a non-existing pair, '
+                           'strategy stoploss is returned instead.')
+            return self.strategy.stoploss
+
+    def adjust(self, pairs) -> list:
+        """
+        Filters out and sorts "pairs" according to Edge calculated pairs
+        """
+        final = []
+        for pair, info in self._cached_pairs.items():
+            if info.expectancy > float(self.edge_config.get('minimum_expectancy', 0.2)) and \
+                info.winrate > float(self.edge_config.get('minimum_winrate', 0.60)) and \
+                    pair in pairs:
+                final.append(pair)
+
+        if self._final_pairs != final:
+            self._final_pairs = final
+            if self._final_pairs:
+                logger.info(
+                    'Minimum expectancy and minimum winrate are met only for %s,'
+                    ' so other pairs are filtered out.',
+                    self._final_pairs
+                    )
+            else:
+                logger.info(
+                    'Edge removed all pairs as no pair with minimum expectancy '
+                    'and minimum winrate was found !'
+                    )
+
+        return self._final_pairs
+
+    def accepted_pairs(self) -> list:
+        """
+        return a list of accepted pairs along with their winrate, expectancy and stoploss
+        """
+        final = []
+        for pair, info in self._cached_pairs.items():
+            if info.expectancy > float(self.edge_config.get('minimum_expectancy', 0.2)) and \
+                 info.winrate > float(self.edge_config.get('minimum_winrate', 0.60)):
+                final.append({
+                    'Pair': pair,
+                    'Winrate': info.winrate,
+                    'Expectancy': info.expectancy,
+                    'Stoploss': info.stoploss,
+                })
+        return final
+
+    def _fill_calculable_fields(self, result: DataFrame) -> DataFrame:
+        """
+        The result frame contains a number of columns that are calculable
+        from other columns. These are left blank till all rows are added,
+        to be populated in single vector calls.
+
+        Columns to be populated are:
+        - Profit
+        - trade duration
+        - profit abs
+        :param result Dataframe
+        :return: result Dataframe
+        """
+
+        # stake and fees
+        # stake = 0.015
+        # 0.05% is 0.0005
+        # fee = 0.001
+
+        # we set stake amount to an arbitrary amount.
+        # as it doesn't change the calculation.
+        # all returned values are relative. they are percentages.
+        stake = 0.015
+        fee = self.fee
+        open_fee = fee / 2
+        close_fee = fee / 2
+
+        result['trade_duration'] = result['close_time'] - result['open_time']
+
+        result['trade_duration'] = result['trade_duration'].map(
+            lambda x: int(x.total_seconds() / 60))
+
+        # Spends, Takes, Profit, Absolute Profit
+
+        # Buy Price
+        result['buy_vol'] = stake / result['open_rate']  # How many target are we buying
+        result['buy_fee'] = stake * open_fee
+        result['buy_spend'] = stake + result['buy_fee']  # How much we're spending
+
+        # Sell price
+        result['sell_sum'] = result['buy_vol'] * result['close_rate']
+        result['sell_fee'] = result['sell_sum'] * close_fee
+        result['sell_take'] = result['sell_sum'] - result['sell_fee']
+
+        # profit_percent
+        result['profit_percent'] = (result['sell_take'] - result['buy_spend']) / result['buy_spend']
+
+        # Absolute profit
+        result['profit_abs'] = result['sell_take'] - result['buy_spend']
+
+        return result
+
+    def _process_expectancy(self, results: DataFrame) -> Dict[str, Any]:
+        """
+        This calculates WinRate, Required Risk Reward, Risk Reward and Expectancy of all pairs
+        The calulation will be done per pair and per strategy.
+        """
+        # Removing pairs having less than min_trades_number
+        min_trades_number = self.edge_config.get('min_trade_number', 10)
+        results = results.groupby(['pair', 'stoploss']).filter(lambda x: len(x) > min_trades_number)
+        ###################################
+
+        # Removing outliers (Only Pumps) from the dataset
+        # The method to detect outliers is to calculate standard deviation
+        # Then every value more than (standard deviation + 2*average) is out (pump)
+        #
+        # Removing Pumps
+        if self.edge_config.get('remove_pumps', False):
+            results = results.groupby(['pair', 'stoploss']).apply(
+                lambda x: x[x['profit_abs'] < 2 * x['profit_abs'].std() + x['profit_abs'].mean()])
+        ##########################################################################
+
+        # Removing trades having a duration more than X minutes (set in config)
+        max_trade_duration = self.edge_config.get('max_trade_duration_minute', 1440)
+        results = results[results.trade_duration < max_trade_duration]
+        #######################################################################
+
+        if results.empty:
+            return {}
+
+        groupby_aggregator = {
+            'profit_abs': [
+                ('nb_trades', 'count'),  # number of all trades
+                ('profit_sum', lambda x: x[x > 0].sum()),  # cumulative profit of all winning trades
+                ('loss_sum', lambda x: abs(x[x < 0].sum())),  # cumulative loss of all losing trades
+                ('nb_win_trades', lambda x: x[x > 0].count())  # number of winning trades
+            ],
+            'trade_duration': [('avg_trade_duration', 'mean')]
+        }
+
+        # Group by (pair and stoploss) by applying above aggregator
+        df = results.groupby(['pair', 'stoploss'])['profit_abs', 'trade_duration'].agg(
+            groupby_aggregator).reset_index(col_level=1)
+
+        # Dropping level 0 as we don't need it
+        df.columns = df.columns.droplevel(0)
+
+        # Calculating number of losing trades, average win and average loss
+        df['nb_loss_trades'] = df['nb_trades'] - df['nb_win_trades']
+        df['average_win'] = df['profit_sum'] / df['nb_win_trades']
+        df['average_loss'] = df['loss_sum'] / df['nb_loss_trades']
+
+        # Win rate = number of profitable trades / number of trades
+        df['winrate'] = df['nb_win_trades'] / df['nb_trades']
+
+        # risk_reward_ratio = average win / average loss
+        df['risk_reward_ratio'] = df['average_win'] / df['average_loss']
+
+        # required_risk_reward = (1 / winrate) - 1
+        df['required_risk_reward'] = (1 / df['winrate']) - 1
+
+        # expectancy = (risk_reward_ratio * winrate) - (lossrate)
+        df['expectancy'] = (df['risk_reward_ratio'] * df['winrate']) - (1 - df['winrate'])
+
+        # sort by expectancy and stoploss
+        df = df.sort_values(by=['expectancy', 'stoploss'], ascending=False).groupby(
+            'pair').first().sort_values(by=['expectancy'], ascending=False).reset_index()
+
+        final = {}
+        for x in df.itertuples():
+            final[x.pair] = PairInfo(
+                x.stoploss,
+                x.winrate,
+                x.risk_reward_ratio,
+                x.required_risk_reward,
+                x.expectancy,
+                x.nb_trades,
+                x.avg_trade_duration
+            )
+
+        # Returning a list of pairs in order of "expectancy"
+        return final
+
+    def _find_trades_for_stoploss_range(self, ticker_data, pair, stoploss_range):
+        buy_column = ticker_data['buy'].values
+        sell_column = ticker_data['sell'].values
+        date_column = ticker_data['date'].values
+        ohlc_columns = ticker_data[['open', 'high', 'low', 'close']].values
+
+        result: list = []
+        for stoploss in stoploss_range:
+            result += self._detect_next_stop_or_sell_point(
+                buy_column, sell_column, date_column, ohlc_columns, round(stoploss, 6), pair
+            )
+
+        return result
+
+    def _detect_next_stop_or_sell_point(self, buy_column, sell_column, date_column,
+                                        ohlc_columns, stoploss, pair):
+        """
+        Iterate through ohlc_columns in order to find the next trade
+        Next trade opens from the first buy signal noticed to
+        The sell or stoploss signal after it.
+        It then cuts OHLC, buy_column, sell_column and date_column.
+        Cut from (the exit trade index) + 1.
+
+        Author: https://github.com/mishaker
+        """
+
+        result: list = []
+        start_point = 0
+
+        while True:
+            open_trade_index = utf1st.find_1st(buy_column, 1, utf1st.cmp_equal)
+
+            # Return empty if we don't find trade entry (i.e. buy==1) or
+            # we find a buy but at the end of array
+            if open_trade_index == -1 or open_trade_index == len(buy_column) - 1:
+                break
+            else:
+                # When a buy signal is seen,
+                # trade opens in reality on the next candle
+                open_trade_index += 1
+
+            stop_price_percentage = stoploss + 1
+            open_price = ohlc_columns[open_trade_index, 0]
+            stop_price = (open_price * stop_price_percentage)
+
+            # Searching for the index where stoploss is hit
+            stop_index = utf1st.find_1st(
+                ohlc_columns[open_trade_index:, 2], stop_price, utf1st.cmp_smaller)
+
+            # If we don't find it then we assume stop_index will be far in future (infinite number)
+            if stop_index == -1:
+                stop_index = float('inf')
+
+            # Searching for the index where sell is hit
+            sell_index = utf1st.find_1st(sell_column[open_trade_index:], 1, utf1st.cmp_equal)
+
+            # If we don't find it then we assume sell_index will be far in future (infinite number)
+            if sell_index == -1:
+                sell_index = float('inf')
+
+            # Check if we don't find any stop or sell point (in that case trade remains open)
+            # It is not interesting for Edge to consider it so we simply ignore the trade
+            # And stop iterating there is no more entry
+            if stop_index == sell_index == float('inf'):
+                break
+
+            if stop_index <= sell_index:
+                exit_index = open_trade_index + stop_index
+                exit_type = SellType.STOP_LOSS
+                exit_price = stop_price
+            elif stop_index > sell_index:
+                # If exit is SELL then we exit at the next candle
+                exit_index = open_trade_index + sell_index + 1
+
+                # Check if we have the next candle
+                if len(ohlc_columns) - 1 < exit_index:
+                    break
+
+                exit_type = SellType.SELL_SIGNAL
+                exit_price = ohlc_columns[exit_index, 0]
+
+            trade = {'pair': pair,
+                     'stoploss': stoploss,
+                     'profit_percent': '',
+                     'profit_abs': '',
+                     'open_time': date_column[open_trade_index],
+                     'close_time': date_column[exit_index],
+                     'open_index': start_point + open_trade_index,
+                     'close_index': start_point + exit_index,
+                     'trade_duration': '',
+                     'open_rate': round(open_price, 15),
+                     'close_rate': round(exit_price, 15),
+                     'exit_type': exit_type
+                     }
+
+            result.append(trade)
+
+            # Giving a view of exit_index till the end of array
+            buy_column = buy_column[exit_index:]
+            sell_column = sell_column[exit_index:]
+            date_column = date_column[exit_index:]
+            ohlc_columns = ohlc_columns[exit_index:]
+            start_point += exit_index
+
+        return result

freqtrade/exchange/__init__.py

@@ -1,169 +1,3 @@
-import enum
-import logging
-from random import randint
-from typing import List, Dict, Any, Optional
-
-import arrow
-
-from freqtrade.exchange.bittrex import Bittrex
-from freqtrade.exchange.interface import Exchange
-
-logger = logging.getLogger(__name__)
-
-# Current selected exchange
-_API: Exchange = None
-_CONF: dict = {}
-
-# Holds all open sell orders for dry_run
-_DRY_RUN_OPEN_ORDERS: Dict[str, Any] = {}
-
-
-class Exchanges(enum.Enum):
-    """
-    Maps supported exchange names to correspondent classes.
-    """
-    BITTREX = Bittrex
-
-
-def init(config: dict) -> None:
-    """
-    Initializes this module with the given config,
-    it does basic validation whether the specified
-    exchange and pairs are valid.
-    :param config: config to use
-    :return: None
-    """
-    global _CONF, _API
-
-    _CONF.update(config)
-
-    if config['dry_run']:
-        logger.info('Instance is running with dry_run enabled')
-
-    exchange_config = config['exchange']
-
-    # Find matching class for the given exchange name
-    name = exchange_config['name']
-    try:
-        exchange_class = Exchanges[name.upper()].value
-    except KeyError:
-        raise RuntimeError('Exchange {} is not supported'.format(name))
-
-    _API = exchange_class(exchange_config)
-
-    # Check if all pairs are available
-    validate_pairs(config['exchange']['pair_whitelist'])
-
-
-def validate_pairs(pairs: List[str]) -> None:
-    """
-    Checks if all given pairs are tradable on the current exchange.
-    Raises RuntimeError if one pair is not available.
-    :param pairs: list of pairs
-    :return: None
-    """
-    markets = _API.get_markets()
-    stake_cur = _CONF['stake_currency']
-    for pair in pairs:
-        if not pair.startswith(stake_cur):
-            raise RuntimeError(
-                'Pair {} not compatible with stake_currency: {}'.format(pair, stake_cur)
-            )
-        if pair not in markets:
-            raise RuntimeError('Pair {} is not available at {}'.format(pair, _API.name.lower()))
-
-
-def buy(pair: str, rate: float, amount: float) -> str:
-    if _CONF['dry_run']:
-        global _DRY_RUN_OPEN_ORDERS
-        order_id = 'dry_run_buy_{}'.format(randint(0, 1e6))
-        _DRY_RUN_OPEN_ORDERS[order_id] = {
-            'pair': pair,
-            'rate': rate,
-            'amount': amount,
-            'type': 'LIMIT_BUY',
-            'remaining': 0.0,
-            'opened': arrow.utcnow().datetime,
-            'closed': arrow.utcnow().datetime,
-        }
-        return order_id
-
-    return _API.buy(pair, rate, amount)
-
-
-def sell(pair: str, rate: float, amount: float) -> str:
-    if _CONF['dry_run']:
-        global _DRY_RUN_OPEN_ORDERS
-        order_id = 'dry_run_sell_{}'.format(randint(0, 1e6))
-        _DRY_RUN_OPEN_ORDERS[order_id] = {
-            'pair': pair,
-            'rate': rate,
-            'amount': amount,
-            'type': 'LIMIT_SELL',
-            'remaining': 0.0,
-            'opened': arrow.utcnow().datetime,
-            'closed': arrow.utcnow().datetime,
-        }
-        return order_id
-
-    return _API.sell(pair, rate, amount)
-
-
-def get_balance(currency: str) -> float:
-    if _CONF['dry_run']:
-        return 999.9
-
-    return _API.get_balance(currency)
-
-
-def get_balances():
-    if _CONF['dry_run']:
-        return []
-
-    return _API.get_balances()
-
-
-def get_ticker(pair: str) -> dict:
-    return _API.get_ticker(pair)
-
-
-def get_ticker_history(pair: str, tick_interval: Optional[int] = 5) -> List:
-    return _API.get_ticker_history(pair, tick_interval)
-
-
-def cancel_order(order_id: str) -> None:
-    if _CONF['dry_run']:
-        return
-
-    return _API.cancel_order(order_id)
-
-
-def get_order(order_id: str) -> Dict:
-    if _CONF['dry_run']:
-        order = _DRY_RUN_OPEN_ORDERS[order_id]
-        order.update({
-            'id': order_id
-        })
-        return order
-
-    return _API.get_order(order_id)
-
-
-def get_pair_detail_url(pair: str) -> str:
-    return _API.get_pair_detail_url(pair)
-
-
-def get_markets() -> List[str]:
-    return _API.get_markets()
-
-
-def get_name() -> str:
-    return _API.name
-
-
-def get_sleep_time() -> float:
-    return _API.sleep_time
-
-
-def get_fee() -> float:
-    return _API.fee
+from freqtrade.exchange.exchange import Exchange  # noqa: F401
+from freqtrade.exchange.kraken import Kraken  # noqa: F401
+from freqtrade.exchange.binance import Binance  # noqa: F401

freqtrade/exchange/binance.py

@@ -0,0 +1,27 @@
+""" Binance exchange subclass """
+import logging
+from typing import Dict
+
+from freqtrade.exchange import Exchange
+
+logger = logging.getLogger(__name__)
+
+
+class Binance(Exchange):
+
+    _ft_has: Dict = {
+        "stoploss_on_exchange": True,
+        "order_time_in_force": ['gtc', 'fok', 'ioc'],
+    }
+
+    def get_order_book(self, pair: str, limit: int = 100) -> dict:
+        """
+        get order book level 2 from exchange
+
+        20180619: binance support limits but only on specific range
+        """
+        limit_range = [5, 10, 20, 50, 100, 500, 1000]
+        # get next-higher step in the limit_range list
+        limit = min(list(filter(lambda x: limit <= x, limit_range)))
+
+        return super().get_order_book(pair, limit)

freqtrade/exchange/bittrex.py

@@ -1,141 +0,0 @@
-import logging
-from typing import List, Dict
-
-import requests
-from bittrex.bittrex import Bittrex as _Bittrex
-
-from freqtrade.exchange.interface import Exchange
-
-logger = logging.getLogger(__name__)
-
-_API: _Bittrex = None
-_EXCHANGE_CONF: dict = {}
-
-
-class Bittrex(Exchange):
-    """
-    Bittrex API wrapper.
-    """
-    # Base URL and API endpoints
-    BASE_URL: str = 'https://www.bittrex.com'
-    TICKER_METHOD: str = BASE_URL + '/Api/v2.0/pub/market/GetTicks'
-    PAIR_DETAIL_METHOD: str = BASE_URL + '/Market/Index'
-
-    @property
-    def sleep_time(self) -> float:
-        """ Sleep time to avoid rate limits, used in the main loop """
-        return 25
-
-    def __init__(self, config: dict) -> None:
-        global _API, _EXCHANGE_CONF
-
-        _EXCHANGE_CONF.update(config)
-        _API = _Bittrex(
-            api_key=_EXCHANGE_CONF['key'],
-            api_secret=_EXCHANGE_CONF['secret'],
-            calls_per_second=5,
-        )
-
-    @property
-    def fee(self) -> float:
-        # See https://bittrex.com/fees
-        return 0.0025
-
-    def buy(self, pair: str, rate: float, amount: float) -> str:
-        data = _API.buy_limit(pair.replace('_', '-'), amount, rate)
-        if not data['success']:
-            raise RuntimeError('{message} params=({pair}, {rate}, {amount})'.format(
-                message=data['message'],
-                pair=pair,
-                rate=rate,
-                amount=amount))
-        return data['result']['uuid']
-
-    def sell(self, pair: str, rate: float, amount: float) -> str:
-        data = _API.sell_limit(pair.replace('_', '-'), amount, rate)
-        if not data['success']:
-            raise RuntimeError('{message} params=({pair}, {rate}, {amount})'.format(
-                message=data['message'],
-                pair=pair,
-                rate=rate,
-                amount=amount))
-        return data['result']['uuid']
-
-    def get_balance(self, currency: str) -> float:
-        data = _API.get_balance(currency)
-        if not data['success']:
-            raise RuntimeError('{message} params=({currency})'.format(
-                message=data['message'],
-                currency=currency))
-        return float(data['result']['Balance'] or 0.0)
-
-    def get_balances(self):
-        data = _API.get_balances()
-        if not data['success']:
-            raise RuntimeError('{message}'.format(message=data['message']))
-        return data['result']
-
-    def get_ticker(self, pair: str) -> dict:
-        data = _API.get_ticker(pair.replace('_', '-'))
-        if not data['success']:
-            raise RuntimeError('{message} params=({pair})'.format(
-                message=data['message'],
-                pair=pair))
-        return {
-            'bid': float(data['result']['Bid']),
-            'ask': float(data['result']['Ask']),
-            'last': float(data['result']['Last']),
-        }
-
-    def get_ticker_history(self, pair: str, tick_interval: int):
-        if tick_interval == 1:
-            interval = 'oneMin'
-        elif tick_interval == 5:
-            interval = 'fiveMin'
-        else:
-            raise ValueError('Cannot parse tick_interval: {}'.format(tick_interval))
-
-        data = requests.get(self.TICKER_METHOD, params={
-            'marketName': pair.replace('_', '-'),
-            'tickInterval': interval,
-        }).json()
-        if not data['success']:
-            raise RuntimeError('{message} params=({pair})'.format(
-                message=data['message'],
-                pair=pair))
-
-        return data['result']
-
-    def get_order(self, order_id: str) -> Dict:
-        data = _API.get_order(order_id)
-        if not data['success']:
-            raise RuntimeError('{message} params=({order_id})'.format(
-                message=data['message'],
-                order_id=order_id))
-        data = data['result']
-        return {
-            'id': data['OrderUuid'],
-            'type': data['Type'],
-            'pair': data['Exchange'].replace('-', '_'),
-            'opened': data['Opened'],
-            'rate': data['PricePerUnit'],
-            'amount': data['Quantity'],
-            'remaining': data['QuantityRemaining'],
-            'closed': data['Closed'],
-        }
-
-    def cancel_order(self, order_id: str) -> None:
-        data = _API.cancel(order_id)
-        if not data['success']:
-            raise RuntimeError('{message} params=({order_id})'.format(
-                message=data['message'],
-                order_id=order_id))
-
-    def get_pair_detail_url(self, pair: str) -> str:
-        return self.PAIR_DETAIL_METHOD + '?MarketName={}'.format(pair.replace('_', '-'))
-
-    def get_markets(self) -> List[str]:
-        data = _API.get_markets()
-        if not data['success']:
-            raise RuntimeError('{message}'.format(message=data['message']))
-        return [m['MarketName'].replace('-', '_') for m in data['result']]

freqtrade/exchange/exchange.py

@@ -0,0 +1,691 @@
+# pragma pylint: disable=W0603
+""" Cryptocurrency Exchanges support """
+import logging
+import inspect
+from random import randint
+from typing import List, Dict, Tuple, Any, Optional
+from datetime import datetime
+from math import floor, ceil
+
+import arrow
+import asyncio
+import ccxt
+import ccxt.async_support as ccxt_async
+from pandas import DataFrame
+
+from freqtrade import (constants, DependencyException, OperationalException,
+                       TemporaryError, InvalidOrderException)
+from freqtrade.data.converter import parse_ticker_dataframe
+from freqtrade.misc import timeframe_to_seconds, timeframe_to_msecs
+
+
+logger = logging.getLogger(__name__)
+
+
+API_RETRY_COUNT = 4
+
+
+def retrier_async(f):
+    async def wrapper(*args, **kwargs):
+        count = kwargs.pop('count', API_RETRY_COUNT)
+        try:
+            return await f(*args, **kwargs)
+        except (TemporaryError, DependencyException) as ex:
+            logger.warning('%s() returned exception: "%s"', f.__name__, ex)
+            if count > 0:
+                count -= 1
+                kwargs.update({'count': count})
+                logger.warning('retrying %s() still for %s times', f.__name__, count)
+                return await wrapper(*args, **kwargs)
+            else:
+                logger.warning('Giving up retrying: %s()', f.__name__)
+                raise ex
+    return wrapper
+
+
+def retrier(f):
+    def wrapper(*args, **kwargs):
+        count = kwargs.pop('count', API_RETRY_COUNT)
+        try:
+            return f(*args, **kwargs)
+        except (TemporaryError, DependencyException) as ex:
+            logger.warning('%s() returned exception: "%s"', f.__name__, ex)
+            if count > 0:
+                count -= 1
+                kwargs.update({'count': count})
+                logger.warning('retrying %s() still for %s times', f.__name__, count)
+                return wrapper(*args, **kwargs)
+            else:
+                logger.warning('Giving up retrying: %s()', f.__name__)
+                raise ex
+    return wrapper
+
+
+class Exchange(object):
+
+    _config: Dict = {}
+    _params: Dict = {}
+
+    # Dict to specify which options each exchange implements
+    # TODO: this should be merged with attributes from subclasses
+    # To avoid having to copy/paste this to all subclasses.
+    _ft_has: Dict = {
+        "stoploss_on_exchange": False,
+        "order_time_in_force": ["gtc"],
+    }
+
+    def __init__(self, config: dict) -> None:
+        """
+        Initializes this module with the given config,
+        it does basic validation whether the specified exchange and pairs are valid.
+        :return: None
+        """
+        self._config.update(config)
+
+        self._cached_ticker: Dict[str, Any] = {}
+
+        # Holds last candle refreshed time of each pair
+        self._pairs_last_refresh_time: Dict[Tuple[str, str], int] = {}
+        # Timestamp of last markets refresh
+        self._last_markets_refresh: int = 0
+
+        # Holds candles
+        self._klines: Dict[Tuple[str, str], DataFrame] = {}
+
+        # Holds all open sell orders for dry_run
+        self._dry_run_open_orders: Dict[str, Any] = {}
+
+        if config['dry_run']:
+            logger.info('Instance is running with dry_run enabled')
+
+        exchange_config = config['exchange']
+        self._api: ccxt.Exchange = self._init_ccxt(
+            exchange_config, ccxt_kwargs=exchange_config.get('ccxt_config'))
+        self._api_async: ccxt_async.Exchange = self._init_ccxt(
+            exchange_config, ccxt_async, ccxt_kwargs=exchange_config.get('ccxt_async_config'))
+
+        logger.info('Using Exchange "%s"', self.name)
+
+        # Converts the interval provided in minutes in config to seconds
+        self.markets_refresh_interval: int = exchange_config.get(
+            "markets_refresh_interval", 60) * 60
+        # Initial markets load
+        self._load_markets()
+
+        # Check if all pairs are available
+        self.validate_pairs(config['exchange']['pair_whitelist'])
+        self.validate_ordertypes(config.get('order_types', {}))
+        self.validate_order_time_in_force(config.get('order_time_in_force', {}))
+
+        if config.get('ticker_interval'):
+            # Check if timeframe is available
+            self.validate_timeframes(config['ticker_interval'])
+
+    def __del__(self):
+        """
+        Destructor - clean up async stuff
+        """
+        logger.debug("Exchange object destroyed, closing async loop")
+        if self._api_async and inspect.iscoroutinefunction(self._api_async.close):
+            asyncio.get_event_loop().run_until_complete(self._api_async.close())
+
+    def _init_ccxt(self, exchange_config: dict, ccxt_module=ccxt,
+                   ccxt_kwargs: dict = None) -> ccxt.Exchange:
+        """
+        Initialize ccxt with given config and return valid
+        ccxt instance.
+        """
+        # Find matching class for the given exchange name
+        name = exchange_config['name']
+
+        if name not in ccxt_module.exchanges:
+            raise OperationalException(f'Exchange {name} is not supported')
+
+        ex_config = {
+            'apiKey': exchange_config.get('key'),
+            'secret': exchange_config.get('secret'),
+            'password': exchange_config.get('password'),
+            'uid': exchange_config.get('uid', ''),
+        }
+        if ccxt_kwargs:
+            logger.info('Applying additional ccxt config: %s', ccxt_kwargs)
+            ex_config.update(ccxt_kwargs)
+        try:
+
+            api = getattr(ccxt_module, name.lower())(ex_config)
+        except (KeyError, AttributeError):
+            raise OperationalException(f'Exchange {name} is not supported')
+
+        self.set_sandbox(api, exchange_config, name)
+
+        return api
+
+    @property
+    def name(self) -> str:
+        """exchange Name (from ccxt)"""
+        return self._api.name
+
+    @property
+    def id(self) -> str:
+        """exchange ccxt id"""
+        return self._api.id
+
+    @property
+    def markets(self) -> Dict:
+        """exchange ccxt markets"""
+        if not self._api.markets:
+            logger.warning("Markets were not loaded. Loading them now..")
+            self._load_markets()
+        return self._api.markets
+
+    def klines(self, pair_interval: Tuple[str, str], copy=True) -> DataFrame:
+        if pair_interval in self._klines:
+            return self._klines[pair_interval].copy() if copy else self._klines[pair_interval]
+        else:
+            return DataFrame()
+
+    def set_sandbox(self, api, exchange_config: dict, name: str):
+        if exchange_config.get('sandbox'):
+            if api.urls.get('test'):
+                api.urls['api'] = api.urls['test']
+                logger.info("Enabled Sandbox API on %s", name)
+            else:
+                logger.warning(name, "No Sandbox URL in CCXT, exiting. "
+                                     "Please check your config.json")
+                raise OperationalException(f'Exchange {name} does not provide a sandbox api')
+
+    def _load_async_markets(self, reload=False) -> None:
+        try:
+            if self._api_async:
+                asyncio.get_event_loop().run_until_complete(
+                    self._api_async.load_markets(reload=reload))
+
+        except ccxt.BaseError as e:
+            logger.warning('Could not load async markets. Reason: %s', e)
+            return
+
+    def _load_markets(self) -> None:
+        """ Initialize markets both sync and async """
+        try:
+            self._api.load_markets()
+            self._load_async_markets()
+            self._last_markets_refresh = arrow.utcnow().timestamp
+        except ccxt.BaseError as e:
+            logger.warning('Unable to initialize markets. Reason: %s', e)
+
+    def _reload_markets(self) -> None:
+        """Reload markets both sync and async, if refresh interval has passed"""
+        # Check whether markets have to be reloaded
+        if (self._last_markets_refresh > 0) and (
+                self._last_markets_refresh + self.markets_refresh_interval
+                > arrow.utcnow().timestamp):
+            return None
+        logger.debug("Performing scheduled market reload..")
+        self._api.load_markets(reload=True)
+        self._last_markets_refresh = arrow.utcnow().timestamp
+
+    def validate_pairs(self, pairs: List[str]) -> None:
+        """
+        Checks if all given pairs are tradable on the current exchange.
+        Raises OperationalException if one pair is not available.
+        :param pairs: list of pairs
+        :return: None
+        """
+
+        if not self.markets:
+            logger.warning('Unable to validate pairs (assuming they are correct).')
+        #     return
+
+        for pair in pairs:
+            # Note: ccxt has BaseCurrency/QuoteCurrency format for pairs
+            # TODO: add a support for having coins in BTC/USDT format
+            if self.markets and pair not in self.markets:
+                raise OperationalException(
+                    f'Pair {pair} is not available on {self.name}. '
+                    f'Please remove {pair} from your whitelist.')
+
+    def validate_timeframes(self, timeframe: List[str]) -> None:
+        """
+        Checks if ticker interval from config is a supported timeframe on the exchange
+        """
+        timeframes = self._api.timeframes
+        if timeframe not in timeframes:
+            raise OperationalException(
+                f'Invalid ticker {timeframe}, this Exchange supports {timeframes}')
+
+    def validate_ordertypes(self, order_types: Dict) -> None:
+        """
+        Checks if order-types configured in strategy/config are supported
+        """
+        if any(v == 'market' for k, v in order_types.items()):
+            if not self.exchange_has('createMarketOrder'):
+                raise OperationalException(
+                    f'Exchange {self.name} does not support market orders.')
+
+        if (order_types.get("stoploss_on_exchange")
+                and not self._ft_has.get("stoploss_on_exchange", False)):
+            raise OperationalException(
+                'On exchange stoploss is not supported for %s.' % self.name
+            )
+
+    def validate_order_time_in_force(self, order_time_in_force: Dict) -> None:
+        """
+        Checks if order time in force configured in strategy/config are supported
+        """
+        if any(v not in self._ft_has["order_time_in_force"]
+               for k, v in order_time_in_force.items()):
+            raise OperationalException(
+                f'Time in force policies are not supported for {self.name} yet.')
+
+    def exchange_has(self, endpoint: str) -> bool:
+        """
+        Checks if exchange implements a specific API endpoint.
+        Wrapper around ccxt 'has' attribute
+        :param endpoint: Name of endpoint (e.g. 'fetchOHLCV', 'fetchTickers')
+        :return: bool
+        """
+        return endpoint in self._api.has and self._api.has[endpoint]
+
+    def symbol_amount_prec(self, pair, amount: float):
+        '''
+        Returns the amount to buy or sell to a precision the Exchange accepts
+        Rounded down
+        '''
+        if self.markets[pair]['precision']['amount']:
+            symbol_prec = self.markets[pair]['precision']['amount']
+            big_amount = amount * pow(10, symbol_prec)
+            amount = floor(big_amount) / pow(10, symbol_prec)
+        return amount
+
+    def symbol_price_prec(self, pair, price: float):
+        '''
+        Returns the price buying or selling with to the precision the Exchange accepts
+        Rounds up
+        '''
+        if self.markets[pair]['precision']['price']:
+            symbol_prec = self.markets[pair]['precision']['price']
+            big_price = price * pow(10, symbol_prec)
+            price = ceil(big_price) / pow(10, symbol_prec)
+        return price
+
+    def dry_run_order(self, pair: str, ordertype: str, side: str, amount: float,
+                      rate: float, params: Dict = {}) -> Dict[str, Any]:
+        order_id = f'dry_run_{side}_{randint(0, 10**6)}'
+        dry_order = {  # TODO: additional entry should be added for stoploss limit
+            "id": order_id,
+            'pair': pair,
+            'price': rate,
+            'amount': amount,
+            "cost": amount * rate,
+            'type': ordertype,
+            'side': side,
+            'remaining': amount,
+            'datetime': arrow.utcnow().isoformat(),
+            'status': "open",
+            'fee': None,
+            "info": {}
+        }
+        self._store_dry_order(dry_order)
+        return dry_order
+
+    def _store_dry_order(self, dry_order: Dict) -> None:
+        closed_order = dry_order.copy()
+        if closed_order["type"] in ["market", "limit"]:
+            closed_order.update({
+                "status": "closed",
+                "filled": closed_order["amount"],
+                "remaining": 0
+                })
+        self._dry_run_open_orders[closed_order["id"]] = closed_order
+
+    def create_order(self, pair: str, ordertype: str, side: str, amount: float,
+                     rate: float, params: Dict = {}) -> Dict:
+        try:
+            # Set the precision for amount and price(rate) as accepted by the exchange
+            amount = self.symbol_amount_prec(pair, amount)
+            rate = self.symbol_price_prec(pair, rate) if ordertype != 'market' else None
+
+            return self._api.create_order(pair, ordertype, side,
+                                          amount, rate, params)
+
+        except ccxt.InsufficientFunds as e:
+            raise DependencyException(
+                f'Insufficient funds to create {ordertype} {side} order on market {pair}.'
+                f'Tried to {side} amount {amount} at rate {rate} (total {rate*amount}).'
+                f'Message: {e}')
+        except ccxt.InvalidOrder as e:
+            raise DependencyException(
+                f'Could not create {ordertype} {side} order on market {pair}.'
+                f'Tried to {side} amount {amount} at rate {rate} (total {rate*amount}).'
+                f'Message: {e}')
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not place {side} order due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
+
+    def buy(self, pair: str, ordertype: str, amount: float,
+            rate: float, time_in_force) -> Dict:
+
+        if self._config['dry_run']:
+            dry_order = self.dry_run_order(pair, ordertype, "buy", amount, rate)
+            return dry_order
+
+        params = self._params.copy()
+        if time_in_force != 'gtc' and ordertype != 'market':
+            params.update({'timeInForce': time_in_force})
+
+        return self.create_order(pair, ordertype, 'buy', amount, rate, params)
+
+    def sell(self, pair: str, ordertype: str, amount: float,
+             rate: float, time_in_force='gtc') -> Dict:
+
+        if self._config['dry_run']:
+            dry_order = self.dry_run_order(pair, ordertype, "sell", amount, rate)
+            return dry_order
+
+        params = self._params.copy()
+        if time_in_force != 'gtc' and ordertype != 'market':
+            params.update({'timeInForce': time_in_force})
+
+        return self.create_order(pair, ordertype, 'sell', amount, rate, params)
+
+    def stoploss_limit(self, pair: str, amount: float, stop_price: float, rate: float) -> Dict:
+        """
+        creates a stoploss limit order.
+        NOTICE: it is not supported by all exchanges. only binance is tested for now.
+        TODO: implementation maybe needs to be moved to the binance subclass
+        """
+        ordertype = "stop_loss_limit"
+
+        stop_price = self.symbol_price_prec(pair, stop_price)
+
+        # Ensure rate is less than stop price
+        if stop_price <= rate:
+            raise OperationalException(
+                'In stoploss limit order, stop price should be more than limit price')
+
+        if self._config['dry_run']:
+            dry_order = self.dry_run_order(
+                pair, ordertype, "sell", amount, stop_price)
+            return dry_order
+
+        params = self._params.copy()
+        params.update({'stopPrice': stop_price})
+
+        order = self.create_order(pair, ordertype, 'sell', amount, rate, params)
+        logger.info('stoploss limit order added for %s. '
+                    'stop price: %s. limit: %s' % (pair, stop_price, rate))
+        return order
+
+    @retrier
+    def get_balance(self, currency: str) -> float:
+        if self._config['dry_run']:
+            return constants.DRY_RUN_WALLET
+
+        # ccxt exception is already handled by get_balances
+        balances = self.get_balances()
+        balance = balances.get(currency)
+        if balance is None:
+            raise TemporaryError(
+                f'Could not get {currency} balance due to malformed exchange response: {balances}')
+        return balance['free']
+
+    @retrier
+    def get_balances(self) -> dict:
+        if self._config['dry_run']:
+            return {}
+
+        try:
+            balances = self._api.fetch_balance()
+            # Remove additional info from ccxt results
+            balances.pop("info", None)
+            balances.pop("free", None)
+            balances.pop("total", None)
+            balances.pop("used", None)
+
+            return balances
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not get balance due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
+
+    @retrier
+    def get_tickers(self) -> Dict:
+        try:
+            return self._api.fetch_tickers()
+        except ccxt.NotSupported as e:
+            raise OperationalException(
+                f'Exchange {self._api.name} does not support fetching tickers in batch.'
+                f'Message: {e}')
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not load tickers due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
+
+    @retrier
+    def get_ticker(self, pair: str, refresh: Optional[bool] = True) -> dict:
+        if refresh or pair not in self._cached_ticker.keys():
+            try:
+                if pair not in self._api.markets:
+                    raise DependencyException(f"Pair {pair} not available")
+                data = self._api.fetch_ticker(pair)
+                try:
+                    self._cached_ticker[pair] = {
+                        'bid': float(data['bid']),
+                        'ask': float(data['ask']),
+                    }
+                except KeyError:
+                    logger.debug("Could not cache ticker data for %s", pair)
+                return data
+            except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+                raise TemporaryError(
+                    f'Could not load ticker due to {e.__class__.__name__}. Message: {e}')
+            except ccxt.BaseError as e:
+                raise OperationalException(e)
+        else:
+            logger.info("returning cached ticker-data for %s", pair)
+            return self._cached_ticker[pair]
+
+    def get_history(self, pair: str, ticker_interval: str,
+                    since_ms: int) -> List:
+        """
+        Gets candle history using asyncio and returns the list of candles.
+        Handles all async doing.
+        """
+        return asyncio.get_event_loop().run_until_complete(
+            self._async_get_history(pair=pair, ticker_interval=ticker_interval,
+                                    since_ms=since_ms))
+
+    async def _async_get_history(self, pair: str,
+                                 ticker_interval: str,
+                                 since_ms: int) -> List:
+        # Assume exchange returns 500 candles
+        _LIMIT = 500
+
+        one_call = timeframe_to_msecs(ticker_interval) * _LIMIT
+        logger.debug("one_call: %s msecs", one_call)
+        input_coroutines = [self._async_get_candle_history(
+            pair, ticker_interval, since) for since in
+            range(since_ms, arrow.utcnow().timestamp * 1000, one_call)]
+
+        tickers = await asyncio.gather(*input_coroutines, return_exceptions=True)
+
+        # Combine tickers
+        data: List = []
+        for p, ticker_interval, ticker in tickers:
+            if p == pair:
+                data.extend(ticker)
+        # Sort data again after extending the result - above calls return in "async order"
+        data = sorted(data, key=lambda x: x[0])
+        logger.info("downloaded %s with length %s.", pair, len(data))
+        return data
+
+    def refresh_latest_ohlcv(self, pair_list: List[Tuple[str, str]]) -> List[Tuple[str, List]]:
+        """
+        Refresh in-memory ohlcv asyncronously and set `_klines` with the result
+        """
+        logger.debug("Refreshing ohlcv data for %d pairs", len(pair_list))
+
+        input_coroutines = []
+
+        # Gather coroutines to run
+        for pair, ticker_interval in set(pair_list):
+            if (not ((pair, ticker_interval) in self._klines)
+                    or self._now_is_time_to_refresh(pair, ticker_interval)):
+                input_coroutines.append(self._async_get_candle_history(pair, ticker_interval))
+            else:
+                logger.debug("Using cached ohlcv data for %s, %s ...", pair, ticker_interval)
+
+        tickers = asyncio.get_event_loop().run_until_complete(
+            asyncio.gather(*input_coroutines, return_exceptions=True))
+
+        # handle caching
+        for res in tickers:
+            if isinstance(res, Exception):
+                logger.warning("Async code raised an exception: %s", res.__class__.__name__)
+                continue
+            pair = res[0]
+            ticker_interval = res[1]
+            ticks = res[2]
+            # keeping last candle time as last refreshed time of the pair
+            if ticks:
+                self._pairs_last_refresh_time[(pair, ticker_interval)] = ticks[-1][0] // 1000
+            # keeping parsed dataframe in cache
+            self._klines[(pair, ticker_interval)] = parse_ticker_dataframe(
+                ticks, ticker_interval, fill_missing=True)
+        return tickers
+
+    def _now_is_time_to_refresh(self, pair: str, ticker_interval: str) -> bool:
+        # Calculating ticker interval in seconds
+        interval_in_sec = timeframe_to_seconds(ticker_interval)
+
+        return not ((self._pairs_last_refresh_time.get((pair, ticker_interval), 0)
+                     + interval_in_sec) >= arrow.utcnow().timestamp)
+
+    @retrier_async
+    async def _async_get_candle_history(self, pair: str, ticker_interval: str,
+                                        since_ms: Optional[int] = None) -> Tuple[str, str, List]:
+        """
+        Asyncronously gets candle histories using fetch_ohlcv
+        returns tuple: (pair, ticker_interval, ohlcv_list)
+        """
+        try:
+            # fetch ohlcv asynchronously
+            logger.debug("fetching %s, %s since %s ...", pair, ticker_interval, since_ms)
+
+            data = await self._api_async.fetch_ohlcv(pair, timeframe=ticker_interval,
+                                                     since=since_ms)
+
+            # Because some exchange sort Tickers ASC and other DESC.
+            # Ex: Bittrex returns a list of tickers ASC (oldest first, newest last)
+            # when GDAX returns a list of tickers DESC (newest first, oldest last)
+            # Only sort if necessary to save computing time
+            try:
+                if data and data[0][0] > data[-1][0]:
+                    data = sorted(data, key=lambda x: x[0])
+            except IndexError:
+                logger.exception("Error loading %s. Result was %s.", pair, data)
+                return pair, ticker_interval, []
+            logger.debug("done fetching %s, %s ...", pair, ticker_interval)
+            return pair, ticker_interval, data
+
+        except ccxt.NotSupported as e:
+            raise OperationalException(
+                f'Exchange {self._api.name} does not support fetching historical candlestick data.'
+                f'Message: {e}')
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not load ticker history due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(f'Could not fetch ticker data. Msg: {e}')
+
+    @retrier
+    def cancel_order(self, order_id: str, pair: str) -> None:
+        if self._config['dry_run']:
+            return
+
+        try:
+            return self._api.cancel_order(order_id, pair)
+        except ccxt.InvalidOrder as e:
+            raise InvalidOrderException(
+                f'Could not cancel order. Message: {e}')
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not cancel order due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
+
+    @retrier
+    def get_order(self, order_id: str, pair: str) -> Dict:
+        if self._config['dry_run']:
+            order = self._dry_run_open_orders[order_id]
+            return order
+        try:
+            return self._api.fetch_order(order_id, pair)
+        except ccxt.InvalidOrder as e:
+            raise InvalidOrderException(
+                f'Tried to get an invalid order (id: {order_id}). Message: {e}')
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not get order due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
+
+    @retrier
+    def get_order_book(self, pair: str, limit: int = 100) -> dict:
+        """
+        get order book level 2 from exchange
+
+        Notes:
+        20180619: bittrex doesnt support limits -.-
+        """
+        try:
+
+            return self._api.fetch_l2_order_book(pair, limit)
+        except ccxt.NotSupported as e:
+            raise OperationalException(
+                f'Exchange {self._api.name} does not support fetching order book.'
+                f'Message: {e}')
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not get order book due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
+
+    @retrier
+    def get_trades_for_order(self, order_id: str, pair: str, since: datetime) -> List:
+        if self._config['dry_run']:
+            return []
+        if not self.exchange_has('fetchMyTrades'):
+            return []
+        try:
+            # Allow 5s offset to catch slight time offsets (discovered in #1185)
+            my_trades = self._api.fetch_my_trades(pair, since.timestamp() - 5)
+            matched_trades = [trade for trade in my_trades if trade['order'] == order_id]
+
+            return matched_trades
+
+        except ccxt.NetworkError as e:
+            raise TemporaryError(
+                f'Could not get trades due to networking error. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
+
+    @retrier
+    def get_fee(self, symbol='ETH/BTC', type='', side='', amount=1,
+                price=1, taker_or_maker='maker') -> float:
+        try:
+            # validate that markets are loaded before trying to get fee
+            if self._api.markets is None or len(self._api.markets) == 0:
+                self._api.load_markets()
+
+            return self._api.calculate_fee(symbol=symbol, type=type, side=side, amount=amount,
+                                           price=price, takerOrMaker=taker_or_maker)['rate']
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not get fee info due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)

freqtrade/exchange/interface.py

@@ -1,141 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import List, Dict
-
-
-class Exchange(ABC):
-    @property
-    def name(self) -> str:
-        """
-        Name of the exchange.
-        :return: str representation of the class name
-        """
-        return self.__class__.__name__
-
-    @property
-    def fee(self) -> float:
-        """
-        Fee for placing an order
-        :return: percentage in float
-        """
-
-    @property
-    @abstractmethod
-    def sleep_time(self) -> float:
-        """
-        Sleep time in seconds for the main loop to avoid API rate limits.
-        :return: float
-        """
-
-    @abstractmethod
-    def buy(self, pair: str, rate: float, amount: float) -> str:
-        """
-        Places a limit buy order.
-        :param pair: Pair as str, format: BTC_ETH
-        :param rate: Rate limit for order
-        :param amount: The amount to purchase
-        :return: order_id of the placed buy order
-        """
-
-    @abstractmethod
-    def sell(self, pair: str, rate: float, amount: float) -> str:
-        """
-        Places a limit sell order.
-        :param pair: Pair as str, format: BTC_ETH
-        :param rate: Rate limit for order
-        :param amount: The amount to sell
-        :return: order_id of the placed sell order
-        """
-
-    @abstractmethod
-    def get_balance(self, currency: str) -> float:
-        """
-        Gets account balance.
-        :param currency: Currency as str, format: BTC
-        :return: float
-        """
-
-    @abstractmethod
-    def get_balances(self) -> List[dict]:
-        """
-        Gets account balances across currencies
-        :return: List of dicts, format: [
-          {
-            'Currency': str,
-            'Balance': float,
-            'Available': float,
-            'Pending': float,
-          }
-          ...
-        ]
-        """
-
-    @abstractmethod
-    def get_ticker(self, pair: str) -> dict:
-        """
-        Gets ticker for given pair.
-        :param pair: Pair as str, format: BTC_ETC
-        :return: dict, format: {
-            'bid': float,
-            'ask': float,
-            'last': float
-        }
-        """
-
-    @abstractmethod
-    def get_ticker_history(self, pair: str, tick_interval: int) -> List:
-        """
-        Gets ticker history for given pair.
-        :param pair: Pair as str, format: BTC_ETC
-        :param tick_interval: ticker interval in minutes
-        :return: list, format: [
-            {
-                'O': float,       (Open)
-                'H': float,       (High)
-                'L': float,       (Low)
-                'C': float,       (Close)
-                'V': float,       (Volume)
-                'T': datetime,    (Time)
-                'BV': float,      (Base Volume)
-            },
-            ...
-        ]
-        """
-
-    def get_order(self, order_id: str) -> Dict:
-        """
-        Get order details for the given order_id.
-        :param order_id: ID as str
-        :return: dict, format: {
-            'id': str,
-            'type': str,
-            'pair': str,
-            'opened': str ISO 8601 datetime,
-            'closed': str ISO 8601 datetime,
-            'rate': float,
-            'amount': float,
-            'remaining': int
-        }
-        """
-
-    @abstractmethod
-    def cancel_order(self, order_id: str) -> None:
-        """
-        Cancels order for given order_id.
-        :param order_id: ID as str
-        :return: None
-        """
-
-    @abstractmethod
-    def get_pair_detail_url(self, pair: str) -> str:
-        """
-        Returns the market detail url for the given pair.
-        :param pair: Pair as str, format: BTC_ETC
-        :return: URL as str
-        """
-
-    @abstractmethod
-    def get_markets(self) -> List[str]:
-        """
-        Returns all available markets.
-        :return: List of all available pairs
-        """

freqtrade/exchange/kraken.py

@@ -0,0 +1,12 @@
+""" Kraken exchange subclass """
+import logging
+from typing import Dict
+
+from freqtrade.exchange import Exchange
+
+logger = logging.getLogger(__name__)
+
+
+class Kraken(Exchange):
+
+    _params: Dict = {"trading_agreement": "agree"}

freqtrade/freqtradebot.py

@@ -0,0 +1,881 @@
+"""
+Freqtrade is the main module of this bot. It contains the class Freqtrade()
+"""
+
+import copy
+import logging
+import traceback
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Tuple
+
+import arrow
+from requests.exceptions import RequestException
+
+from freqtrade import (DependencyException, OperationalException, InvalidOrderException,
+                       __version__, constants, persistence)
+from freqtrade.data.converter import order_book_to_dataframe
+from freqtrade.data.dataprovider import DataProvider
+from freqtrade.edge import Edge
+from freqtrade.misc import timeframe_to_minutes
+from freqtrade.persistence import Trade
+from freqtrade.rpc import RPCManager, RPCMessageType
+from freqtrade.resolvers import ExchangeResolver, StrategyResolver, PairListResolver
+from freqtrade.state import State
+from freqtrade.strategy.interface import SellType, IStrategy
+from freqtrade.wallets import Wallets
+
+
+logger = logging.getLogger(__name__)
+
+
+class FreqtradeBot(object):
+    """
+    Freqtrade is the main class of the bot.
+    This is from here the bot start its logic.
+    """
+
+    def __init__(self, config: Dict[str, Any]) -> None:
+        """
+        Init all variables and objects the bot needs to work
+        :param config: configuration dict, you can use Configuration.get_config()
+        to get the config dict.
+        """
+
+        logger.info('Starting freqtrade %s', __version__)
+
+        # Init bot state
+        self.state = State.STOPPED
+
+        # Init objects
+        self.config = config
+
+        self.strategy: IStrategy = StrategyResolver(self.config).strategy
+
+        self.rpc: RPCManager = RPCManager(self)
+
+        exchange_name = self.config.get('exchange', {}).get('name', 'bittrex').title()
+        self.exchange = ExchangeResolver(exchange_name, self.config).exchange
+
+        self.wallets = Wallets(self.config, self.exchange)
+        self.dataprovider = DataProvider(self.config, self.exchange)
+
+        # Attach Dataprovider to Strategy baseclass
+        IStrategy.dp = self.dataprovider
+        # Attach Wallets to Strategy baseclass
+        IStrategy.wallets = self.wallets
+
+        pairlistname = self.config.get('pairlist', {}).get('method', 'StaticPairList')
+        self.pairlists = PairListResolver(pairlistname, self, self.config).pairlist
+
+        # Initializing Edge only if enabled
+        self.edge = Edge(self.config, self.exchange, self.strategy) if \
+            self.config.get('edge', {}).get('enabled', False) else None
+
+        self.active_pair_whitelist: List[str] = self.config['exchange']['pair_whitelist']
+
+        persistence.init(self.config)
+
+        # Set initial bot state from config
+        initial_state = self.config.get('initial_state')
+        self.state = State[initial_state.upper()] if initial_state else State.STOPPED
+
+    def cleanup(self) -> None:
+        """
+        Cleanup pending resources on an already stopped bot
+        :return: None
+        """
+        logger.info('Cleaning up modules ...')
+
+        self.rpc.cleanup()
+        persistence.cleanup()
+
+    def process(self) -> bool:
+        """
+        Queries the persistence layer for open trades and handles them,
+        otherwise a new trade is created.
+        :return: True if one or more trades has been created or closed, False otherwise
+        """
+        state_changed = False
+
+        # Check whether markets have to be reloaded
+        self.exchange._reload_markets()
+
+        # Refresh whitelist
+        self.pairlists.refresh_pairlist()
+        self.active_pair_whitelist = self.pairlists.whitelist
+
+        # Calculating Edge positioning
+        if self.edge:
+            self.edge.calculate()
+            self.active_pair_whitelist = self.edge.adjust(self.active_pair_whitelist)
+
+        # Query trades from persistence layer
+        trades = Trade.get_open_trades()
+
+        # Extend active-pair whitelist with pairs from open trades
+        # It ensures that tickers are downloaded for open trades
+        self._extend_whitelist_with_trades(self.active_pair_whitelist, trades)
+
+        # Refreshing candles
+        self.dataprovider.refresh(self._create_pair_whitelist(self.active_pair_whitelist),
+                                  self.strategy.informative_pairs())
+
+        # First process current opened trades
+        for trade in trades:
+            state_changed |= self.process_maybe_execute_sell(trade)
+
+        # Then looking for buy opportunities
+        if len(trades) < self.config['max_open_trades']:
+            state_changed = self.process_maybe_execute_buy()
+
+        if 'unfilledtimeout' in self.config:
+            # Check and handle any timed out open orders
+            self.check_handle_timedout()
+            Trade.session.flush()
+
+        return state_changed
+
+    def _extend_whitelist_with_trades(self, whitelist: List[str], trades: List[Any]):
+        """
+        Extend whitelist with pairs from open trades
+        """
+        whitelist.extend([trade.pair for trade in trades if trade.pair not in whitelist])
+
+    def _create_pair_whitelist(self, pairs: List[str]) -> List[Tuple[str, str]]:
+        """
+        Create pair-whitelist tuple with (pair, ticker_interval)
+        """
+        return [(pair, self.config['ticker_interval']) for pair in pairs]
+
+    def get_target_bid(self, pair: str, tick: Dict = None) -> float:
+        """
+        Calculates bid target between current ask price and last price
+        :return: float: Price
+        """
+        config_bid_strategy = self.config.get('bid_strategy', {})
+        if 'use_order_book' in config_bid_strategy and\
+                config_bid_strategy.get('use_order_book', False):
+            logger.info('Getting price from order book')
+            order_book_top = config_bid_strategy.get('order_book_top', 1)
+            order_book = self.exchange.get_order_book(pair, order_book_top)
+            logger.debug('order_book %s', order_book)
+            # top 1 = index 0
+            order_book_rate = order_book['bids'][order_book_top - 1][0]
+            logger.info('...top %s order book buy rate %0.8f', order_book_top, order_book_rate)
+            used_rate = order_book_rate
+        else:
+            if not tick:
+                logger.info('Using Last Ask / Last Price')
+                ticker = self.exchange.get_ticker(pair)
+            else:
+                ticker = tick
+            if ticker['ask'] < ticker['last']:
+                ticker_rate = ticker['ask']
+            else:
+                balance = self.config['bid_strategy']['ask_last_balance']
+                ticker_rate = ticker['ask'] + balance * (ticker['last'] - ticker['ask'])
+            used_rate = ticker_rate
+
+        return used_rate
+
+    def _get_trade_stake_amount(self, pair) -> Optional[float]:
+        """
+        Check if stake amount can be fulfilled with the available balance
+        for the stake currency
+        :return: float: Stake Amount
+        """
+        if self.edge:
+            return self.edge.stake_amount(
+                pair,
+                self.wallets.get_free(self.config['stake_currency']),
+                self.wallets.get_total(self.config['stake_currency']),
+                Trade.total_open_trades_stakes()
+            )
+        else:
+            stake_amount = self.config['stake_amount']
+
+        avaliable_amount = self.wallets.get_free(self.config['stake_currency'])
+
+        if stake_amount == constants.UNLIMITED_STAKE_AMOUNT:
+            open_trades = len(Trade.get_open_trades())
+            if open_trades >= self.config['max_open_trades']:
+                logger.warning('Can\'t open a new trade: max number of trades is reached')
+                return None
+            return avaliable_amount / (self.config['max_open_trades'] - open_trades)
+
+        # Check if stake_amount is fulfilled
+        if avaliable_amount < stake_amount:
+            raise DependencyException(
+                f"Available balance({avaliable_amount} {self.config['stake_currency']}) is "
+                f"lower than stake amount({stake_amount} {self.config['stake_currency']})"
+            )
+
+        return stake_amount
+
+    def _get_min_pair_stake_amount(self, pair: str, price: float) -> Optional[float]:
+        try:
+            market = self.exchange.markets[pair]
+        except KeyError:
+            raise ValueError(f"Can't get market information for symbol {pair}")
+
+        if 'limits' not in market:
+            return None
+
+        min_stake_amounts = []
+        limits = market['limits']
+        if ('cost' in limits and 'min' in limits['cost']
+                and limits['cost']['min'] is not None):
+            min_stake_amounts.append(limits['cost']['min'])
+
+        if ('amount' in limits and 'min' in limits['amount']
+                and limits['amount']['min'] is not None):
+            min_stake_amounts.append(limits['amount']['min'] * price)
+
+        if not min_stake_amounts:
+            return None
+
+        # reserve some percent defined in config (5% default) + stoploss
+        amount_reserve_percent = 1.0 - self.config.get('amount_reserve_percent',
+                                                       constants.DEFAULT_AMOUNT_RESERVE_PERCENT)
+        if self.strategy.stoploss is not None:
+            amount_reserve_percent += self.strategy.stoploss
+        # it should not be more than 50%
+        amount_reserve_percent = max(amount_reserve_percent, 0.5)
+        return min(min_stake_amounts) / amount_reserve_percent
+
+    def create_trade(self) -> bool:
+        """
+        Checks the implemented trading indicator(s) for a randomly picked pair,
+        if one pair triggers the buy_signal a new trade record gets created
+        :return: True if a trade object has been created and persisted, False otherwise
+        """
+        interval = self.strategy.ticker_interval
+        whitelist = copy.deepcopy(self.active_pair_whitelist)
+
+        if not whitelist:
+            logger.warning("Whitelist is empty.")
+            return False
+
+        # Remove currently opened and latest pairs from whitelist
+        for trade in Trade.get_open_trades():
+            if trade.pair in whitelist:
+                whitelist.remove(trade.pair)
+                logger.debug('Ignoring %s in pair whitelist', trade.pair)
+
+        if not whitelist:
+            logger.info("No currency pair in whitelist, but checking to sell open trades.")
+            return False
+
+        # running get_signal on historical data fetched
+        for _pair in whitelist:
+            (buy, sell) = self.strategy.get_signal(
+                _pair, interval, self.dataprovider.ohlcv(_pair, self.strategy.ticker_interval))
+
+            if buy and not sell:
+                stake_amount = self._get_trade_stake_amount(_pair)
+                if not stake_amount:
+                    return False
+
+                logger.info(f"Buy signal found: about create a new trade with stake_amount: "
+                            f"{stake_amount} ...")
+
+                bidstrat_check_depth_of_market = self.config.get('bid_strategy', {}).\
+                    get('check_depth_of_market', {})
+                if (bidstrat_check_depth_of_market.get('enabled', False)) and\
+                        (bidstrat_check_depth_of_market.get('bids_to_ask_delta', 0) > 0):
+                    if self._check_depth_of_market_buy(_pair, bidstrat_check_depth_of_market):
+                        return self.execute_buy(_pair, stake_amount)
+                    else:
+                        return False
+                return self.execute_buy(_pair, stake_amount)
+
+        return False
+
+    def _check_depth_of_market_buy(self, pair: str, conf: Dict) -> bool:
+        """
+        Checks depth of market before executing a buy
+        """
+        conf_bids_to_ask_delta = conf.get('bids_to_ask_delta', 0)
+        logger.info('checking depth of market for %s', pair)
+        order_book = self.exchange.get_order_book(pair, 1000)
+        order_book_data_frame = order_book_to_dataframe(order_book['bids'], order_book['asks'])
+        order_book_bids = order_book_data_frame['b_size'].sum()
+        order_book_asks = order_book_data_frame['a_size'].sum()
+        bids_ask_delta = order_book_bids / order_book_asks
+        logger.info('bids: %s, asks: %s, delta: %s', order_book_bids,
+                    order_book_asks, bids_ask_delta)
+        if bids_ask_delta >= conf_bids_to_ask_delta:
+            return True
+        return False
+
+    def execute_buy(self, pair: str, stake_amount: float, price: Optional[float] = None) -> bool:
+        """
+        Executes a limit buy for the given pair
+        :param pair: pair for which we want to create a LIMIT_BUY
+        :return: None
+        """
+        pair_s = pair.replace('_', '/')
+        stake_currency = self.config['stake_currency']
+        fiat_currency = self.config.get('fiat_display_currency', None)
+        time_in_force = self.strategy.order_time_in_force['buy']
+
+        if price:
+            buy_limit_requested = price
+        else:
+            # Calculate amount
+            buy_limit_requested = self.get_target_bid(pair)
+
+        min_stake_amount = self._get_min_pair_stake_amount(pair_s, buy_limit_requested)
+        if min_stake_amount is not None and min_stake_amount > stake_amount:
+            logger.warning(
+                f'Can\'t open a new trade for {pair_s}: stake amount '
+                f'is too small ({stake_amount} < {min_stake_amount})'
+            )
+            return False
+
+        amount = stake_amount / buy_limit_requested
+
+        order = self.exchange.buy(pair=pair, ordertype=self.strategy.order_types['buy'],
+                                  amount=amount, rate=buy_limit_requested,
+                                  time_in_force=time_in_force)
+        order_id = order['id']
+        order_status = order.get('status', None)
+
+        # we assume the order is executed at the price requested
+        buy_limit_filled_price = buy_limit_requested
+
+        if order_status == 'expired' or order_status == 'rejected':
+            order_type = self.strategy.order_types['buy']
+            order_tif = self.strategy.order_time_in_force['buy']
+
+            # return false if the order is not filled
+            if float(order['filled']) == 0:
+                logger.warning('Buy %s order with time in force %s for %s is %s by %s.'
+                               ' zero amount is fulfilled.',
+                               order_tif, order_type, pair_s, order_status, self.exchange.name)
+                return False
+            else:
+                # the order is partially fulfilled
+                # in case of IOC orders we can check immediately
+                # if the order is fulfilled fully or partially
+                logger.warning('Buy %s order with time in force %s for %s is %s by %s.'
+                               ' %s amount fulfilled out of %s (%s remaining which is canceled).',
+                               order_tif, order_type, pair_s, order_status, self.exchange.name,
+                               order['filled'], order['amount'], order['remaining']
+                               )
+                stake_amount = order['cost']
+                amount = order['amount']
+                buy_limit_filled_price = order['price']
+                order_id = None
+
+        # in case of FOK the order may be filled immediately and fully
+        elif order_status == 'closed':
+            stake_amount = order['cost']
+            amount = order['amount']
+            buy_limit_filled_price = order['price']
+
+        self.rpc.send_msg({
+            'type': RPCMessageType.BUY_NOTIFICATION,
+            'exchange': self.exchange.name.capitalize(),
+            'pair': pair_s,
+            'limit': buy_limit_filled_price,
+            'stake_amount': stake_amount,
+            'stake_currency': stake_currency,
+            'fiat_currency': fiat_currency
+        })
+
+        # Fee is applied twice because we make a LIMIT_BUY and LIMIT_SELL
+        fee = self.exchange.get_fee(symbol=pair, taker_or_maker='maker')
+        trade = Trade(
+            pair=pair,
+            stake_amount=stake_amount,
+            amount=amount,
+            fee_open=fee,
+            fee_close=fee,
+            open_rate=buy_limit_filled_price,
+            open_rate_requested=buy_limit_requested,
+            open_date=datetime.utcnow(),
+            exchange=self.exchange.id,
+            open_order_id=order_id,
+            strategy=self.strategy.get_strategy_name(),
+            ticker_interval=timeframe_to_minutes(self.config['ticker_interval'])
+        )
+
+        # Update fees if order is closed
+        if order_status == 'closed':
+            self.update_trade_state(trade, order)
+
+        Trade.session.add(trade)
+        Trade.session.flush()
+
+        # Updating wallets
+        self.wallets.update()
+
+        return True
+
+    def process_maybe_execute_buy(self) -> bool:
+        """
+        Tries to execute a buy trade in a safe way
+        :return: True if executed
+        """
+        try:
+            # Create entity and execute trade
+            if self.create_trade():
+                return True
+
+            logger.info('Found no buy signals for whitelisted currencies. Trying again..')
+            return False
+        except DependencyException as exception:
+            logger.warning('Unable to create trade: %s', exception)
+            return False
+
+    def process_maybe_execute_sell(self, trade: Trade) -> bool:
+        """
+        Tries to execute a sell trade
+        :return: True if executed
+        """
+        try:
+            self.update_trade_state(trade)
+
+            if self.strategy.order_types.get('stoploss_on_exchange') and trade.is_open:
+                result = self.handle_stoploss_on_exchange(trade)
+                if result:
+                    self.wallets.update()
+                    return result
+
+            if trade.is_open and trade.open_order_id is None:
+                # Check if we can sell our current pair
+                result = self.handle_trade(trade)
+
+                # Updating wallets if any trade occured
+                if result:
+                    self.wallets.update()
+
+                return result
+
+        except DependencyException as exception:
+            logger.warning('Unable to sell trade: %s', exception)
+        return False
+
+    def get_real_amount(self, trade: Trade, order: Dict) -> float:
+        """
+        Get real amount for the trade
+        Necessary for self.exchanges which charge fees in base currency (e.g. binance)
+        """
+        order_amount = order['amount']
+        # Only run for closed orders
+        if trade.fee_open == 0 or order['status'] == 'open':
+            return order_amount
+
+        # use fee from order-dict if possible
+        if 'fee' in order and order['fee'] and (order['fee'].keys() >= {'currency', 'cost'}):
+            if trade.pair.startswith(order['fee']['currency']):
+                new_amount = order_amount - order['fee']['cost']
+                logger.info("Applying fee on amount for %s (from %s to %s) from Order",
+                            trade, order['amount'], new_amount)
+                return new_amount
+
+        # Fallback to Trades
+        trades = self.exchange.get_trades_for_order(trade.open_order_id, trade.pair,
+                                                    trade.open_date)
+
+        if len(trades) == 0:
+            logger.info("Applying fee on amount for %s failed: myTrade-Dict empty found", trade)
+            return order_amount
+        amount = 0
+        fee_abs = 0
+        for exectrade in trades:
+            amount += exectrade['amount']
+            if "fee" in exectrade and (exectrade['fee'].keys() >= {'currency', 'cost'}):
+                # only applies if fee is in quote currency!
+                if trade.pair.startswith(exectrade['fee']['currency']):
+                    fee_abs += exectrade['fee']['cost']
+
+        if amount != order_amount:
+            logger.warning(f"Amount {amount} does not match amount {trade.amount}")
+            raise OperationalException("Half bought? Amounts don't match")
+        real_amount = amount - fee_abs
+        if fee_abs != 0:
+            logger.info(f"Applying fee on amount for {trade} "
+                        f"(from {order_amount} to {real_amount}) from Trades")
+        return real_amount
+
+    def update_trade_state(self, trade, action_order: dict = None):
+        """
+        Checks trades with open orders and updates the amount if necessary
+        """
+        # Get order details for actual price per unit
+        if trade.open_order_id:
+            # Update trade with order values
+            logger.info('Found open order for %s', trade)
+            order = action_order or self.exchange.get_order(trade.open_order_id, trade.pair)
+            # Try update amount (binance-fix)
+            try:
+                new_amount = self.get_real_amount(trade, order)
+                if order['amount'] != new_amount:
+                    order['amount'] = new_amount
+                    # Fee was applied, so set to 0
+                    trade.fee_open = 0
+
+            except OperationalException as exception:
+                logger.warning("Could not update trade amount: %s", exception)
+
+            trade.update(order)
+
+    def get_sell_rate(self, pair: str, refresh: bool) -> float:
+        """
+        Get sell rate - either using get-ticker bid or first bid based on orderbook
+        The orderbook portion is only used for rpc messaging, which would otherwise fail
+        for BitMex (has no bid/ask in get_ticker)
+        or remain static in any other case since it's not updating.
+        :return: Bid rate
+        """
+        config_ask_strategy = self.config.get('ask_strategy', {})
+        if config_ask_strategy.get('use_order_book', False):
+            logger.debug('Using order book to get sell rate')
+
+            order_book = self.exchange.get_order_book(pair, 1)
+            rate = order_book['bids'][0][0]
+
+        else:
+            rate = self.exchange.get_ticker(pair, refresh)['bid']
+        return rate
+
+    def handle_trade(self, trade: Trade) -> bool:
+        """
+        Sells the current pair if the threshold is reached and updates the trade record.
+        :return: True if trade has been sold, False otherwise
+        """
+        if not trade.is_open:
+            raise ValueError(f'Attempt to handle closed trade: {trade}')
+
+        logger.debug('Handling %s ...', trade)
+
+        (buy, sell) = (False, False)
+        experimental = self.config.get('experimental', {})
+        if experimental.get('use_sell_signal') or experimental.get('ignore_roi_if_buy_signal'):
+            (buy, sell) = self.strategy.get_signal(
+                trade.pair, self.strategy.ticker_interval,
+                self.dataprovider.ohlcv(trade.pair, self.strategy.ticker_interval))
+
+        config_ask_strategy = self.config.get('ask_strategy', {})
+        if config_ask_strategy.get('use_order_book', False):
+            logger.info('Using order book for selling...')
+            # logger.debug('Order book %s',orderBook)
+            order_book_min = config_ask_strategy.get('order_book_min', 1)
+            order_book_max = config_ask_strategy.get('order_book_max', 1)
+
+            order_book = self.exchange.get_order_book(trade.pair, order_book_max)
+
+            for i in range(order_book_min, order_book_max + 1):
+                order_book_rate = order_book['asks'][i - 1][0]
+                logger.info('  order book asks top %s: %0.8f', i, order_book_rate)
+                sell_rate = order_book_rate
+
+                if self.check_sell(trade, sell_rate, buy, sell):
+                    return True
+
+        else:
+            logger.debug('checking sell')
+            sell_rate = self.get_sell_rate(trade.pair, True)
+            if self.check_sell(trade, sell_rate, buy, sell):
+                return True
+
+        logger.debug('Found no sell signal for %s.', trade)
+        return False
+
+    def handle_stoploss_on_exchange(self, trade: Trade) -> bool:
+        """
+        Check if trade is fulfilled in which case the stoploss
+        on exchange should be added immediately if stoploss on exchange
+        is enabled.
+        """
+
+        logger.debug('Handling stoploss on exchange %s ...', trade)
+
+        stoploss_order = None
+
+        try:
+            # First we check if there is already a stoploss on exchange
+            stoploss_order = self.exchange.get_order(trade.stoploss_order_id, trade.pair) \
+                if trade.stoploss_order_id else None
+        except InvalidOrderException as exception:
+            logger.warning('Unable to fetch stoploss order: %s', exception)
+
+        # If trade open order id does not exist: buy order is fulfilled
+        buy_order_fulfilled = not trade.open_order_id
+
+        # Limit price threshold: As limit price should always be below price
+        limit_price_pct = 0.99
+
+        # If buy order is fulfilled but there is no stoploss, we add a stoploss on exchange
+        if (buy_order_fulfilled and not stoploss_order):
+            if self.edge:
+                stoploss = self.edge.stoploss(pair=trade.pair)
+            else:
+                stoploss = self.strategy.stoploss
+
+            stop_price = trade.open_rate * (1 + stoploss)
+
+            # limit price should be less than stop price.
+            limit_price = stop_price * limit_price_pct
+
+            try:
+                stoploss_order_id = self.exchange.stoploss_limit(
+                    pair=trade.pair, amount=trade.amount, stop_price=stop_price, rate=limit_price
+                )['id']
+                trade.stoploss_order_id = str(stoploss_order_id)
+                trade.stoploss_last_update = datetime.now()
+                return False
+
+            except DependencyException as exception:
+                logger.warning('Unable to place a stoploss order on exchange: %s', exception)
+
+        # If stoploss order is canceled for some reason we add it
+        if stoploss_order and stoploss_order['status'] == 'canceled':
+            try:
+                stoploss_order_id = self.exchange.stoploss_limit(
+                    pair=trade.pair, amount=trade.amount,
+                    stop_price=trade.stop_loss, rate=trade.stop_loss * limit_price_pct
+                )['id']
+                trade.stoploss_order_id = str(stoploss_order_id)
+                return False
+            except DependencyException as exception:
+                logger.warning('Stoploss order was cancelled, '
+                               'but unable to recreate one: %s', exception)
+
+        # We check if stoploss order is fulfilled
+        if stoploss_order and stoploss_order['status'] == 'closed':
+            trade.sell_reason = SellType.STOPLOSS_ON_EXCHANGE.value
+            trade.update(stoploss_order)
+            self.notify_sell(trade)
+            return True
+
+        # Finally we check if stoploss on exchange should be moved up because of trailing.
+        if stoploss_order and self.config.get('trailing_stop', False):
+            # if trailing stoploss is enabled we check if stoploss value has changed
+            # in which case we cancel stoploss order and put another one with new
+            # value immediately
+            self.handle_trailing_stoploss_on_exchange(trade, stoploss_order)
+
+        return False
+
+    def handle_trailing_stoploss_on_exchange(self, trade: Trade, order):
+        """
+        Check to see if stoploss on exchange should be updated
+        in case of trailing stoploss on exchange
+        :param Trade: Corresponding Trade
+        :param order: Current on exchange stoploss order
+        :return: None
+        """
+
+        if trade.stop_loss > float(order['info']['stopPrice']):
+            # we check if the update is neccesary
+            update_beat = self.strategy.order_types.get('stoploss_on_exchange_interval', 60)
+            if (datetime.utcnow() - trade.stoploss_last_update).total_seconds() > update_beat:
+                # cancelling the current stoploss on exchange first
+                logger.info('Trailing stoploss: cancelling current stoploss on exchange (id:{%s})'
+                            'in order to add another one ...', order['id'])
+                if self.exchange.cancel_order(order['id'], trade.pair):
+                    # creating the new one
+                    stoploss_order_id = self.exchange.stoploss_limit(
+                        pair=trade.pair, amount=trade.amount,
+                        stop_price=trade.stop_loss, rate=trade.stop_loss * 0.99
+                    )['id']
+                    trade.stoploss_order_id = str(stoploss_order_id)
+
+    def check_sell(self, trade: Trade, sell_rate: float, buy: bool, sell: bool) -> bool:
+        if self.edge:
+            stoploss = self.edge.stoploss(trade.pair)
+            should_sell = self.strategy.should_sell(
+                trade, sell_rate, datetime.utcnow(), buy, sell, force_stoploss=stoploss)
+        else:
+            should_sell = self.strategy.should_sell(trade, sell_rate, datetime.utcnow(), buy, sell)
+
+        if should_sell.sell_flag:
+            self.execute_sell(trade, sell_rate, should_sell.sell_type)
+            logger.info('executed sell, reason: %s', should_sell.sell_type)
+            return True
+        return False
+
+    def check_handle_timedout(self) -> None:
+        """
+        Check if any orders are timed out and cancel if neccessary
+        :param timeoutvalue: Number of minutes until order is considered timed out
+        :return: None
+        """
+        buy_timeout = self.config['unfilledtimeout']['buy']
+        sell_timeout = self.config['unfilledtimeout']['sell']
+        buy_timeoutthreashold = arrow.utcnow().shift(minutes=-buy_timeout).datetime
+        sell_timeoutthreashold = arrow.utcnow().shift(minutes=-sell_timeout).datetime
+
+        for trade in Trade.query.filter(Trade.open_order_id.isnot(None)).all():
+            try:
+                # FIXME: Somehow the query above returns results
+                # where the open_order_id is in fact None.
+                # This is probably because the record got
+                # updated via /forcesell in a different thread.
+                if not trade.open_order_id:
+                    continue
+                order = self.exchange.get_order(trade.open_order_id, trade.pair)
+            except (RequestException, DependencyException):
+                logger.info(
+                    'Cannot query order for %s due to %s',
+                    trade,
+                    traceback.format_exc())
+                continue
+            ordertime = arrow.get(order['datetime']).datetime
+
+            # Check if trade is still actually open
+            if float(order['remaining']) == 0.0:
+                self.wallets.update()
+                continue
+
+            # Handle cancelled on exchange
+            if order['status'] == 'canceled':
+                if order['side'] == 'buy':
+                    self.handle_buy_order_full_cancel(trade, "canceled on Exchange")
+                elif order['side'] == 'sell':
+                    self.handle_timedout_limit_sell(trade, order)
+                    self.wallets.update()
+            # Check if order is still actually open
+            elif order['status'] == 'open':
+                if order['side'] == 'buy' and ordertime < buy_timeoutthreashold:
+                    self.handle_timedout_limit_buy(trade, order)
+                    self.wallets.update()
+                elif order['side'] == 'sell' and ordertime < sell_timeoutthreashold:
+                    self.handle_timedout_limit_sell(trade, order)
+                    self.wallets.update()
+
+    def handle_buy_order_full_cancel(self, trade: Trade, reason: str) -> None:
+        """Close trade in database and send message"""
+        Trade.session.delete(trade)
+        Trade.session.flush()
+        logger.info('Buy order %s for %s.', reason, trade)
+        self.rpc.send_msg({
+            'type': RPCMessageType.STATUS_NOTIFICATION,
+            'status': f'Unfilled buy order for {trade.pair} {reason}'
+        })
+
+    def handle_timedout_limit_buy(self, trade: Trade, order: Dict) -> bool:
+        """Buy timeout - cancel order
+        :return: True if order was fully cancelled
+        """
+        self.exchange.cancel_order(trade.open_order_id, trade.pair)
+        if order['remaining'] == order['amount']:
+            # if trade is not partially completed, just delete the trade
+            self.handle_buy_order_full_cancel(trade, "cancelled due to timeout")
+            return True
+
+        # if trade is partially complete, edit the stake details for the trade
+        # and close the order
+        trade.amount = order['amount'] - order['remaining']
+        trade.stake_amount = trade.amount * trade.open_rate
+        trade.open_order_id = None
+        logger.info('Partial buy order timeout for %s.', trade)
+        self.rpc.send_msg({
+            'type': RPCMessageType.STATUS_NOTIFICATION,
+            'status': f'Remaining buy order for {trade.pair} cancelled due to timeout'
+        })
+        return False
+
+    def handle_timedout_limit_sell(self, trade: Trade, order: Dict) -> bool:
+        """
+        Sell timeout - cancel order and update trade
+        :return: True if order was fully cancelled
+        """
+        if order['remaining'] == order['amount']:
+            # if trade is not partially completed, just cancel the trade
+            if order["status"] != "canceled":
+                reason = "due to timeout"
+                self.exchange.cancel_order(trade.open_order_id, trade.pair)
+                logger.info('Sell order timeout for %s.', trade)
+            else:
+                reason = "on exchange"
+                logger.info('Sell order canceled on exchange for %s.', trade)
+            trade.close_rate = None
+            trade.close_profit = None
+            trade.close_date = None
+            trade.is_open = True
+            trade.open_order_id = None
+            self.rpc.send_msg({
+                'type': RPCMessageType.STATUS_NOTIFICATION,
+                'status': f'Unfilled sell order for {trade.pair} cancelled {reason}'
+            })
+
+            return True
+
+        # TODO: figure out how to handle partially complete sell orders
+        return False
+
+    def execute_sell(self, trade: Trade, limit: float, sell_reason: SellType) -> None:
+        """
+        Executes a limit sell for the given trade and limit
+        :param trade: Trade instance
+        :param limit: limit rate for the sell order
+        :param sellreason: Reason the sell was triggered
+        :return: None
+        """
+        sell_type = 'sell'
+        if sell_reason in (SellType.STOP_LOSS, SellType.TRAILING_STOP_LOSS):
+            sell_type = 'stoploss'
+
+        # if stoploss is on exchange and we are on dry_run mode,
+        # we consider the sell price stop price
+        if self.config.get('dry_run', False) and sell_type == 'stoploss' \
+           and self.strategy.order_types['stoploss_on_exchange']:
+            limit = trade.stop_loss
+
+        # First cancelling stoploss on exchange ...
+        if self.strategy.order_types.get('stoploss_on_exchange') and trade.stoploss_order_id:
+            self.exchange.cancel_order(trade.stoploss_order_id, trade.pair)
+
+        # Execute sell and update trade record
+        order_id = self.exchange.sell(pair=str(trade.pair),
+                                      ordertype=self.strategy.order_types[sell_type],
+                                      amount=trade.amount, rate=limit,
+                                      time_in_force=self.strategy.order_time_in_force['sell']
+                                      )['id']
+
+        trade.open_order_id = order_id
+        trade.close_rate_requested = limit
+        trade.sell_reason = sell_reason.value
+        Trade.session.flush()
+        self.notify_sell(trade)
+
+    def notify_sell(self, trade: Trade):
+        """
+        Sends rpc notification when a sell occured.
+        """
+        profit_rate = trade.close_rate if trade.close_rate else trade.close_rate_requested
+        profit_trade = trade.calc_profit(rate=profit_rate)
+        # Use cached ticker here - it was updated seconds ago.
+        current_rate = self.get_sell_rate(trade.pair, False)
+        profit_percent = trade.calc_profit_percent(profit_rate)
+        gain = "profit" if profit_percent > 0 else "loss"
+
+        msg = {
+            'type': RPCMessageType.SELL_NOTIFICATION,
+            'exchange': trade.exchange.capitalize(),
+            'pair': trade.pair,
+            'gain': gain,
+            'limit': trade.close_rate_requested,
+            'amount': trade.amount,
+            'open_rate': trade.open_rate,
+            'current_rate': current_rate,
+            'profit_amount': profit_trade,
+            'profit_percent': profit_percent,
+            'sell_reason': trade.sell_reason
+        }
+
+        # For regular case, when the configuration exists
+        if 'stake_currency' in self.config and 'fiat_display_currency' in self.config:
+            stake_currency = self.config['stake_currency']
+            fiat_currency = self.config['fiat_display_currency']
+            msg.update({
+                'stake_currency': stake_currency,
+                'fiat_currency': fiat_currency,
+            })
+
+        # Send the message
+        self.rpc.send_msg(msg)

freqtrade/indicator_helpers.py

@@ -0,0 +1,40 @@
+from math import cos, exp, pi, sqrt
+
+import numpy as np
+import talib as ta
+from pandas import Series
+
+
+def went_up(series: Series) -> bool:
+    return series > series.shift(1)
+
+
+def went_down(series: Series) -> bool:
+    return series < series.shift(1)
+
+
+def ehlers_super_smoother(series: Series, smoothing: float = 6) -> Series:
+    magic = pi * sqrt(2) / smoothing
+    a1 = exp(-magic)
+    coeff2 = 2 * a1 * cos(magic)
+    coeff3 = -a1 * a1
+    coeff1 = (1 - coeff2 - coeff3) / 2
+
+    filtered = series.copy()
+
+    for i in range(2, len(series)):
+        filtered.iloc[i] = coeff1 * (series.iloc[i] + series.iloc[i-1]) + \
+            coeff2 * filtered.iloc[i-1] + coeff3 * filtered.iloc[i-2]
+
+    return filtered
+
+
+def fishers_inverse(series: Series, smoothing: float = 0) -> np.ndarray:
+    """ Does a smoothed fishers inverse transformation.
+        Can be used with any oscillator that goes from 0 to 100 like RSI or MFI """
+    v1 = 0.1 * (series - 50)
+    if smoothing > 0:
+        v2 = ta.WMA(v1.values, timeperiod=smoothing)
+    else:
+        v2 = v1
+    return (np.exp(2 * v2)-1) / (np.exp(2 * v2) + 1)

freqtrade/main.py

@@ -1,288 +1,60 @@
 #!/usr/bin/env python3
-import copy
-import json
+"""
+Main Freqtrade bot script.
+Read the documentation to know what cli arguments you need.
+"""
 import logging
-import time
-import traceback
-from datetime import datetime
-from typing import Dict, Optional
-from signal import signal, SIGINT, SIGABRT, SIGTERM
+import sys
+from argparse import Namespace
+from typing import List
 
-import requests
-from jsonschema import validate
-
-from freqtrade import __version__, exchange, persistence
-from freqtrade.analyze import get_buy_signal
-from freqtrade.misc import CONF_SCHEMA, State, get_state, update_state
-from freqtrade.persistence import Trade
-from freqtrade.rpc import telegram
-
-logging.basicConfig(level=logging.DEBUG,
-                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-_CONF = {}
+from freqtrade import OperationalException
+from freqtrade.arguments import Arguments
+from freqtrade.configuration import set_loggers
+from freqtrade.worker import Worker
 
 
-def _process() -> bool:
+logger = logging.getLogger('freqtrade')
+
+
+def main(sysargv: List[str]) -> None:
     """
-    Queries the persistence layer for open trades and handles them,
-    otherwise a new trade is created.
-    :return: True if a trade has been created or closed, False otherwise
+    This function will initiate the bot and start the trading loop.
+    :return: None
     """
-    state_changed = False
+    arguments = Arguments(
+        sysargv,
+        'Free, open source crypto trading bot'
+    )
+    args: Namespace = arguments.get_parsed_arg()
+
+    # A subcommand has been issued.
+    # Means if Backtesting or Hyperopt have been called we exit the bot
+    if hasattr(args, 'func'):
+        args.func(args)
+        return
+
+    worker = None
+    return_code = 1
     try:
-        # Query trades from persistence layer
-        trades = Trade.query.filter(Trade.is_open.is_(True)).all()
-        if len(trades) < _CONF['max_open_trades']:
-            try:
-                # Create entity and execute trade
-                trade = create_trade(float(_CONF['stake_amount']))
-                if trade:
-                    Trade.session.add(trade)
-                    state_changed = True
-                else:
-                    logging.info('Got no buy signal...')
-            except ValueError:
-                logger.exception('Unable to create trade')
+        # Load and run worker
+        worker = Worker(args)
+        worker.run()
 
-        for trade in trades:
-            # Get order details for actual price per unit
-            if trade.open_order_id:
-                # Update trade with order values
-                logger.info('Got open order for %s', trade)
-                trade.update(exchange.get_order(trade.open_order_id))
-
-            if not close_trade_if_fulfilled(trade):
-                # Check if we can sell our current pair
-                state_changed = handle_trade(trade) or state_changed
-
-            Trade.session.flush()
-    except (requests.exceptions.RequestException, json.JSONDecodeError) as error:
-        msg = 'Got {} in _process(), retrying in 30 seconds...'.format(error.__class__.__name__)
-        logger.exception(msg)
-        time.sleep(30)
-    except RuntimeError:
-        telegram.send_msg('*Status:* Got RuntimeError:\n```\n{traceback}```{hint}'.format(
-            traceback=traceback.format_exc(),
-            hint='Issue `/start` if you think it is safe to restart.'
-        ))
-        logger.exception('Got RuntimeError. Stopping trader ...')
-        update_state(State.STOPPED)
-    return state_changed
-
-
-def close_trade_if_fulfilled(trade: Trade) -> bool:
-    """
-    Checks if the trade is closable, and if so it is being closed.
-    :param trade: Trade
-    :return: True if trade has been closed else False
-    """
-    # If we don't have an open order and the close rate is already set,
-    # we can close this trade.
-    if trade.close_profit is not None \
-            and trade.close_date is not None \
-            and trade.close_rate is not None \
-            and trade.open_order_id is None:
-        trade.is_open = False
-        logger.info('No open orders found and trade is fulfilled. Marking %s as closed ...', trade)
-        return True
-    return False
-
-
-def execute_sell(trade: Trade, limit: float) -> None:
-    """
-    Executes a limit sell for the given trade and limit
-    :param trade: Trade instance
-    :param limit: limit rate for the sell order
-    :return: None
-    """
-    # Execute sell and update trade record
-    order_id = exchange.sell(str(trade.pair), limit, trade.amount)
-    trade.open_order_id = order_id
-
-    fmt_exp_profit = round(trade.calc_profit(limit) * 100, 2)
-    message = '*{}:* Selling [{}]({}) with limit `{:.8f} (profit: ~{:.2f}%)`'.format(
-        trade.exchange,
-        trade.pair.replace('_', '/'),
-        exchange.get_pair_detail_url(trade.pair),
-        limit,
-        fmt_exp_profit
-    )
-    logger.info(message)
-    telegram.send_msg(message)
-
-
-def should_sell(trade: Trade, current_rate: float, current_time: datetime) -> bool:
-    """
-    Based an earlier trade and current price and configuration, decides whether bot should sell
-    :return True if bot should sell at current rate
-    """
-    current_profit = trade.calc_profit(current_rate)
-    if 'stoploss' in _CONF and current_profit < float(_CONF['stoploss']):
-        logger.debug('Stop loss hit.')
-        return True
-
-    for duration, threshold in sorted(_CONF['minimal_roi'].items()):
-        # Check if time matches and current rate is above threshold
-        time_diff = (current_time - trade.open_date).total_seconds() / 60
-        if time_diff > float(duration) and current_profit > threshold:
-            return True
-
-    logger.debug('Threshold not reached. (cur_profit: %1.2f%%)', current_profit * 100.0)
-    return False
-
-
-def handle_trade(trade: Trade) -> bool:
-    """
-    Sells the current pair if the threshold is reached and updates the trade record.
-    :return: True if trade has been sold, False otherwise
-    """
-    if not trade.is_open:
-        raise ValueError('attempt to handle closed trade: {}'.format(trade))
-
-    logger.debug('Handling %s ...', trade)
-    current_rate = exchange.get_ticker(trade.pair)['bid']
-    if should_sell(trade, current_rate, datetime.utcnow()):
-        execute_sell(trade, current_rate)
-        return True
-    return False
-
-
-def get_target_bid(ticker: Dict[str, float]) -> float:
-    """ Calculates bid target between current ask price and last price """
-    if ticker['ask'] < ticker['last']:
-        return ticker['ask']
-    balance = _CONF['bid_strategy']['ask_last_balance']
-    return ticker['ask'] + balance * (ticker['last'] - ticker['ask'])
-
-
-def create_trade(stake_amount: float) -> Optional[Trade]:
-    """
-    Checks the implemented trading indicator(s) for a randomly picked pair,
-    if one pair triggers the buy_signal a new trade record gets created
-    :param stake_amount: amount of btc to spend
-    """
-    logger.info('Creating new trade with stake_amount: %f ...', stake_amount)
-    whitelist = copy.deepcopy(_CONF['exchange']['pair_whitelist'])
-    # Check if stake_amount is fulfilled
-    if exchange.get_balance(_CONF['stake_currency']) < stake_amount:
-        raise ValueError(
-            'stake amount is not fulfilled (currency={})'.format(_CONF['stake_currency'])
-        )
-
-    # Remove currently opened and latest pairs from whitelist
-    for trade in Trade.query.filter(Trade.is_open.is_(True)).all():
-        if trade.pair in whitelist:
-            whitelist.remove(trade.pair)
-            logger.debug('Ignoring %s in pair whitelist', trade.pair)
-    if not whitelist:
-        raise ValueError('No pair in whitelist')
-
-    # Pick pair based on StochRSI buy signals
-    for _pair in whitelist:
-        if get_buy_signal(_pair):
-            pair = _pair
-            break
-    else:
-        return None
-
-    # Calculate amount and subtract fee
-    fee = exchange.get_fee()
-    buy_limit = get_target_bid(exchange.get_ticker(pair))
-    amount = (1 - fee) * stake_amount / buy_limit
-
-    order_id = exchange.buy(pair, buy_limit, amount)
-    # Create trade entity and return
-    message = '*{}:* Buying [{}]({}) with limit `{:.8f}`'.format(
-        exchange.get_name().upper(),
-        pair.replace('_', '/'),
-        exchange.get_pair_detail_url(pair),
-        buy_limit
-    )
-    logger.info(message)
-    telegram.send_msg(message)
-    # Fee is applied twice because we make a LIMIT_BUY and LIMIT_SELL
-    return Trade(pair=pair,
-                 stake_amount=stake_amount,
-                 amount=amount,
-                 fee=fee * 2,
-                 open_rate=buy_limit,
-                 open_date=datetime.utcnow(),
-                 exchange=exchange.get_name().upper(),
-                 open_order_id=order_id)
-
-
-def init(config: dict, db_url: Optional[str] = None) -> None:
-    """
-    Initializes all modules and updates the config
-    :param config: config as dict
-    :param db_url: database connector string for sqlalchemy (Optional)
-    :return: None
-    """
-    # Initialize all modules
-    telegram.init(config)
-    persistence.init(config, db_url)
-    exchange.init(config)
-
-    # Set initial application state
-    initial_state = config.get('initial_state')
-    if initial_state:
-        update_state(State[initial_state.upper()])
-    else:
-        update_state(State.STOPPED)
-
-    # Register signal handlers
-    for sig in (SIGINT, SIGTERM, SIGABRT):
-        signal(sig, cleanup)
-
-
-def cleanup(*args, **kwargs) -> None:
-    """
-    Cleanup the application state und finish all pending tasks
-    :return: None
-    """
-    telegram.send_msg('*Status:* `Stopping trader...`')
-    logger.info('Stopping trader and cleaning up modules...')
-    update_state(State.STOPPED)
-    persistence.cleanup()
-    telegram.cleanup()
-    exit(0)
-
-
-def main():
-    """
-    Loads and validates the config and handles the main loop
-    :return: None
-    """
-    logger.info('Starting freqtrade %s', __version__)
-
-    global _CONF
-    with open('config.json') as file:
-        _CONF = json.load(file)
-
-    logger.info('Validating configuration ...')
-    validate(_CONF, CONF_SCHEMA)
-
-    init(_CONF)
-    old_state = get_state()
-    logger.info('Initial State: %s', old_state)
-    telegram.send_msg('*Status:* `{}`'.format(old_state.name.lower()))
-    while True:
-        new_state = get_state()
-        # Log state transition
-        if new_state != old_state:
-            telegram.send_msg('*Status:* `{}`'.format(new_state.name.lower()))
-            logging.info('Changing state to: %s', new_state.name)
-
-        if new_state == State.STOPPED:
-            time.sleep(1)
-        elif new_state == State.RUNNING:
-            _process()
-            # We need to sleep here because otherwise we would run into bittrex rate limit
-            time.sleep(exchange.get_sleep_time())
-        old_state = new_state
+    except KeyboardInterrupt:
+        logger.info('SIGINT received, aborting ...')
+        return_code = 0
+    except OperationalException as e:
+        logger.error(str(e))
+        return_code = 2
+    except BaseException:
+        logger.exception('Fatal exception!')
+    finally:
+        if worker:
+            worker.exit()
+        sys.exit(return_code)
 
 
 if __name__ == '__main__':
-    main()
+    set_loggers()
+    main(sys.argv[1:])

freqtrade/misc.py

@@ -1,103 +1,157 @@
-import enum
+"""
+Various tool function for Freqtrade and scripts
+"""
 
-from wrapt import synchronized
+import gzip
+import logging
+import re
+from datetime import datetime
+from typing import Dict
+
+from ccxt import Exchange
+import numpy as np
+from pandas import DataFrame
+import rapidjson
+
+logger = logging.getLogger(__name__)
 
 
-class State(enum.Enum):
-    RUNNING = 0
-    STOPPED = 1
-
-
-# Current application state
-_STATE = State.STOPPED
-
-
-@synchronized
-def update_state(state: State) -> None:
+def shorten_date(_date: str) -> str:
     """
-    Updates the application state
-    :param state: new state
-    :return: None
+    Trim the date so it fits on small screens
     """
-    global _STATE
-    _STATE = state
+    new_date = re.sub('seconds?', 'sec', _date)
+    new_date = re.sub('minutes?', 'min', new_date)
+    new_date = re.sub('hours?', 'h', new_date)
+    new_date = re.sub('days?', 'd', new_date)
+    new_date = re.sub('^an?', '1', new_date)
+    return new_date
 
 
-@synchronized
-def get_state() -> State:
+############################################
+# Used by scripts                          #
+# Matplotlib doesn't support ::datetime64, #
+# so we need to convert it into ::datetime #
+############################################
+def datesarray_to_datetimearray(dates: np.ndarray) -> np.ndarray:
     """
-    Gets the current application state
+    Convert an pandas-array of timestamps into
+    An numpy-array of datetimes
+    :return: numpy-array of datetime
+    """
+    return dates.dt.to_pydatetime()
+
+
+def common_datearray(dfs: Dict[str, DataFrame]) -> np.ndarray:
+    """
+    Return dates from Dataframe
+    :param dfs: Dict with format pair: pair_data
+    :return: List of dates
+    """
+    alldates = {}
+    for pair, pair_data in dfs.items():
+        dates = datesarray_to_datetimearray(pair_data['date'])
+        for date in dates:
+            alldates[date] = 1
+    lst = []
+    for date, _ in alldates.items():
+        lst.append(date)
+    arr = np.array(lst)
+    return np.sort(arr, axis=0)
+
+
+def file_dump_json(filename, data, is_zip=False) -> None:
+    """
+    Dump JSON data into a file
+    :param filename: file to create
+    :param data: JSON Data to save
     :return:
     """
-    return _STATE
+    logger.info(f'dumping json to "{filename}"')
+
+    if is_zip:
+        if not filename.endswith('.gz'):
+            filename = filename + '.gz'
+        with gzip.open(filename, 'w') as fp:
+            rapidjson.dump(data, fp, default=str, number_mode=rapidjson.NM_NATIVE)
+    else:
+        with open(filename, 'w') as fp:
+            rapidjson.dump(data, fp, default=str, number_mode=rapidjson.NM_NATIVE)
+
+    logger.debug(f'done json to "{filename}"')
 
 
-# Required json-schema for user specified config
-CONF_SCHEMA = {
-    'type': 'object',
-    'properties': {
-        'max_open_trades': {'type': 'integer', 'minimum': 1},
-        'stake_currency': {'type': 'string', 'enum': ['BTC', 'ETH', 'USDT']},
-        'stake_amount': {'type': 'number', 'minimum': 0.0005},
-        'dry_run': {'type': 'boolean'},
-        'minimal_roi': {
-            'type': 'object',
-            'patternProperties': {
-                '^[0-9.]+$': {'type': 'number'}
-            },
-            'minProperties': 1
-        },
-        'stoploss': {'type': 'number', 'maximum': 0, 'exclusiveMaximum': True},
-        'bid_strategy': {
-            'type': 'object',
-            'properties': {
-                'ask_last_balance': {
-                    'type': 'number',
-                    'minimum': 0,
-                    'maximum': 1,
-                    'exclusiveMaximum': False
-                },
-            },
-            'required': ['ask_last_balance']
-        },
-        'exchange': {'$ref': '#/definitions/exchange'},
-        'telegram': {
-            'type': 'object',
-            'properties': {
-                'enabled': {'type': 'boolean'},
-                'token': {'type': 'string'},
-                'chat_id': {'type': 'string'},
-            },
-            'required': ['enabled', 'token', 'chat_id']
-        },
-        'initial_state': {'type': 'string', 'enum': ['running', 'stopped']},
-    },
-    'definitions': {
-        'exchange': {
-            'type': 'object',
-            'properties': {
-                'name': {'type': 'string'},
-                'key': {'type': 'string'},
-                'secret': {'type': 'string'},
-                'pair_whitelist': {
-                    'type': 'array',
-                    'items': {'type': 'string'},
-                    'uniqueItems': True
-                }
-            },
-            'required': ['name', 'key', 'secret', 'pair_whitelist']
-        }
-    },
-    'anyOf': [
-        {'required': ['exchange']}
-    ],
-    'required': [
-        'max_open_trades',
-        'stake_currency',
-        'stake_amount',
-        'dry_run',
-        'minimal_roi',
-        'bid_strategy',
-        'telegram'
-    ]
-}
+def json_load(datafile):
+    """
+    load data with rapidjson
+    Use this to have a consistent experience,
+    sete number_mode to "NM_NATIVE" for greatest speed
+    """
+    return rapidjson.load(datafile, number_mode=rapidjson.NM_NATIVE)
+
+
+def file_load_json(file):
+
+    gzipfile = file.with_suffix(file.suffix + '.gz')
+
+    # Try gzip file first, otherwise regular json file.
+    if gzipfile.is_file():
+        logger.debug('Loading ticker data from file %s', gzipfile)
+        with gzip.open(gzipfile) as tickerdata:
+            pairdata = json_load(tickerdata)
+    elif file.is_file():
+        logger.debug('Loading ticker data from file %s', file)
+        with open(file) as tickerdata:
+            pairdata = json_load(tickerdata)
+    else:
+        return None
+    return pairdata
+
+
+def format_ms_time(date: int) -> str:
+    """
+    convert MS date to readable format.
+    : epoch-string in ms
+    """
+    return datetime.fromtimestamp(date/1000.0).strftime('%Y-%m-%dT%H:%M:%S')
+
+
+def deep_merge_dicts(source, destination):
+    """
+    >>> a = { 'first' : { 'rows' : { 'pass' : 'dog', 'number' : '1' } } }
+    >>> b = { 'first' : { 'rows' : { 'fail' : 'cat', 'number' : '5' } } }
+    >>> merge(b, a) == { 'first' : { 'rows' : { 'pass' : 'dog', 'fail' : 'cat', 'number' : '5' } } }
+    True
+    """
+    for key, value in source.items():
+        if isinstance(value, dict):
+            # get node or create one
+            node = destination.setdefault(key, {})
+            deep_merge_dicts(value, node)
+        else:
+            destination[key] = value
+
+    return destination
+
+
+def timeframe_to_seconds(ticker_interval: str) -> int:
+    """
+    Translates the timeframe interval value written in the human readable
+    form ('1m', '5m', '1h', '1d', '1w', etc.) to the number
+    of seconds for one timeframe interval.
+    """
+    return Exchange.parse_timeframe(ticker_interval)
+
+
+def timeframe_to_minutes(ticker_interval: str) -> int:
+    """
+    Same as above, but returns minutes.
+    """
+    return Exchange.parse_timeframe(ticker_interval) // 60
+
+
+def timeframe_to_msecs(ticker_interval: str) -> int:
+    """
+    Same as above, but returns milliseconds.
+    """
+    return Exchange.parse_timeframe(ticker_interval) * 1000

freqtrade/optimize/__init__.py

@@ -0,0 +1,49 @@
+# pragma pylint: disable=missing-docstring
+
+import logging
+from datetime import datetime
+from typing import Dict, Tuple
+import operator
+
+import arrow
+from pandas import DataFrame
+
+from freqtrade.optimize.default_hyperopt import DefaultHyperOpts  # noqa: F401
+
+logger = logging.getLogger(__name__)
+
+
+def get_timeframe(data: Dict[str, DataFrame]) -> Tuple[arrow.Arrow, arrow.Arrow]:
+    """
+    Get the maximum timeframe for the given backtest data
+    :param data: dictionary with preprocessed backtesting data
+    :return: tuple containing min_date, max_date
+    """
+    timeframe = [
+        (arrow.get(frame['date'].min()), arrow.get(frame['date'].max()))
+        for frame in data.values()
+    ]
+    return min(timeframe, key=operator.itemgetter(0))[0], \
+        max(timeframe, key=operator.itemgetter(1))[1]
+
+
+def validate_backtest_data(data: Dict[str, DataFrame], min_date: datetime,
+                           max_date: datetime, ticker_interval_mins: int) -> bool:
+    """
+    Validates preprocessed backtesting data for missing values and shows warnings about it that.
+
+    :param data: dictionary with preprocessed backtesting data
+    :param min_date: start-date of the data
+    :param max_date: end-date of the data
+    :param ticker_interval_mins: ticker interval in minutes
+    """
+    # total difference in minutes / interval-minutes
+    expected_frames = int((max_date - min_date).total_seconds() // 60 // ticker_interval_mins)
+    found_missing = False
+    for pair, df in data.items():
+        dflen = len(df)
+        if dflen < expected_frames:
+            found_missing = True
+            logger.warning("%s has missing frames: expected %s, got %s, that's %s missing values",
+                           pair, expected_frames, dflen, expected_frames - dflen)
+    return found_missing

freqtrade/optimize/backtesting.py

@@ -0,0 +1,521 @@
+# pragma pylint: disable=missing-docstring, W0212, too-many-arguments
+
+"""
+This module contains the backtesting logic
+"""
+import logging
+from argparse import Namespace
+from copy import deepcopy
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any, Dict, List, NamedTuple, Optional
+
+from pandas import DataFrame
+from tabulate import tabulate
+
+from freqtrade import optimize
+from freqtrade import DependencyException, constants
+from freqtrade.arguments import Arguments
+from freqtrade.configuration import Configuration
+from freqtrade.data import history
+from freqtrade.data.dataprovider import DataProvider
+from freqtrade.misc import file_dump_json, timeframe_to_minutes
+from freqtrade.persistence import Trade
+from freqtrade.resolvers import ExchangeResolver, StrategyResolver
+from freqtrade.state import RunMode
+from freqtrade.strategy.interface import SellType, IStrategy
+
+logger = logging.getLogger(__name__)
+
+
+class BacktestResult(NamedTuple):
+    """
+    NamedTuple Defining BacktestResults inputs.
+    """
+    pair: str
+    profit_percent: float
+    profit_abs: float
+    open_time: datetime
+    close_time: datetime
+    open_index: int
+    close_index: int
+    trade_duration: float
+    open_at_end: bool
+    open_rate: float
+    close_rate: float
+    sell_reason: SellType
+
+
+class Backtesting(object):
+    """
+    Backtesting class, this class contains all the logic to run a backtest
+
+    To run a backtest:
+    backtesting = Backtesting(config)
+    backtesting.start()
+    """
+
+    def __init__(self, config: Dict[str, Any]) -> None:
+        self.config = config
+
+        # Reset keys for backtesting
+        self.config['exchange']['key'] = ''
+        self.config['exchange']['secret'] = ''
+        self.config['exchange']['password'] = ''
+        self.config['exchange']['uid'] = ''
+        self.config['dry_run'] = True
+        self.strategylist: List[IStrategy] = []
+
+        exchange_name = self.config.get('exchange', {}).get('name', 'bittrex').title()
+        self.exchange = ExchangeResolver(exchange_name, self.config).exchange
+        self.fee = self.exchange.get_fee()
+
+        if self.config.get('runmode') != RunMode.HYPEROPT:
+            self.dataprovider = DataProvider(self.config, self.exchange)
+            IStrategy.dp = self.dataprovider
+
+        if self.config.get('strategy_list', None):
+            # Force one interval
+            self.ticker_interval = str(self.config.get('ticker_interval'))
+            self.ticker_interval_mins = timeframe_to_minutes(self.ticker_interval)
+            for strat in list(self.config['strategy_list']):
+                stratconf = deepcopy(self.config)
+                stratconf['strategy'] = strat
+                self.strategylist.append(StrategyResolver(stratconf).strategy)
+
+        else:
+            # only one strategy
+            self.strategylist.append(StrategyResolver(self.config).strategy)
+        # Load one strategy
+        self._set_strategy(self.strategylist[0])
+
+    def _set_strategy(self, strategy):
+        """
+        Load strategy into backtesting
+        """
+        self.strategy = strategy
+
+        self.ticker_interval = self.config.get('ticker_interval')
+        self.ticker_interval_mins = timeframe_to_minutes(self.ticker_interval)
+        self.tickerdata_to_dataframe = strategy.tickerdata_to_dataframe
+        self.advise_buy = strategy.advise_buy
+        self.advise_sell = strategy.advise_sell
+        # Set stoploss_on_exchange to false for backtesting,
+        # since a "perfect" stoploss-sell is assumed anyway
+        # And the regular "stoploss" function would not apply to that case
+        self.strategy.order_types['stoploss_on_exchange'] = False
+
+    def _generate_text_table(self, data: Dict[str, Dict], results: DataFrame,
+                             skip_nan: bool = False) -> str:
+        """
+        Generates and returns a text table for the given backtest data and the results dataframe
+        :return: pretty printed table with tabulate as str
+        """
+        stake_currency = str(self.config.get('stake_currency'))
+        max_open_trades = self.config.get('max_open_trades')
+
+        floatfmt = ('s', 'd', '.2f', '.2f', '.8f', '.2f', 'd', '.1f', '.1f')
+        tabular_data = []
+        headers = ['pair', 'buy count', 'avg profit %', 'cum profit %',
+                   'tot profit ' + stake_currency, 'tot profit %', 'avg duration',
+                   'profit', 'loss']
+        for pair in data:
+            result = results[results.pair == pair]
+            if skip_nan and result.profit_abs.isnull().all():
+                continue
+
+            tabular_data.append([
+                pair,
+                len(result.index),
+                result.profit_percent.mean() * 100.0,
+                result.profit_percent.sum() * 100.0,
+                result.profit_abs.sum(),
+                result.profit_percent.sum() * 100.0 / max_open_trades,
+                str(timedelta(
+                    minutes=round(result.trade_duration.mean()))) if not result.empty else '0:00',
+                len(result[result.profit_abs > 0]),
+                len(result[result.profit_abs < 0])
+            ])
+
+        # Append Total
+        tabular_data.append([
+            'TOTAL',
+            len(results.index),
+            results.profit_percent.mean() * 100.0,
+            results.profit_percent.sum() * 100.0,
+            results.profit_abs.sum(),
+            results.profit_percent.sum() * 100.0 / max_open_trades,
+            str(timedelta(
+                minutes=round(results.trade_duration.mean()))) if not results.empty else '0:00',
+            len(results[results.profit_abs > 0]),
+            len(results[results.profit_abs < 0])
+        ])
+        # Ignore type as floatfmt does allow tuples but mypy does not know that
+        return tabulate(tabular_data, headers=headers,  # type: ignore
+                        floatfmt=floatfmt, tablefmt="pipe")
+
+    def _generate_text_table_sell_reason(self, data: Dict[str, Dict], results: DataFrame) -> str:
+        """
+        Generate small table outlining Backtest results
+        """
+        tabular_data = []
+        headers = ['Sell Reason', 'Count']
+        for reason, count in results['sell_reason'].value_counts().iteritems():
+            tabular_data.append([reason.value,  count])
+        return tabulate(tabular_data, headers=headers, tablefmt="pipe")
+
+    def _generate_text_table_strategy(self, all_results: dict) -> str:
+        """
+        Generate summary table per strategy
+        """
+        stake_currency = str(self.config.get('stake_currency'))
+        max_open_trades = self.config.get('max_open_trades')
+
+        floatfmt = ('s', 'd', '.2f', '.2f', '.8f', '.2f', 'd', '.1f', '.1f')
+        tabular_data = []
+        headers = ['Strategy', 'buy count', 'avg profit %', 'cum profit %',
+                   'tot profit ' + stake_currency, 'tot profit %', 'avg duration',
+                   'profit', 'loss']
+        for strategy, results in all_results.items():
+            tabular_data.append([
+                strategy,
+                len(results.index),
+                results.profit_percent.mean() * 100.0,
+                results.profit_percent.sum() * 100.0,
+                results.profit_abs.sum(),
+                results.profit_percent.sum() * 100.0 / max_open_trades,
+                str(timedelta(
+                    minutes=round(results.trade_duration.mean()))) if not results.empty else '0:00',
+                len(results[results.profit_abs > 0]),
+                len(results[results.profit_abs < 0])
+            ])
+        # Ignore type as floatfmt does allow tuples but mypy does not know that
+        return tabulate(tabular_data, headers=headers,  # type: ignore
+                        floatfmt=floatfmt, tablefmt="pipe")
+
+    def _store_backtest_result(self, recordfilename: str, results: DataFrame,
+                               strategyname: Optional[str] = None) -> None:
+
+        records = [(t.pair, t.profit_percent, t.open_time.timestamp(),
+                    t.close_time.timestamp(), t.open_index - 1, t.trade_duration,
+                    t.open_rate, t.close_rate, t.open_at_end, t.sell_reason.value)
+                   for index, t in results.iterrows()]
+
+        if records:
+            if strategyname:
+                # Inject strategyname to filename
+                recname = Path(recordfilename)
+                recordfilename = str(Path.joinpath(
+                    recname.parent, f'{recname.stem}-{strategyname}').with_suffix(recname.suffix))
+            logger.info('Dumping backtest results to %s', recordfilename)
+            file_dump_json(recordfilename, records)
+
+    def _get_ticker_list(self, processed) -> Dict[str, DataFrame]:
+        """
+        Helper function to convert a processed tickerlist into a list for performance reasons.
+
+        Used by backtest() - so keep this optimized for performance.
+        """
+        headers = ['date', 'buy', 'open', 'close', 'sell', 'low', 'high']
+        ticker: Dict = {}
+        # Create ticker dict
+        for pair, pair_data in processed.items():
+            pair_data['buy'], pair_data['sell'] = 0, 0  # cleanup from previous run
+
+            ticker_data = self.advise_sell(
+                self.advise_buy(pair_data, {'pair': pair}), {'pair': pair})[headers].copy()
+
+            # to avoid using data from future, we buy/sell with signal from previous candle
+            ticker_data.loc[:, 'buy'] = ticker_data['buy'].shift(1)
+            ticker_data.loc[:, 'sell'] = ticker_data['sell'].shift(1)
+
+            ticker_data.drop(ticker_data.head(1).index, inplace=True)
+
+            # Convert from Pandas to list for performance reasons
+            # (Looping Pandas is slow.)
+            ticker[pair] = [x for x in ticker_data.itertuples()]
+        return ticker
+
+    def _get_sell_trade_entry(
+            self, pair: str, buy_row: DataFrame,
+            partial_ticker: List, trade_count_lock: Dict, args: Dict) -> Optional[BacktestResult]:
+
+        stake_amount = args['stake_amount']
+        max_open_trades = args.get('max_open_trades', 0)
+        trade = Trade(
+            open_rate=buy_row.open,
+            open_date=buy_row.date,
+            stake_amount=stake_amount,
+            amount=stake_amount / buy_row.open,
+            fee_open=self.fee,
+            fee_close=self.fee
+        )
+
+        # calculate win/lose forwards from buy point
+        for sell_row in partial_ticker:
+            if max_open_trades > 0:
+                # Increase trade_count_lock for every iteration
+                trade_count_lock[sell_row.date] = trade_count_lock.get(sell_row.date, 0) + 1
+
+            buy_signal = sell_row.buy
+            sell = self.strategy.should_sell(trade, sell_row.open, sell_row.date, buy_signal,
+                                             sell_row.sell, low=sell_row.low, high=sell_row.high)
+            if sell.sell_flag:
+
+                trade_dur = int((sell_row.date - buy_row.date).total_seconds() // 60)
+                # Special handling if high or low hit STOP_LOSS or ROI
+                if sell.sell_type in (SellType.STOP_LOSS, SellType.TRAILING_STOP_LOSS):
+                    # Set close_rate to stoploss
+                    closerate = trade.stop_loss
+                elif sell.sell_type == (SellType.ROI):
+                    # get next entry in min_roi > to trade duration
+                    # Interface.py skips on trade_duration <= duration
+                    roi_entry = max(list(filter(lambda x: trade_dur >= x,
+                                                self.strategy.minimal_roi.keys())))
+                    roi = self.strategy.minimal_roi[roi_entry]
+
+                    # - (Expected abs profit + open_rate + open_fee) / (fee_close -1)
+                    closerate = - (trade.open_rate * roi + trade.open_rate *
+                                   (1 + trade.fee_open)) / (trade.fee_close - 1)
+                else:
+                    closerate = sell_row.open
+
+                return BacktestResult(pair=pair,
+                                      profit_percent=trade.calc_profit_percent(rate=closerate),
+                                      profit_abs=trade.calc_profit(rate=closerate),
+                                      open_time=buy_row.date,
+                                      close_time=sell_row.date,
+                                      trade_duration=trade_dur,
+                                      open_index=buy_row.Index,
+                                      close_index=sell_row.Index,
+                                      open_at_end=False,
+                                      open_rate=buy_row.open,
+                                      close_rate=closerate,
+                                      sell_reason=sell.sell_type
+                                      )
+        if partial_ticker:
+            # no sell condition found - trade stil open at end of backtest period
+            sell_row = partial_ticker[-1]
+            btr = BacktestResult(pair=pair,
+                                 profit_percent=trade.calc_profit_percent(rate=sell_row.open),
+                                 profit_abs=trade.calc_profit(rate=sell_row.open),
+                                 open_time=buy_row.date,
+                                 close_time=sell_row.date,
+                                 trade_duration=int((
+                                     sell_row.date - buy_row.date).total_seconds() // 60),
+                                 open_index=buy_row.Index,
+                                 close_index=sell_row.Index,
+                                 open_at_end=True,
+                                 open_rate=buy_row.open,
+                                 close_rate=sell_row.open,
+                                 sell_reason=SellType.FORCE_SELL
+                                 )
+            logger.debug('Force_selling still open trade %s with %s perc - %s', btr.pair,
+                         btr.profit_percent, btr.profit_abs)
+            return btr
+        return None
+
+    def backtest(self, args: Dict) -> DataFrame:
+        """
+        Implements backtesting functionality
+
+        NOTE: This method is used by Hyperopt at each iteration. Please keep it optimized.
+        Of course try to not have ugly code. By some accessor are sometime slower than functions.
+        Avoid, logging on this method
+
+        :param args: a dict containing:
+            stake_amount: btc amount to use for each trade
+            processed: a processed dictionary with format {pair, data}
+            max_open_trades: maximum number of concurrent trades (default: 0, disabled)
+            position_stacking: do we allow position stacking? (default: False)
+        :return: DataFrame
+        """
+        processed = args['processed']
+        max_open_trades = args.get('max_open_trades', 0)
+        position_stacking = args.get('position_stacking', False)
+        start_date = args['start_date']
+        end_date = args['end_date']
+        trades = []
+        trade_count_lock: Dict = {}
+
+        # Dict of ticker-lists for performance (looping lists is a lot faster than dataframes)
+        ticker: Dict = self._get_ticker_list(processed)
+
+        lock_pair_until: Dict = {}
+        # Indexes per pair, so some pairs are allowed to have a missing start.
+        indexes: Dict = {}
+        tmp = start_date + timedelta(minutes=self.ticker_interval_mins)
+
+        # Loop timerange and get candle for each pair at that point in time
+        while tmp < end_date:
+
+            for i, pair in enumerate(ticker):
+                if pair not in indexes:
+                    indexes[pair] = 0
+
+                try:
+                    row = ticker[pair][indexes[pair]]
+                except IndexError:
+                    # missing Data for one pair at the end.
+                    # Warnings for this are shown by `validate_backtest_data`
+                    continue
+
+                # Waits until the time-counter reaches the start of the data for this pair.
+                if row.date > tmp.datetime:
+                    continue
+
+                indexes[pair] += 1
+
+                if row.buy == 0 or row.sell == 1:
+                    continue  # skip rows where no buy signal or that would immediately sell off
+
+                if (not position_stacking and pair in lock_pair_until
+                        and row.date <= lock_pair_until[pair]):
+                    # without positionstacking, we can only have one open trade per pair.
+                    continue
+
+                if max_open_trades > 0:
+                    # Check if max_open_trades has already been reached for the given date
+                    if not trade_count_lock.get(row.date, 0) < max_open_trades:
+                        continue
+                    trade_count_lock[row.date] = trade_count_lock.get(row.date, 0) + 1
+
+                trade_entry = self._get_sell_trade_entry(pair, row, ticker[pair][indexes[pair]:],
+                                                         trade_count_lock, args)
+
+                if trade_entry:
+                    lock_pair_until[pair] = trade_entry.close_time
+                    trades.append(trade_entry)
+                else:
+                    # Set lock_pair_until to end of testing period if trade could not be closed
+                    lock_pair_until[pair] = end_date.datetime
+
+            # Move time one configured time_interval ahead.
+            tmp += timedelta(minutes=self.ticker_interval_mins)
+        return DataFrame.from_records(trades, columns=BacktestResult._fields)
+
+    def start(self) -> None:
+        """
+        Run a backtesting end-to-end
+        :return: None
+        """
+        data: Dict[str, Any] = {}
+        pairs = self.config['exchange']['pair_whitelist']
+        logger.info('Using stake_currency: %s ...', self.config['stake_currency'])
+        logger.info('Using stake_amount: %s ...', self.config['stake_amount'])
+
+        if self.config.get('live'):
+            logger.info('Downloading data for all pairs in whitelist ...')
+            self.exchange.refresh_latest_ohlcv([(pair, self.ticker_interval) for pair in pairs])
+            data = {key[0]: value for key, value in self.exchange._klines.items()}
+
+        else:
+            logger.info('Using local backtesting data (using whitelist in given config) ...')
+
+            timerange = Arguments.parse_timerange(None if self.config.get(
+                'timerange') is None else str(self.config.get('timerange')))
+            data = history.load_data(
+                datadir=Path(self.config['datadir']) if self.config.get('datadir') else None,
+                pairs=pairs,
+                ticker_interval=self.ticker_interval,
+                refresh_pairs=self.config.get('refresh_pairs', False),
+                exchange=self.exchange,
+                timerange=timerange
+            )
+
+        if not data:
+            logger.critical("No data found. Terminating.")
+            return
+        # Use max_open_trades in backtesting, except --disable-max-market-positions is set
+        if self.config.get('use_max_market_positions', True):
+            max_open_trades = self.config['max_open_trades']
+        else:
+            logger.info('Ignoring max_open_trades (--disable-max-market-positions was used) ...')
+            max_open_trades = 0
+        all_results = {}
+
+        for strat in self.strategylist:
+            logger.info("Running backtesting for Strategy %s", strat.get_strategy_name())
+            self._set_strategy(strat)
+
+            min_date, max_date = optimize.get_timeframe(data)
+            # Validate dataframe for missing values (mainly at start and end, as fillup is called)
+            optimize.validate_backtest_data(data, min_date, max_date,
+                                            timeframe_to_minutes(self.ticker_interval))
+            logger.info(
+                'Measuring data from %s up to %s (%s days)..',
+                min_date.isoformat(),
+                max_date.isoformat(),
+                (max_date - min_date).days
+            )
+            # need to reprocess data every time to populate signals
+            preprocessed = self.strategy.tickerdata_to_dataframe(data)
+
+            # Execute backtest and print results
+            all_results[self.strategy.get_strategy_name()] = self.backtest(
+                {
+                    'stake_amount': self.config.get('stake_amount'),
+                    'processed': preprocessed,
+                    'max_open_trades': max_open_trades,
+                    'position_stacking': self.config.get('position_stacking', False),
+                    'start_date': min_date,
+                    'end_date': max_date,
+                }
+            )
+
+        for strategy, results in all_results.items():
+
+            if self.config.get('export', False):
+                self._store_backtest_result(self.config['exportfilename'], results,
+                                            strategy if len(self.strategylist) > 1 else None)
+
+            print(f"Result for strategy {strategy}")
+            print(' BACKTESTING REPORT '.center(133, '='))
+            print(self._generate_text_table(data, results))
+
+            print(' SELL REASON STATS '.center(133, '='))
+            print(self._generate_text_table_sell_reason(data, results))
+
+            print(' LEFT OPEN TRADES REPORT '.center(133, '='))
+            print(self._generate_text_table(data, results.loc[results.open_at_end], True))
+            print()
+        if len(all_results) > 1:
+            # Print Strategy summary table
+            print(' Strategy Summary '.center(133, '='))
+            print(self._generate_text_table_strategy(all_results))
+            print('\nFor more details, please look at the detail tables above')
+
+
+def setup_configuration(args: Namespace) -> Dict[str, Any]:
+    """
+    Prepare the configuration for the backtesting
+    :param args: Cli args from Arguments()
+    :return: Configuration
+    """
+    configuration = Configuration(args, RunMode.BACKTEST)
+    config = configuration.get_config()
+
+    # Ensure we do not use Exchange credentials
+    config['exchange']['key'] = ''
+    config['exchange']['secret'] = ''
+
+    if config['stake_amount'] == constants.UNLIMITED_STAKE_AMOUNT:
+        raise DependencyException('stake amount could not be "%s" for backtesting' %
+                                  constants.UNLIMITED_STAKE_AMOUNT)
+
+    return config
+
+
+def start(args: Namespace) -> None:
+    """
+    Start Backtesting script
+    :param args: Cli args from Arguments()
+    :return: None
+    """
+    # Initialize configuration
+    config = setup_configuration(args)
+    logger.info('Starting freqtrade in Backtesting mode')
+
+    # Initialize backtesting object
+    backtesting = Backtesting(config)
+    backtesting.start()

freqtrade/optimize/default_hyperopt.py

@@ -0,0 +1,226 @@
+# pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement
+
+import talib.abstract as ta
+from pandas import DataFrame
+from typing import Dict, Any, Callable, List
+from functools import reduce
+
+from skopt.space import Categorical, Dimension, Integer, Real
+
+import freqtrade.vendor.qtpylib.indicators as qtpylib
+from freqtrade.optimize.hyperopt_interface import IHyperOpt
+
+class_name = 'DefaultHyperOpts'
+
+
+class DefaultHyperOpts(IHyperOpt):
+    """
+    Default hyperopt provided by freqtrade bot.
+    You can override it with your own hyperopt
+    """
+
+    @staticmethod
+    def populate_indicators(dataframe: DataFrame, metadata: dict) -> DataFrame:
+        dataframe['adx'] = ta.ADX(dataframe)
+        macd = ta.MACD(dataframe)
+        dataframe['macd'] = macd['macd']
+        dataframe['macdsignal'] = macd['macdsignal']
+        dataframe['mfi'] = ta.MFI(dataframe)
+        dataframe['rsi'] = ta.RSI(dataframe)
+        stoch_fast = ta.STOCHF(dataframe)
+        dataframe['fastd'] = stoch_fast['fastd']
+        dataframe['minus_di'] = ta.MINUS_DI(dataframe)
+        # Bollinger bands
+        bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
+        dataframe['bb_lowerband'] = bollinger['lower']
+        dataframe['bb_upperband'] = bollinger['upper']
+        dataframe['sar'] = ta.SAR(dataframe)
+        return dataframe
+
+    @staticmethod
+    def buy_strategy_generator(params: Dict[str, Any]) -> Callable:
+        """
+        Define the buy strategy parameters to be used by hyperopt
+        """
+        def populate_buy_trend(dataframe: DataFrame, metadata: dict) -> DataFrame:
+            """
+            Buy strategy Hyperopt will build and use
+            """
+            conditions = []
+            # GUARDS AND TRENDS
+            if 'mfi-enabled' in params and params['mfi-enabled']:
+                conditions.append(dataframe['mfi'] < params['mfi-value'])
+            if 'fastd-enabled' in params and params['fastd-enabled']:
+                conditions.append(dataframe['fastd'] < params['fastd-value'])
+            if 'adx-enabled' in params and params['adx-enabled']:
+                conditions.append(dataframe['adx'] > params['adx-value'])
+            if 'rsi-enabled' in params and params['rsi-enabled']:
+                conditions.append(dataframe['rsi'] < params['rsi-value'])
+
+            # TRIGGERS
+            if 'trigger' in params:
+                if params['trigger'] == 'bb_lower':
+                    conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
+                if params['trigger'] == 'macd_cross_signal':
+                    conditions.append(qtpylib.crossed_above(
+                        dataframe['macd'], dataframe['macdsignal']
+                    ))
+                if params['trigger'] == 'sar_reversal':
+                    conditions.append(qtpylib.crossed_above(
+                        dataframe['close'], dataframe['sar']
+                    ))
+
+            dataframe.loc[
+                reduce(lambda x, y: x & y, conditions),
+                'buy'] = 1
+
+            return dataframe
+
+        return populate_buy_trend
+
+    @staticmethod
+    def indicator_space() -> List[Dimension]:
+        """
+        Define your Hyperopt space for searching strategy parameters
+        """
+        return [
+            Integer(10, 25, name='mfi-value'),
+            Integer(15, 45, name='fastd-value'),
+            Integer(20, 50, name='adx-value'),
+            Integer(20, 40, name='rsi-value'),
+            Categorical([True, False], name='mfi-enabled'),
+            Categorical([True, False], name='fastd-enabled'),
+            Categorical([True, False], name='adx-enabled'),
+            Categorical([True, False], name='rsi-enabled'),
+            Categorical(['bb_lower', 'macd_cross_signal', 'sar_reversal'], name='trigger')
+        ]
+
+    @staticmethod
+    def sell_strategy_generator(params: Dict[str, Any]) -> Callable:
+        """
+        Define the sell strategy parameters to be used by hyperopt
+        """
+        def populate_sell_trend(dataframe: DataFrame, metadata: dict) -> DataFrame:
+            """
+            Sell strategy Hyperopt will build and use
+            """
+            # print(params)
+            conditions = []
+            # GUARDS AND TRENDS
+            if 'sell-mfi-enabled' in params and params['sell-mfi-enabled']:
+                conditions.append(dataframe['mfi'] > params['sell-mfi-value'])
+            if 'sell-fastd-enabled' in params and params['sell-fastd-enabled']:
+                conditions.append(dataframe['fastd'] > params['sell-fastd-value'])
+            if 'sell-adx-enabled' in params and params['sell-adx-enabled']:
+                conditions.append(dataframe['adx'] < params['sell-adx-value'])
+            if 'sell-rsi-enabled' in params and params['sell-rsi-enabled']:
+                conditions.append(dataframe['rsi'] > params['sell-rsi-value'])
+
+            # TRIGGERS
+            if 'sell-trigger' in params:
+                if params['sell-trigger'] == 'sell-bb_upper':
+                    conditions.append(dataframe['close'] > dataframe['bb_upperband'])
+                if params['sell-trigger'] == 'sell-macd_cross_signal':
+                    conditions.append(qtpylib.crossed_above(
+                        dataframe['macdsignal'], dataframe['macd']
+                    ))
+                if params['sell-trigger'] == 'sell-sar_reversal':
+                    conditions.append(qtpylib.crossed_above(
+                        dataframe['sar'], dataframe['close']
+                    ))
+
+            dataframe.loc[
+                reduce(lambda x, y: x & y, conditions),
+                'sell'] = 1
+
+            return dataframe
+
+        return populate_sell_trend
+
+    @staticmethod
+    def sell_indicator_space() -> List[Dimension]:
+        """
+        Define your Hyperopt space for searching sell strategy parameters
+        """
+        return [
+            Integer(75, 100, name='sell-mfi-value'),
+            Integer(50, 100, name='sell-fastd-value'),
+            Integer(50, 100, name='sell-adx-value'),
+            Integer(60, 100, name='sell-rsi-value'),
+            Categorical([True, False], name='sell-mfi-enabled'),
+            Categorical([True, False], name='sell-fastd-enabled'),
+            Categorical([True, False], name='sell-adx-enabled'),
+            Categorical([True, False], name='sell-rsi-enabled'),
+            Categorical(['sell-bb_upper',
+                         'sell-macd_cross_signal',
+                         'sell-sar_reversal'], name='sell-trigger')
+        ]
+
+    @staticmethod
+    def generate_roi_table(params: Dict) -> Dict[int, float]:
+        """
+        Generate the ROI table that will be used by Hyperopt
+        """
+        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
+
+    @staticmethod
+    def stoploss_space() -> List[Dimension]:
+        """
+        Stoploss Value to search
+        """
+        return [
+            Real(-0.5, -0.02, name='stoploss'),
+        ]
+
+    @staticmethod
+    def roi_space() -> List[Dimension]:
+        """
+        Values to search for each ROI steps
+        """
+        return [
+            Integer(10, 120, name='roi_t1'),
+            Integer(10, 60, name='roi_t2'),
+            Integer(10, 40, name='roi_t3'),
+            Real(0.01, 0.04, name='roi_p1'),
+            Real(0.01, 0.07, name='roi_p2'),
+            Real(0.01, 0.20, name='roi_p3'),
+        ]
+
+    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Based on TA indicators. Should be a copy of from strategy
+        must align to populate_indicators in this file
+        Only used when --spaces does not include buy
+        """
+        dataframe.loc[
+            (
+                (dataframe['close'] < dataframe['bb_lowerband']) &
+                (dataframe['mfi'] < 16) &
+                (dataframe['adx'] > 25) &
+                (dataframe['rsi'] < 21)
+            ),
+            'buy'] = 1
+
+        return dataframe
+
+    def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Based on TA indicators. Should be a copy of from strategy
+        must align to populate_indicators in this file
+        Only used when --spaces does not include sell
+        """
+        dataframe.loc[
+            (
+                (qtpylib.crossed_above(
+                    dataframe['macdsignal'], dataframe['macd']
+                )) &
+                (dataframe['fastd'] > 54)
+            ),
+            'sell'] = 1
+        return dataframe

freqtrade/optimize/edge_cli.py

@@ -0,0 +1,109 @@
+# pragma pylint: disable=missing-docstring, W0212, too-many-arguments
+
+"""
+This module contains the edge backtesting interface
+"""
+import logging
+from argparse import Namespace
+from typing import Dict, Any
+from tabulate import tabulate
+from freqtrade.edge import Edge
+
+from freqtrade.arguments import Arguments
+from freqtrade.configuration import Configuration
+from freqtrade.exchange import Exchange
+from freqtrade.resolvers import StrategyResolver
+from freqtrade.state import RunMode
+
+logger = logging.getLogger(__name__)
+
+
+class EdgeCli(object):
+    """
+    EdgeCli class, this class contains all the logic to run edge backtesting
+
+    To run a edge backtest:
+    edge = EdgeCli(config)
+    edge.start()
+    """
+
+    def __init__(self, config: Dict[str, Any]) -> None:
+        self.config = config
+
+        # Reset keys for edge
+        self.config['exchange']['key'] = ''
+        self.config['exchange']['secret'] = ''
+        self.config['exchange']['password'] = ''
+        self.config['exchange']['uid'] = ''
+        self.config['dry_run'] = True
+        self.exchange = Exchange(self.config)
+        self.strategy = StrategyResolver(self.config).strategy
+
+        self.edge = Edge(config, self.exchange, self.strategy)
+        self.edge._refresh_pairs = self.config.get('refresh_pairs', False)
+
+        self.timerange = Arguments.parse_timerange(None if self.config.get(
+            'timerange') is None else str(self.config.get('timerange')))
+
+        self.edge._timerange = self.timerange
+
+    def _generate_edge_table(self, results: dict) -> str:
+
+        floatfmt = ('s', '.10g', '.2f', '.2f', '.2f', '.2f', 'd', '.d')
+        tabular_data = []
+        headers = ['pair', 'stoploss', 'win rate', 'risk reward ratio',
+                   'required risk reward', 'expectancy', 'total number of trades',
+                   'average duration (min)']
+
+        for result in results.items():
+            if result[1].nb_trades > 0:
+                tabular_data.append([
+                    result[0],
+                    result[1].stoploss,
+                    result[1].winrate,
+                    result[1].risk_reward_ratio,
+                    result[1].required_risk_reward,
+                    result[1].expectancy,
+                    result[1].nb_trades,
+                    round(result[1].avg_trade_duration)
+                ])
+
+        # Ignore type as floatfmt does allow tuples but mypy does not know that
+        return tabulate(tabular_data, headers=headers,  # type: ignore
+                        floatfmt=floatfmt, tablefmt="pipe")
+
+    def start(self) -> None:
+        self.edge.calculate()
+        print('')  # blank like for readability
+        print(self._generate_edge_table(self.edge._cached_pairs))
+
+
+def setup_configuration(args: Namespace) -> Dict[str, Any]:
+    """
+    Prepare the configuration for edge backtesting
+    :param args: Cli args from Arguments()
+    :return: Configuration
+    """
+    configuration = Configuration(args, RunMode.EDGECLI)
+    config = configuration.get_config()
+
+    # Ensure we do not use Exchange credentials
+    config['exchange']['key'] = ''
+    config['exchange']['secret'] = ''
+
+    return config
+
+
+def start(args: Namespace) -> None:
+    """
+    Start Edge script
+    :param args: Cli args from Arguments()
+    :return: None
+    """
+    # Initialize configuration
+    config = setup_configuration(args)
+    logger.info('Starting freqtrade in Edge mode')
+
+    # Initialize Edge object
+    edge_cli = EdgeCli(config)
+    edge_cli.start()

freqtrade/optimize/hyperopt.py

@@ -0,0 +1,326 @@
+# pragma pylint: disable=too-many-instance-attributes, pointless-string-statement
+
+"""
+This module contains the hyperopt logic
+"""
+
+import logging
+import multiprocessing
+import os
+import sys
+from argparse import Namespace
+from math import exp
+from operator import itemgetter
+from pathlib import Path
+from pprint import pprint
+from typing import Any, Dict, List
+
+from joblib import Parallel, delayed, dump, load, wrap_non_picklable_objects
+from pandas import DataFrame
+from skopt import Optimizer
+from skopt.space import Dimension
+
+from freqtrade.arguments import Arguments
+from freqtrade.configuration import Configuration
+from freqtrade.data.history import load_data
+from freqtrade.optimize import get_timeframe
+from freqtrade.optimize.backtesting import Backtesting
+from freqtrade.state import RunMode
+from freqtrade.resolvers import HyperOptResolver
+
+logger = logging.getLogger(__name__)
+
+MAX_LOSS = 100000  # just a big enough number to be bad result in loss optimization
+TICKERDATA_PICKLE = os.path.join('user_data', 'hyperopt_tickerdata.pkl')
+
+
+class Hyperopt(Backtesting):
+    """
+    Hyperopt class, this class contains all the logic to run a hyperopt simulation
+
+    To run a backtest:
+    hyperopt = Hyperopt(config)
+    hyperopt.start()
+    """
+    def __init__(self, config: Dict[str, Any]) -> None:
+        super().__init__(config)
+        self.config = config
+        self.custom_hyperopt = HyperOptResolver(self.config).hyperopt
+
+        # set TARGET_TRADES to suit your number concurrent trades so its realistic
+        # to the number of days
+        self.target_trades = 600
+        self.total_tries = config.get('epochs', 0)
+        self.current_best_loss = 100
+
+        # max average trade duration in minutes
+        # if eval ends with higher value, we consider it a failed eval
+        self.max_accepted_trade_duration = 300
+
+        # this is expexted avg profit * expected trade count
+        # for example 3.5%, 1100 trades, self.expected_max_profit = 3.85
+        # check that the reported Σ% values do not exceed this!
+        self.expected_max_profit = 3.0
+
+        # Previous evaluations
+        self.trials_file = os.path.join('user_data', 'hyperopt_results.pickle')
+        self.trials: List = []
+
+    def get_args(self, params):
+        dimensions = self.hyperopt_space()
+        # Ensure the number of dimensions match
+        # the number of parameters in the list x.
+        if len(params) != len(dimensions):
+            raise ValueError('Mismatch in number of search-space dimensions. '
+                             f'len(dimensions)=={len(dimensions)} and len(x)=={len(params)}')
+
+        # Create a dict where the keys are the names of the dimensions
+        # and the values are taken from the list of parameters x.
+        arg_dict = {dim.name: value for dim, value in zip(dimensions, params)}
+        return arg_dict
+
+    def save_trials(self) -> None:
+        """
+        Save hyperopt trials to file
+        """
+        if self.trials:
+            logger.info('Saving %d evaluations to \'%s\'', len(self.trials), self.trials_file)
+            dump(self.trials, self.trials_file)
+
+    def read_trials(self) -> List:
+        """
+        Read hyperopt trials file
+        """
+        logger.info('Reading Trials from \'%s\'', self.trials_file)
+        trials = load(self.trials_file)
+        os.remove(self.trials_file)
+        return trials
+
+    def log_trials_result(self) -> None:
+        """
+        Display Best hyperopt result
+        """
+        results = sorted(self.trials, key=itemgetter('loss'))
+        best_result = results[0]
+        logger.info(
+            'Best result:\n%s\nwith values:\n',
+            best_result['result']
+        )
+        pprint(best_result['params'], indent=4)
+        if 'roi_t1' in best_result['params']:
+            logger.info('ROI table:')
+            pprint(self.custom_hyperopt.generate_roi_table(best_result['params']), indent=4)
+
+    def log_results(self, results) -> None:
+        """
+        Log results if it is better than any previous evaluation
+        """
+        if results['loss'] < self.current_best_loss:
+            current = results['current_tries']
+            total = results['total_tries']
+            res = results['result']
+            loss = results['loss']
+            self.current_best_loss = results['loss']
+            log_msg = f'\n{current:5d}/{total}: {res}. Loss {loss:.5f}'
+            print(log_msg)
+        else:
+            print('.', end='')
+            sys.stdout.flush()
+
+    def calculate_loss(self, total_profit: float, trade_count: int, trade_duration: float) -> float:
+        """
+        Objective function, returns smaller number for more optimal results
+        """
+        trade_loss = 1 - 0.25 * exp(-(trade_count - self.target_trades) ** 2 / 10 ** 5.8)
+        profit_loss = max(0, 1 - total_profit / self.expected_max_profit)
+        duration_loss = 0.4 * min(trade_duration / self.max_accepted_trade_duration, 1)
+        result = trade_loss + profit_loss + duration_loss
+        return result
+
+    def has_space(self, space: str) -> bool:
+        """
+        Tell if a space value is contained in the configuration
+        """
+        if space in self.config['spaces'] or 'all' in self.config['spaces']:
+            return True
+        return False
+
+    def hyperopt_space(self) -> List[Dimension]:
+        """
+        Return the space to use during Hyperopt
+        """
+        spaces: List[Dimension] = []
+        if self.has_space('buy'):
+            spaces += self.custom_hyperopt.indicator_space()
+        if self.has_space('sell'):
+            spaces += self.custom_hyperopt.sell_indicator_space()
+            # Make sure experimental is enabled
+            if 'experimental' not in self.config:
+                self.config['experimental'] = {}
+            self.config['experimental']['use_sell_signal'] = True
+        if self.has_space('roi'):
+            spaces += self.custom_hyperopt.roi_space()
+        if self.has_space('stoploss'):
+            spaces += self.custom_hyperopt.stoploss_space()
+        return spaces
+
+    def generate_optimizer(self, _params: Dict) -> Dict:
+        params = self.get_args(_params)
+        if self.has_space('roi'):
+            self.strategy.minimal_roi = self.custom_hyperopt.generate_roi_table(params)
+
+        if self.has_space('buy'):
+            self.advise_buy = self.custom_hyperopt.buy_strategy_generator(params)
+        elif hasattr(self.custom_hyperopt, 'populate_buy_trend'):
+            self.advise_buy = self.custom_hyperopt.populate_buy_trend  # type: ignore
+
+        if self.has_space('sell'):
+            self.advise_sell = self.custom_hyperopt.sell_strategy_generator(params)
+        elif hasattr(self.custom_hyperopt, 'populate_sell_trend'):
+            self.advise_sell = self.custom_hyperopt.populate_sell_trend  # type: ignore
+
+        if self.has_space('stoploss'):
+            self.strategy.stoploss = params['stoploss']
+
+        processed = load(TICKERDATA_PICKLE)
+        min_date, max_date = get_timeframe(processed)
+        results = self.backtest(
+            {
+                'stake_amount': self.config['stake_amount'],
+                'processed': processed,
+                'position_stacking': self.config.get('position_stacking', True),
+                'start_date': min_date,
+                'end_date': max_date,
+            }
+        )
+        result_explanation = self.format_results(results)
+
+        total_profit = results.profit_percent.sum()
+        trade_count = len(results.index)
+        trade_duration = results.trade_duration.mean()
+
+        if trade_count == 0:
+            return {
+                'loss': MAX_LOSS,
+                'params': params,
+                'result': result_explanation,
+            }
+
+        loss = self.calculate_loss(total_profit, trade_count, trade_duration)
+
+        return {
+            'loss': loss,
+            'params': params,
+            'result': result_explanation,
+        }
+
+    def format_results(self, results: DataFrame) -> str:
+        """
+        Return the format result in a string
+        """
+        trades = len(results.index)
+        avg_profit = results.profit_percent.mean() * 100.0
+        total_profit = results.profit_abs.sum()
+        stake_cur = self.config['stake_currency']
+        profit = results.profit_percent.sum()
+        duration = results.trade_duration.mean()
+
+        return (f'{trades:6d} trades. Avg profit {avg_profit: 5.2f}%. '
+                f'Total profit {total_profit: 11.8f} {stake_cur} '
+                f'({profit:.4f}Σ%). Avg duration {duration:5.1f} mins.')
+
+    def get_optimizer(self, cpu_count) -> Optimizer:
+        return Optimizer(
+            self.hyperopt_space(),
+            base_estimator="ET",
+            acq_optimizer="auto",
+            n_initial_points=30,
+            acq_optimizer_kwargs={'n_jobs': cpu_count}
+        )
+
+    def run_optimizer_parallel(self, parallel, asked) -> List:
+        return parallel(delayed(
+                        wrap_non_picklable_objects(self.generate_optimizer))(v) for v in asked)
+
+    def load_previous_results(self):
+        """ read trials file if we have one """
+        if os.path.exists(self.trials_file) and os.path.getsize(self.trials_file) > 0:
+            self.trials = self.read_trials()
+            logger.info(
+                'Loaded %d previous evaluations from disk.',
+                len(self.trials)
+            )
+
+    def start(self) -> None:
+        timerange = Arguments.parse_timerange(None if self.config.get(
+            'timerange') is None else str(self.config.get('timerange')))
+        data = load_data(
+            datadir=Path(self.config['datadir']) if self.config.get('datadir') else None,
+            pairs=self.config['exchange']['pair_whitelist'],
+            ticker_interval=self.ticker_interval,
+            timerange=timerange
+        )
+
+        if self.has_space('buy') or self.has_space('sell'):
+            self.strategy.advise_indicators = \
+                self.custom_hyperopt.populate_indicators  # type: ignore
+        dump(self.strategy.tickerdata_to_dataframe(data), TICKERDATA_PICKLE)
+        self.exchange = None  # type: ignore
+        self.load_previous_results()
+
+        cpus = multiprocessing.cpu_count()
+        logger.info(f'Found {cpus} CPU cores. Let\'s make them scream!')
+
+        opt = self.get_optimizer(cpus)
+        EVALS = max(self.total_tries // cpus, 1)
+        try:
+            with Parallel(n_jobs=cpus) as parallel:
+                for i in range(EVALS):
+                    asked = opt.ask(n_points=cpus)
+                    f_val = self.run_optimizer_parallel(parallel, asked)
+                    opt.tell(asked, [i['loss'] for i in f_val])
+
+                    self.trials += f_val
+                    for j in range(cpus):
+                        self.log_results({
+                            'loss': f_val[j]['loss'],
+                            'current_tries': i * cpus + j,
+                            'total_tries': self.total_tries,
+                            'result': f_val[j]['result'],
+                        })
+        except KeyboardInterrupt:
+            print('User interrupted..')
+
+        self.save_trials()
+        self.log_trials_result()
+
+
+def start(args: Namespace) -> None:
+    """
+    Start Backtesting script
+    :param args: Cli args from Arguments()
+    :return: None
+    """
+
+    # Remove noisy log messages
+    logging.getLogger('hyperopt.tpe').setLevel(logging.WARNING)
+
+    # Initialize configuration
+    # Monkey patch the configuration with hyperopt_conf.py
+    configuration = Configuration(args, RunMode.HYPEROPT)
+    logger.info('Starting freqtrade in Hyperopt mode')
+    config = configuration.load_config()
+
+    config['exchange']['key'] = ''
+    config['exchange']['secret'] = ''
+
+    if config.get('strategy') and config.get('strategy') != 'DefaultStrategy':
+        logger.error("Please don't use --strategy for hyperopt.")
+        logger.error(
+            "Read the documentation at "
+            "https://github.com/freqtrade/freqtrade/blob/develop/docs/hyperopt.md "
+            "to understand how to configure hyperopt.")
+        raise ValueError("--strategy configured but not supported for hyperopt")
+    # Initialize backtesting object
+    hyperopt = Hyperopt(config)
+    hyperopt.start()

freqtrade/optimize/hyperopt_interface.py

@@ -0,0 +1,80 @@
+"""
+IHyperOpt interface
+This module defines the interface to apply for hyperopts
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Callable, List
+
+from pandas import DataFrame
+from skopt.space import Dimension
+
+
+class IHyperOpt(ABC):
+    """
+    Interface for freqtrade hyperopts
+    Defines the mandatory structure must follow any custom strategies
+
+    Attributes you can use:
+        minimal_roi -> Dict: Minimal ROI designed for the strategy
+        stoploss -> float: optimal stoploss designed for the strategy
+        ticker_interval -> int: value of the ticker interval to use for the strategy
+    """
+
+    @staticmethod
+    @abstractmethod
+    def populate_indicators(dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Populate indicators that will be used in the Buy and Sell strategy
+        :param dataframe: Raw data from the exchange and parsed by parse_ticker_dataframe()
+        :return: a Dataframe with all mandatory indicators for the strategies
+        """
+
+    @staticmethod
+    @abstractmethod
+    def buy_strategy_generator(params: Dict[str, Any]) -> Callable:
+        """
+        Create a buy strategy generator
+        """
+
+    @staticmethod
+    @abstractmethod
+    def sell_strategy_generator(params: Dict[str, Any]) -> Callable:
+        """
+        Create a sell strategy generator
+        """
+
+    @staticmethod
+    @abstractmethod
+    def indicator_space() -> List[Dimension]:
+        """
+        Create an indicator space
+        """
+
+    @staticmethod
+    @abstractmethod
+    def sell_indicator_space() -> List[Dimension]:
+        """
+        Create a sell indicator space
+        """
+
+    @staticmethod
+    @abstractmethod
+    def generate_roi_table(params: Dict) -> Dict[int, float]:
+        """
+        Create an roi table
+        """
+
+    @staticmethod
+    @abstractmethod
+    def stoploss_space() -> List[Dimension]:
+        """
+        Create a stoploss space
+        """
+
+    @staticmethod
+    @abstractmethod
+    def roi_space() -> List[Dimension]:
+        """
+        Create a roi space
+        """

freqtrade/pairlist/IPairList.py

@@ -0,0 +1,86 @@
+"""
+Static List provider
+
+Provides lists as configured in config.json
+
+ """
+import logging
+from abc import ABC, abstractmethod
+from typing import List
+
+logger = logging.getLogger(__name__)
+
+
+class IPairList(ABC):
+
+    def __init__(self, freqtrade, config: dict) -> None:
+        self._freqtrade = freqtrade
+        self._config = config
+        self._whitelist = self._config['exchange']['pair_whitelist']
+        self._blacklist = self._config['exchange'].get('pair_blacklist', [])
+
+    @property
+    def name(self) -> str:
+        """
+        Gets name of the class
+        -> no need to overwrite in subclasses
+        """
+        return self.__class__.__name__
+
+    @property
+    def whitelist(self) -> List[str]:
+        """
+        Has the current whitelist
+        -> no need to overwrite in subclasses
+        """
+        return self._whitelist
+
+    @property
+    def blacklist(self) -> List[str]:
+        """
+        Has the current blacklist
+        -> no need to overwrite in subclasses
+        """
+        return self._blacklist
+
+    @abstractmethod
+    def short_desc(self) -> str:
+        """
+        Short whitelist method description - used for startup-messages
+        -> Please overwrite in subclasses
+        """
+
+    @abstractmethod
+    def refresh_pairlist(self) -> None:
+        """
+        Refreshes pairlists and assigns them to self._whitelist and self._blacklist respectively
+        -> Please overwrite in subclasses
+        """
+
+    def _validate_whitelist(self, whitelist: List[str]) -> List[str]:
+        """
+        Check available markets and remove pair from whitelist if necessary
+        :param whitelist: the sorted list of pairs the user might want to trade
+        :return: the list of pairs the user wants to trade without those unavailable or
+        black_listed
+        """
+        markets = self._freqtrade.exchange.markets
+
+        sanitized_whitelist = set()
+        for pair in whitelist:
+            # pair is not in the generated dynamic market, or in the blacklist ... ignore it
+            if (pair in self.blacklist or pair not in markets
+                    or not pair.endswith(self._config['stake_currency'])):
+                logger.warning(f"Pair {pair} is not compatible with exchange "
+                               f"{self._freqtrade.exchange.name} or contained in "
+                               f"your blacklist. Removing it from whitelist..")
+                continue
+            # Check if market is active
+            market = markets[pair]
+            if not market['active']:
+                logger.info(f"Ignoring {pair} from whitelist. Market is not active.")
+                continue
+            sanitized_whitelist.add(pair)
+
+        # We need to remove pairs that are unknown
+        return list(sanitized_whitelist)

freqtrade/pairlist/StaticPairList.py

@@ -0,0 +1,30 @@
+"""
+Static List provider
+
+Provides lists as configured in config.json
+
+ """
+import logging
+
+from freqtrade.pairlist.IPairList import IPairList
+
+logger = logging.getLogger(__name__)
+
+
+class StaticPairList(IPairList):
+
+    def __init__(self, freqtrade, config: dict) -> None:
+        super().__init__(freqtrade, config)
+
+    def short_desc(self) -> str:
+        """
+        Short whitelist method description - used for startup-messages
+        -> Please overwrite in subclasses
+        """
+        return f"{self.name}: {self.whitelist}"
+
+    def refresh_pairlist(self) -> None:
+        """
+        Refreshes pairlists and assigns them to self._whitelist and self._blacklist respectively
+        """
+        self._whitelist = self._validate_whitelist(self._config['exchange']['pair_whitelist'])

freqtrade/pairlist/VolumePairList.py

@@ -0,0 +1,95 @@
+"""
+Volume PairList provider
+
+Provides lists as configured in config.json
+
+ """
+import logging
+from typing import List
+from cachetools import TTLCache, cached
+
+from freqtrade.pairlist.IPairList import IPairList
+from freqtrade import OperationalException
+logger = logging.getLogger(__name__)
+
+SORT_VALUES = ['askVolume', 'bidVolume', 'quoteVolume']
+
+
+class VolumePairList(IPairList):
+
+    def __init__(self, freqtrade, config: dict) -> None:
+        super().__init__(freqtrade, config)
+        self._whitelistconf = self._config.get('pairlist', {}).get('config')
+        if 'number_assets' not in self._whitelistconf:
+            raise OperationalException(
+                f'`number_assets` not specified. Please check your configuration '
+                'for "pairlist.config.number_assets"')
+        self._number_pairs = self._whitelistconf['number_assets']
+        self._sort_key = self._whitelistconf.get('sort_key', 'quoteVolume')
+        self._precision_filter = self._whitelistconf.get('precision_filter', False)
+
+        if not self._freqtrade.exchange.exchange_has('fetchTickers'):
+            raise OperationalException(
+                'Exchange does not support dynamic whitelist.'
+                'Please edit your config and restart the bot'
+            )
+        if not self._validate_keys(self._sort_key):
+            raise OperationalException(
+                f'key {self._sort_key} not in {SORT_VALUES}')
+
+    def _validate_keys(self, key):
+        return key in SORT_VALUES
+
+    def short_desc(self) -> str:
+        """
+        Short whitelist method description - used for startup-messages
+        -> Please overwrite in subclasses
+        """
+        return f"{self.name} - top {self._whitelistconf['number_assets']} volume pairs."
+
+    def refresh_pairlist(self) -> None:
+        """
+        Refreshes pairlists and assigns them to self._whitelist and self._blacklist respectively
+        -> Please overwrite in subclasses
+        """
+        # Generate dynamic whitelist
+        self._whitelist = self._gen_pair_whitelist(
+            self._config['stake_currency'], self._sort_key)[:self._number_pairs]
+        logger.info(f"Searching pairs: {self._whitelist}")
+
+    @cached(TTLCache(maxsize=1, ttl=1800))
+    def _gen_pair_whitelist(self, base_currency: str, key: str) -> List[str]:
+        """
+        Updates the whitelist with with a dynamically generated list
+        :param base_currency: base currency as str
+        :param key: sort key (defaults to 'quoteVolume')
+        :return: List of pairs
+        """
+
+        tickers = self._freqtrade.exchange.get_tickers()
+        # check length so that we make sure that '/' is actually in the string
+        tickers = [v for k, v in tickers.items()
+                   if (len(k.split('/')) == 2 and k.split('/')[1] == base_currency
+                       and v[key] is not None)]
+        sorted_tickers = sorted(tickers, reverse=True, key=lambda t: t[key])
+        # Validate whitelist to only have active market pairs
+        valid_pairs = self._validate_whitelist([s['symbol'] for s in sorted_tickers])
+        valid_tickers = [t for t in sorted_tickers if t["symbol"] in valid_pairs]
+
+        if self._freqtrade.strategy.stoploss is not None and self._precision_filter:
+
+            stop_prices = [self._freqtrade.get_target_bid(t["symbol"], t)
+                           * (1 - abs(self._freqtrade.strategy.stoploss)) for t in valid_tickers]
+            rates = [sp * 0.99 for sp in stop_prices]
+            logger.debug("\n".join([f"{sp} : {r}" for sp, r in zip(stop_prices[:10], rates[:10])]))
+            for i, t in enumerate(valid_tickers):
+                sp = self._freqtrade.exchange.symbol_price_prec(t["symbol"], stop_prices[i])
+                r = self._freqtrade.exchange.symbol_price_prec(t["symbol"], rates[i])
+                logger.debug(f"{t['symbol']} - {sp} : {r}")
+                if sp <= r:
+                    logger.info(f"Removed {t['symbol']} from whitelist, "
+                                f"because stop price {sp} would be <= stop limit {r}")
+                    valid_tickers.remove(t)
+
+        pairs = [s['symbol'] for s in valid_tickers]
+        return pairs

freqtrade/persistence.py

@@ -1,47 +1,149 @@
+"""
+This module contains the class to persist trades into SQLite
+"""
+
 import logging
 from datetime import datetime
-from decimal import Decimal, getcontext
-from typing import Optional, Dict
+from decimal import Decimal
+from typing import Any, Dict, List, Optional
 
 import arrow
-from sqlalchemy import Boolean, Column, DateTime, Float, Integer, String, create_engine
-from sqlalchemy.engine import Engine
+from sqlalchemy import (Boolean, Column, DateTime, Float, Integer, String,
+                        create_engine, inspect)
+from sqlalchemy.exc import NoSuchModuleError
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm.scoping import scoped_session
 from sqlalchemy.orm.session import sessionmaker
+from sqlalchemy import func
 from sqlalchemy.pool import StaticPool
 
-logging.basicConfig(level=logging.DEBUG,
-                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+from freqtrade import OperationalException
+
 logger = logging.getLogger(__name__)
 
-_CONF = {}
-_DECL_BASE = declarative_base()
+_DECL_BASE: Any = declarative_base()
+_SQL_DOCS_URL = 'http://docs.sqlalchemy.org/en/latest/core/engines.html#database-urls'
 
 
-def init(config: dict, engine: Optional[Engine] = None) -> None:
+def init(config: Dict) -> None:
     """
     Initializes this module with the given config,
     registers all known command handlers
     and starts polling for message updates
     :param config: config to use
-    :param engine: database engine for sqlalchemy (Optional)
     :return: None
     """
-    _CONF.update(config)
-    if not engine:
-        if _CONF.get('dry_run', False):
-            engine = create_engine('sqlite://',
-                                   connect_args={'check_same_thread': False},
-                                   poolclass=StaticPool,
-                                   echo=False)
-        else:
-            engine = create_engine('sqlite:///tradesv3.sqlite')
+    db_url = config.get('db_url', None)
+    kwargs = {}
+
+    # Take care of thread ownership if in-memory db
+    if db_url == 'sqlite://':
+        kwargs.update({
+            'connect_args': {'check_same_thread': False},
+            'poolclass': StaticPool,
+            'echo': False,
+        })
+
+    try:
+        engine = create_engine(db_url, **kwargs)
+    except NoSuchModuleError:
+        raise OperationalException(f'Given value for db_url: \'{db_url}\' '
+                                   f'is no valid database URL! (See {_SQL_DOCS_URL})')
 
     session = scoped_session(sessionmaker(bind=engine, autoflush=True, autocommit=True))
     Trade.session = session()
     Trade.query = session.query_property()
     _DECL_BASE.metadata.create_all(engine)
+    check_migrate(engine)
+
+    # Clean dry_run DB if the db is not in-memory
+    if config.get('dry_run', False) and db_url != 'sqlite://':
+        clean_dry_run_db()
+
+
+def has_column(columns, searchname: str) -> bool:
+    return len(list(filter(lambda x: x["name"] == searchname, columns))) == 1
+
+
+def get_column_def(columns, column: str, default: str) -> str:
+    return default if not has_column(columns, column) else column
+
+
+def check_migrate(engine) -> None:
+    """
+    Checks if migration is necessary and migrates if necessary
+    """
+    inspector = inspect(engine)
+
+    cols = inspector.get_columns('trades')
+    tabs = inspector.get_table_names()
+    table_back_name = 'trades_bak'
+    for i, table_back_name in enumerate(tabs):
+        table_back_name = f'trades_bak{i}'
+        logger.debug(f'trying {table_back_name}')
+
+    # Check for latest column
+    if not has_column(cols, 'stop_loss_pct'):
+        logger.info(f'Running database migration - backup available as {table_back_name}')
+
+        fee_open = get_column_def(cols, 'fee_open', 'fee')
+        fee_close = get_column_def(cols, 'fee_close', 'fee')
+        open_rate_requested = get_column_def(cols, 'open_rate_requested', 'null')
+        close_rate_requested = get_column_def(cols, 'close_rate_requested', 'null')
+        stop_loss = get_column_def(cols, 'stop_loss', '0.0')
+        stop_loss_pct = get_column_def(cols, 'stop_loss_pct', 'null')
+        initial_stop_loss = get_column_def(cols, 'initial_stop_loss', '0.0')
+        initial_stop_loss_pct = get_column_def(cols, 'initial_stop_loss_pct', 'null')
+        stoploss_order_id = get_column_def(cols, 'stoploss_order_id', 'null')
+        stoploss_last_update = get_column_def(cols, 'stoploss_last_update', 'null')
+        max_rate = get_column_def(cols, 'max_rate', '0.0')
+        min_rate = get_column_def(cols, 'min_rate', 'null')
+        sell_reason = get_column_def(cols, 'sell_reason', 'null')
+        strategy = get_column_def(cols, 'strategy', 'null')
+        ticker_interval = get_column_def(cols, 'ticker_interval', 'null')
+
+        # Schema migration necessary
+        engine.execute(f"alter table trades rename to {table_back_name}")
+        # drop indexes on backup table
+        for index in inspector.get_indexes(table_back_name):
+            engine.execute(f"drop index {index['name']}")
+        # let SQLAlchemy create the schema as required
+        _DECL_BASE.metadata.create_all(engine)
+
+        # Copy data back - following the correct schema
+        engine.execute(f"""insert into trades
+                (id, exchange, pair, is_open, fee_open, fee_close, open_rate,
+                open_rate_requested, close_rate, close_rate_requested, close_profit,
+                stake_amount, amount, open_date, close_date, open_order_id,
+                stop_loss, stop_loss_pct, initial_stop_loss, initial_stop_loss_pct,
+                stoploss_order_id, stoploss_last_update,
+                max_rate, min_rate, sell_reason, strategy,
+                ticker_interval
+                )
+            select id, lower(exchange),
+                case
+                    when instr(pair, '_') != 0 then
+                    substr(pair,    instr(pair, '_') + 1) || '/' ||
+                    substr(pair, 1, instr(pair, '_') - 1)
+                    else pair
+                    end
+                pair,
+                is_open, {fee_open} fee_open, {fee_close} fee_close,
+                open_rate, {open_rate_requested} open_rate_requested, close_rate,
+                {close_rate_requested} close_rate_requested, close_profit,
+                stake_amount, amount, open_date, close_date, open_order_id,
+                {stop_loss} stop_loss, {stop_loss_pct} stop_loss_pct,
+                {initial_stop_loss} initial_stop_loss,
+                {initial_stop_loss_pct} initial_stop_loss_pct,
+                {stoploss_order_id} stoploss_order_id, {stoploss_last_update} stoploss_last_update,
+                {max_rate} max_rate, {min_rate} min_rate, {sell_reason} sell_reason,
+                {strategy} strategy, {ticker_interval} ticker_interval
+                from {table_back_name}
+             """)
+
+        # Reread columns - the above recreated the table!
+        inspector = inspect(engine)
+        cols = inspector.get_columns('trades')
 
 
 def cleanup() -> None:
@@ -52,31 +154,115 @@ def cleanup() -> None:
     Trade.session.flush()
 
 
+def clean_dry_run_db() -> None:
+    """
+    Remove open_order_id from a Dry_run DB
+    :return: None
+    """
+    for trade in Trade.query.filter(Trade.open_order_id.isnot(None)).all():
+        # Check we are updating only a dry_run order not a prod one
+        if 'dry_run' in trade.open_order_id:
+            trade.open_order_id = None
+
+
 class Trade(_DECL_BASE):
+    """
+    Class used to define a trade structure
+    """
     __tablename__ = 'trades'
 
     id = Column(Integer, primary_key=True)
     exchange = Column(String, nullable=False)
-    pair = Column(String, nullable=False)
-    is_open = Column(Boolean, nullable=False, default=True)
-    fee = Column(Float, nullable=False, default=0.0)
+    pair = Column(String, nullable=False, index=True)
+    is_open = Column(Boolean, nullable=False, default=True, index=True)
+    fee_open = Column(Float, nullable=False, default=0.0)
+    fee_close = Column(Float, nullable=False, default=0.0)
     open_rate = Column(Float)
+    open_rate_requested = Column(Float)
     close_rate = Column(Float)
+    close_rate_requested = Column(Float)
     close_profit = Column(Float)
     stake_amount = Column(Float, nullable=False)
     amount = Column(Float)
     open_date = Column(DateTime, nullable=False, default=datetime.utcnow)
     close_date = Column(DateTime)
     open_order_id = Column(String)
+    # absolute value of the stop loss
+    stop_loss = Column(Float, nullable=True, default=0.0)
+    # percentage value of the stop loss
+    stop_loss_pct = Column(Float, nullable=True)
+    # absolute value of the initial stop loss
+    initial_stop_loss = Column(Float, nullable=True, default=0.0)
+    # percentage value of the initial stop loss
+    initial_stop_loss_pct = Column(Float, nullable=True)
+    # stoploss order id which is on exchange
+    stoploss_order_id = Column(String, nullable=True, index=True)
+    # last update time of the stoploss order on exchange
+    stoploss_last_update = Column(DateTime, nullable=True)
+    # absolute value of the highest reached price
+    max_rate = Column(Float, nullable=True, default=0.0)
+    # Lowest price reached
+    min_rate = Column(Float, nullable=True)
+    sell_reason = Column(String, nullable=True)
+    strategy = Column(String, nullable=True)
+    ticker_interval = Column(Integer, nullable=True)
 
     def __repr__(self):
-        return 'Trade(id={}, pair={}, amount={}, open_rate={}, open_since={})'.format(
-            self.id,
-            self.pair,
-            self.amount,
-            self.open_rate,
-            arrow.get(self.open_date).humanize() if self.is_open else 'closed'
-        )
+        open_since = arrow.get(self.open_date).humanize() if self.is_open else 'closed'
+
+        return (f'Trade(id={self.id}, pair={self.pair}, amount={self.amount:.8f}, '
+                f'open_rate={self.open_rate:.8f}, open_since={open_since})')
+
+    def adjust_min_max_rates(self, current_price: float):
+        """
+        Adjust the max_rate and min_rate.
+        """
+        logger.debug("Adjusting min/max rates")
+        self.max_rate = max(current_price, self.max_rate or self.open_rate)
+        self.min_rate = min(current_price, self.min_rate or self.open_rate)
+
+    def adjust_stop_loss(self, current_price: float, stoploss: float, initial: bool = False):
+        """
+        This adjusts the stop loss to it's most recently observed setting
+        :param current_price: Current rate the asset is traded
+        :param stoploss: Stoploss as factor (sample -0.05 -> -5% below current price).
+        :param initial: Called to initiate stop_loss.
+            Skips everything if self.stop_loss is already set.
+        """
+
+        if initial and not (self.stop_loss is None or self.stop_loss == 0):
+            # Don't modify if called with initial and nothing to do
+            return
+
+        new_loss = float(current_price * (1 - abs(stoploss)))
+
+        # no stop loss assigned yet
+        if not self.stop_loss:
+            logger.debug("assigning new stop loss")
+            self.stop_loss = new_loss
+            self.stop_loss_pct = -1 * abs(stoploss)
+            self.initial_stop_loss = new_loss
+            self.initial_stop_loss_pct = -1 * abs(stoploss)
+            self.stoploss_last_update = datetime.utcnow()
+
+        # evaluate if the stop loss needs to be updated
+        else:
+            if new_loss > self.stop_loss:  # stop losses only walk up, never down!
+                self.stop_loss = new_loss
+                self.stop_loss_pct = -1 * abs(stoploss)
+                self.stoploss_last_update = datetime.utcnow()
+                logger.debug("adjusted stop loss")
+            else:
+                logger.debug("keeping current stop loss")
+
+        logger.debug(
+            f"{self.pair} - current price {current_price:.8f}, "
+            f"bought at {self.open_rate:.8f} and calculated "
+            f"stop loss is at: {self.initial_stop_loss:.8f} initial "
+            f"stop at {self.stop_loss:.8f}. "
+            f"trailing stop loss saved us: "
+            f"{float(self.stop_loss) - float(self.initial_stop_loss):.8f} "
+            f"and max observed rate was {self.max_rate:.8f}")
 
     def update(self, order: Dict) -> None:
         """
@@ -84,31 +270,134 @@ class Trade(_DECL_BASE):
         :param order: order retrieved by exchange.get_order()
         :return: None
         """
-        if not order['closed']:
+        order_type = order['type']
+        # Ignore open and cancelled orders
+        if order['status'] == 'open' or order['price'] is None:
             return
 
-        logger.debug('Updating trade (id=%d) ...', self.id)
-        if order['type'] == 'LIMIT_BUY':
+        logger.info('Updating trade (id=%s) ...', self.id)
+
+        if order_type in ('market', 'limit') and order['side'] == 'buy':
             # Update open rate and actual amount
-            self.open_rate = order['rate']
-            self.amount = order['amount']
-        elif order['type'] == 'LIMIT_SELL':
-            # Set close rate and set actual profit
-            self.close_rate = order['rate']
-            self.close_profit = self.calc_profit()
-            self.close_date = datetime.utcnow()
+            self.open_rate = Decimal(order['price'])
+            self.amount = Decimal(order['amount'])
+            logger.info('%s_BUY has been fulfilled for %s.', order_type.upper(), self)
+            self.open_order_id = None
+        elif order_type in ('market', 'limit') and order['side'] == 'sell':
+            self.close(order['price'])
+            logger.info('%s_SELL has been fulfilled for %s.', order_type.upper(), self)
+        elif order_type == 'stop_loss_limit':
+            self.stoploss_order_id = None
+            self.close_rate_requested = self.stop_loss
+            logger.info('STOP_LOSS_LIMIT is hit for %s.', self)
+            self.close(order['average'])
         else:
-            raise ValueError('Unknown order type: {}'.format(order['type']))
+            raise ValueError(f'Unknown order type: {order_type}')
+        cleanup()
 
+    def close(self, rate: float) -> None:
+        """
+        Sets close_rate to the given rate, calculates total profit
+        and marks trade as closed
+        """
+        self.close_rate = Decimal(rate)
+        self.close_profit = self.calc_profit_percent()
+        self.close_date = datetime.utcnow()
+        self.is_open = False
         self.open_order_id = None
+        logger.info(
+            'Marking %s as closed as the trade is fulfilled and found no open orders for it.',
+            self
+        )
 
-    def calc_profit(self, rate: Optional[float] = None) -> float:
+    def calc_open_trade_price(
+            self,
+            fee: Optional[float] = None) -> float:
+        """
+        Calculate the open_rate including fee.
+        :param fee: fee to use on the open rate (optional).
+        If rate is not set self.fee will be used
+        :return: Price in of the open trade incl. Fees
+        """
+
+        buy_trade = (Decimal(self.amount) * Decimal(self.open_rate))
+        fees = buy_trade * Decimal(fee or self.fee_open)
+        return float(buy_trade + fees)
+
+    def calc_close_trade_price(
+            self,
+            rate: Optional[float] = None,
+            fee: Optional[float] = None) -> float:
+        """
+        Calculate the close_rate including fee
+        :param fee: fee to use on the close rate (optional).
+        If rate is not set self.fee will be used
+        :param rate: rate to compare with (optional).
+        If rate is not set self.close_rate will be used
+        :return: Price in BTC of the open trade
+        """
+
+        if rate is None and not self.close_rate:
+            return 0.0
+
+        sell_trade = (Decimal(self.amount) * Decimal(rate or self.close_rate))
+        fees = sell_trade * Decimal(fee or self.fee_close)
+        return float(sell_trade - fees)
+
+    def calc_profit(
+            self,
+            rate: Optional[float] = None,
+            fee: Optional[float] = None) -> float:
+        """
+        Calculate the absolute profit in stake currency between Close and Open trade
+        :param fee: fee to use on the close rate (optional).
+        If rate is not set self.fee will be used
+        :param rate: close rate to compare with (optional).
+        If rate is not set self.close_rate will be used
+        :return:  profit in stake currency as float
+        """
+        open_trade_price = self.calc_open_trade_price()
+        close_trade_price = self.calc_close_trade_price(
+            rate=(rate or self.close_rate),
+            fee=(fee or self.fee_close)
+        )
+        profit = close_trade_price - open_trade_price
+        return float(f"{profit:.8f}")
+
+    def calc_profit_percent(
+            self,
+            rate: Optional[float] = None,
+            fee: Optional[float] = None) -> float:
         """
         Calculates the profit in percentage (including fee).
         :param rate: rate to compare with (optional).
         If rate is not set self.close_rate will be used
+        :param fee: fee to use on the close rate (optional).
         :return: profit in percentage as float
         """
-        getcontext().prec = 8
-        return float((Decimal(rate or self.close_rate) - Decimal(self.open_rate))
-                     / Decimal(self.open_rate) - Decimal(self.fee))
+
+        open_trade_price = self.calc_open_trade_price()
+        close_trade_price = self.calc_close_trade_price(
+            rate=(rate or self.close_rate),
+            fee=(fee or self.fee_close)
+        )
+        profit_percent = (close_trade_price / open_trade_price) - 1
+        return float(f"{profit_percent:.8f}")
+
+    @staticmethod
+    def total_open_trades_stakes() -> float:
+        """
+        Calculates total invested amount in open trades
+        in stake currency
+        """
+        total_open_stake_amount = Trade.session.query(func.sum(Trade.stake_amount))\
+            .filter(Trade.is_open.is_(True))\
+            .scalar()
+        return total_open_stake_amount or 0
+
+    @staticmethod
+    def get_open_trades() -> List[Any]:
+        """
+        Query trades from persistence layer
+        """
+        return Trade.query.filter(Trade.is_open.is_(True)).all()

freqtrade/resolvers/__init__.py

@@ -0,0 +1,5 @@
+from freqtrade.resolvers.iresolver import IResolver  # noqa: F401
+from freqtrade.resolvers.exchange_resolver import ExchangeResolver  # noqa: F401
+from freqtrade.resolvers.hyperopt_resolver import HyperOptResolver  # noqa: F401
+from freqtrade.resolvers.pairlist_resolver import PairListResolver  # noqa: F401
+from freqtrade.resolvers.strategy_resolver import StrategyResolver  # noqa: F401

freqtrade/resolvers/exchange_resolver.py

@@ -0,0 +1,55 @@
+"""
+This module loads custom exchanges
+"""
+import logging
+
+from freqtrade.exchange import Exchange
+import freqtrade.exchange as exchanges
+from freqtrade.resolvers import IResolver
+
+logger = logging.getLogger(__name__)
+
+
+class ExchangeResolver(IResolver):
+    """
+    This class contains all the logic to load a custom exchange class
+    """
+
+    __slots__ = ['exchange']
+
+    def __init__(self, exchange_name: str, config: dict) -> None:
+        """
+        Load the custom class from config parameter
+        :param config: configuration dictionary
+        """
+        try:
+            self.exchange = self._load_exchange(exchange_name, kwargs={'config': config})
+        except ImportError:
+            logger.info(
+                f"No {exchange_name} specific subclass found. Using the generic class instead.")
+            self.exchange = Exchange(config)
+
+    def _load_exchange(
+            self, exchange_name: str, kwargs: dict) -> Exchange:
+        """
+        Loads the specified exchange.
+        Only checks for exchanges exported in freqtrade.exchanges
+        :param exchange_name: name of the module to import
+        :return: Exchange instance or None
+        """
+
+        try:
+            ex_class = getattr(exchanges, exchange_name)
+
+            exchange = ex_class(kwargs['config'])
+            if exchange:
+                logger.info("Using resolved exchange %s", exchange_name)
+                return exchange
+        except AttributeError:
+            # Pass and raise ImportError instead
+            pass
+
+        raise ImportError(
+            "Impossible to load Exchange '{}'. This class does not exist"
+            " or contains Python code errors".format(exchange_name)
+        )

freqtrade/resolvers/hyperopt_resolver.py

@@ -0,0 +1,74 @@
+# pragma pylint: disable=attribute-defined-outside-init
+
+"""
+This module load custom hyperopts
+"""
+import logging
+from pathlib import Path
+from typing import Optional, Dict
+
+from freqtrade.constants import DEFAULT_HYPEROPT
+from freqtrade.optimize.hyperopt_interface import IHyperOpt
+from freqtrade.resolvers import IResolver
+
+logger = logging.getLogger(__name__)
+
+
+class HyperOptResolver(IResolver):
+    """
+    This class contains all the logic to load custom hyperopt class
+    """
+
+    __slots__ = ['hyperopt']
+
+    def __init__(self, config: Optional[Dict] = None) -> None:
+        """
+        Load the custom class from config parameter
+        :param config: configuration dictionary or None
+        """
+        config = config or {}
+
+        # Verify the hyperopt is in the configuration, otherwise fallback to the default hyperopt
+        hyperopt_name = config.get('hyperopt') or DEFAULT_HYPEROPT
+        self.hyperopt = self._load_hyperopt(hyperopt_name, extra_dir=config.get('hyperopt_path'))
+
+        if not hasattr(self.hyperopt, 'populate_buy_trend'):
+            logger.warning("Custom Hyperopt does not provide populate_buy_trend. "
+                           "Using populate_buy_trend from DefaultStrategy.")
+        if not hasattr(self.hyperopt, 'populate_sell_trend'):
+            logger.warning("Custom Hyperopt does not provide populate_sell_trend. "
+                           "Using populate_sell_trend from DefaultStrategy.")
+
+    def _load_hyperopt(
+            self, hyperopt_name: str, extra_dir: Optional[str] = None) -> IHyperOpt:
+        """
+        Search and loads the specified hyperopt.
+        :param hyperopt_name: name of the module to import
+        :param extra_dir: additional directory to search for the given hyperopt
+        :return: HyperOpt instance or None
+        """
+        current_path = Path(__file__).parent.parent.joinpath('optimize').resolve()
+
+        abs_paths = [
+            current_path.parent.parent.joinpath('user_data/hyperopts'),
+            current_path,
+        ]
+
+        if extra_dir:
+            # Add extra hyperopt directory on top of search paths
+            abs_paths.insert(0, Path(extra_dir))
+
+        for _path in abs_paths:
+            try:
+                hyperopt = self._search_object(directory=_path, object_type=IHyperOpt,
+                                               object_name=hyperopt_name)
+                if hyperopt:
+                    logger.info("Using resolved hyperopt %s from '%s'", hyperopt_name, _path)
+                    return hyperopt
+            except FileNotFoundError:
+                logger.warning('Path "%s" does not exist', _path.relative_to(Path.cwd()))
+
+        raise ImportError(
+            "Impossible to load Hyperopt '{}'. This class does not exist"
+            " or contains Python code errors".format(hyperopt_name)
+        )

freqtrade/resolvers/iresolver.py

@@ -0,0 +1,65 @@
+# pragma pylint: disable=attribute-defined-outside-init
+
+"""
+This module load custom objects
+"""
+import importlib.util
+import inspect
+import logging
+from pathlib import Path
+from typing import Optional, Type, Any
+
+logger = logging.getLogger(__name__)
+
+
+class IResolver(object):
+    """
+    This class contains all the logic to load custom classes
+    """
+
+    @staticmethod
+    def _get_valid_object(object_type, module_path: Path,
+                          object_name: str) -> Optional[Type[Any]]:
+        """
+        Returns the first object with matching object_type and object_name in the path given.
+        :param object_type: object_type (class)
+        :param module_path: absolute path to the module
+        :param object_name: Class name of the object
+        :return: class or None
+        """
+
+        # Generate spec based on absolute path
+        spec = importlib.util.spec_from_file_location('unknown', str(module_path))
+        module = importlib.util.module_from_spec(spec)
+        try:
+            spec.loader.exec_module(module)  # type: ignore # importlib does not use typehints
+        except (ModuleNotFoundError, SyntaxError) as err:
+            # Catch errors in case a specific module is not installed
+            logger.warning(f"Could not import {module_path} due to '{err}'")
+
+        valid_objects_gen = (
+            obj for name, obj in inspect.getmembers(module, inspect.isclass)
+            if object_name == name and object_type in obj.__bases__
+        )
+        return next(valid_objects_gen, None)
+
+    @staticmethod
+    def _search_object(directory: Path, object_type, object_name: str,
+                       kwargs: dict = {}) -> Optional[Any]:
+        """
+        Search for the objectname in the given directory
+        :param directory: relative or absolute directory path
+        :return: object instance
+        """
+        logger.debug("Searching for %s %s in '%s'", object_type.__name__, object_name, directory)
+        for entry in directory.iterdir():
+            # Only consider python files
+            if not str(entry).endswith('.py'):
+                logger.debug('Ignoring %s', entry)
+                continue
+            obj = IResolver._get_valid_object(
+                object_type, Path.resolve(directory.joinpath(entry)), object_name
+            )
+            if obj:
+                return obj(**kwargs)
+        return None

freqtrade/resolvers/pairlist_resolver.py

@@ -0,0 +1,59 @@
+# pragma pylint: disable=attribute-defined-outside-init
+
+"""
+This module load custom hyperopts
+"""
+import logging
+from pathlib import Path
+
+from freqtrade.pairlist.IPairList import IPairList
+from freqtrade.resolvers import IResolver
+
+logger = logging.getLogger(__name__)
+
+
+class PairListResolver(IResolver):
+    """
+    This class contains all the logic to load custom hyperopt class
+    """
+
+    __slots__ = ['pairlist']
+
+    def __init__(self, pairlist_name: str, freqtrade, config: dict) -> None:
+        """
+        Load the custom class from config parameter
+        :param config: configuration dictionary or None
+        """
+        self.pairlist = self._load_pairlist(pairlist_name, kwargs={'freqtrade': freqtrade,
+                                                                   'config': config})
+
+    def _load_pairlist(
+            self, pairlist_name: str, kwargs: dict) -> IPairList:
+        """
+        Search and loads the specified pairlist.
+        :param pairlist_name: name of the module to import
+        :param extra_dir: additional directory to search for the given pairlist
+        :return: PairList instance or None
+        """
+        current_path = Path(__file__).parent.parent.joinpath('pairlist').resolve()
+
+        abs_paths = [
+            current_path.parent.parent.joinpath('user_data/pairlist'),
+            current_path,
+        ]
+
+        for _path in abs_paths:
+            try:
+                pairlist = self._search_object(directory=_path, object_type=IPairList,
+                                               object_name=pairlist_name,
+                                               kwargs=kwargs)
+                if pairlist:
+                    logger.info("Using resolved pairlist %s from '%s'", pairlist_name, _path)
+                    return pairlist
+            except FileNotFoundError:
+                logger.warning('Path "%s" does not exist', _path.relative_to(Path.cwd()))
+
+        raise ImportError(
+            "Impossible to load Pairlist '{}'. This class does not exist"
+            " or contains Python code errors".format(pairlist_name)
+        )

freqtrade/resolvers/strategy_resolver.py

@@ -0,0 +1,171 @@
+# pragma pylint: disable=attribute-defined-outside-init
+
+"""
+This module load custom strategies
+"""
+import logging
+import tempfile
+from base64 import urlsafe_b64decode
+from collections import OrderedDict
+from inspect import getfullargspec
+from pathlib import Path
+from typing import Dict, Optional
+
+from freqtrade import constants
+from freqtrade.resolvers import IResolver
+from freqtrade.strategy import import_strategy
+from freqtrade.strategy.interface import IStrategy
+
+logger = logging.getLogger(__name__)
+
+
+class StrategyResolver(IResolver):
+    """
+    This class contains all the logic to load custom strategy class
+    """
+
+    __slots__ = ['strategy']
+
+    def __init__(self, config: Optional[Dict] = None) -> None:
+        """
+        Load the custom class from config parameter
+        :param config: configuration dictionary or None
+        """
+        config = config or {}
+
+        # Verify the strategy is in the configuration, otherwise fallback to the default strategy
+        strategy_name = config.get('strategy') or constants.DEFAULT_STRATEGY
+        self.strategy: IStrategy = self._load_strategy(strategy_name,
+                                                       config=config,
+                                                       extra_dir=config.get('strategy_path'))
+
+        # make sure experimental dict is available
+        if 'experimental' not in config:
+            config['experimental'] = {}
+
+        # Set attributes
+        # Check if we need to override configuration
+        # (Attribute name,                              default, experimental)
+        attributes = [("minimal_roi",                     {"0": 10.0}, False),
+                      ("ticker_interval",                 None,        False),
+                      ("stoploss",                        None,        False),
+                      ("trailing_stop",                   None,        False),
+                      ("trailing_stop_positive",          None,        False),
+                      ("trailing_stop_positive_offset",   0.0,         False),
+                      ("trailing_only_offset_is_reached", None,        False),
+                      ("process_only_new_candles",        None,        False),
+                      ("order_types",                     None,        False),
+                      ("order_time_in_force",             None,        False),
+                      ("stake_currency",                  None,        False),
+                      ("stake_amount",                    None,        False),
+                      ("use_sell_signal",                 False,       True),
+                      ("sell_profit_only",                False,       True),
+                      ("ignore_roi_if_buy_signal",        False,       True),
+                      ]
+        for attribute, default, experimental in attributes:
+            if experimental:
+                self._override_attribute_helper(config['experimental'], attribute, default)
+            else:
+                self._override_attribute_helper(config, attribute, default)
+
+        # Loop this list again to have output combined
+        for attribute, _, exp in attributes:
+            if exp and attribute in config['experimental']:
+                logger.info("Strategy using %s: %s", attribute, config['experimental'][attribute])
+            elif attribute in config:
+                logger.info("Strategy using %s: %s", attribute, config[attribute])
+
+        # Sort and apply type conversions
+        self.strategy.minimal_roi = OrderedDict(sorted(
+            {int(key): value for (key, value) in self.strategy.minimal_roi.items()}.items(),
+            key=lambda t: t[0]))
+        self.strategy.stoploss = float(self.strategy.stoploss)
+
+        self._strategy_sanity_validations()
+
+    def _override_attribute_helper(self, config, attribute: str, default):
+        """
+        Override attributes in the strategy.
+        Prevalence:
+        - Configuration
+        - Strategy
+        - default (if not None)
+        """
+        if attribute in config:
+            setattr(self.strategy, attribute, config[attribute])
+            logger.info("Override strategy '%s' with value in config file: %s.",
+                        attribute, config[attribute])
+        elif hasattr(self.strategy, attribute):
+            config[attribute] = getattr(self.strategy, attribute)
+        # Explicitly check for None here as other "falsy" values are possible
+        elif default is not None:
+            setattr(self.strategy, attribute, default)
+            config[attribute] = default
+
+    def _strategy_sanity_validations(self):
+        if not all(k in self.strategy.order_types for k in constants.REQUIRED_ORDERTYPES):
+            raise ImportError(f"Impossible to load Strategy '{self.strategy.__class__.__name__}'. "
+                              f"Order-types mapping is incomplete.")
+
+        if not all(k in self.strategy.order_time_in_force for k in constants.REQUIRED_ORDERTIF):
+            raise ImportError(f"Impossible to load Strategy '{self.strategy.__class__.__name__}'. "
+                              f"Order-time-in-force mapping is incomplete.")
+
+    def _load_strategy(
+            self, strategy_name: str, config: dict, extra_dir: Optional[str] = None) -> IStrategy:
+        """
+        Search and loads the specified strategy.
+        :param strategy_name: name of the module to import
+        :param config: configuration for the strategy
+        :param extra_dir: additional directory to search for the given strategy
+        :return: Strategy instance or None
+        """
+        current_path = Path(__file__).parent.parent.joinpath('strategy').resolve()
+
+        abs_paths = [
+            Path.cwd().joinpath('user_data/strategies'),
+            current_path,
+        ]
+
+        if extra_dir:
+            # Add extra strategy directory on top of search paths
+            abs_paths.insert(0, Path(extra_dir).resolve())
+
+        if ":" in strategy_name:
+            logger.info("loading base64 endocded strategy")
+            strat = strategy_name.split(":")
+
+            if len(strat) == 2:
+                temp = Path(tempfile.mkdtemp("freq", "strategy"))
+                name = strat[0] + ".py"
+
+                temp.joinpath(name).write_text(urlsafe_b64decode(strat[1]).decode('utf-8'))
+                temp.joinpath("__init__.py").touch()
+
+                strategy_name = strat[0]
+
+                # register temp path with the bot
+                abs_paths.insert(0, temp.resolve())
+
+        for _path in abs_paths:
+            try:
+                strategy = self._search_object(directory=_path, object_type=IStrategy,
+                                               object_name=strategy_name, kwargs={'config': config})
+                if strategy:
+                    logger.info("Using resolved strategy %s from '%s'", strategy_name, _path)
+                    strategy._populate_fun_len = len(
+                        getfullargspec(strategy.populate_indicators).args)
+                    strategy._buy_fun_len = len(getfullargspec(strategy.populate_buy_trend).args)
+                    strategy._sell_fun_len = len(getfullargspec(strategy.populate_sell_trend).args)
+                    try:
+                        return import_strategy(strategy, config=config)
+                    except TypeError as e:
+                        logger.warning(
+                            f"Impossible to load strategy '{strategy}' from {_path}. Error: {e}")
+            except FileNotFoundError:
+                logger.warning('Path "%s" does not exist', _path.relative_to(Path.cwd()))
+
+        raise ImportError(
+            f"Impossible to load Strategy '{strategy_name}'. This class does not exist"
+            " or contains Python code errors"
+        )

freqtrade/rpc/__init__.py

@@ -1 +1,2 @@
-from . import telegram
+from .rpc import RPC, RPCMessageType, RPCException  # noqa
+from .rpc_manager import RPCManager  # noqa

freqtrade/rpc/fiat_convert.py

@@ -0,0 +1,206 @@
+"""
+Module that define classes to convert Crypto-currency to FIAT
+e.g BTC to USD
+"""
+
+import logging
+import time
+from typing import Dict, List
+
+from coinmarketcap import Market
+
+from freqtrade.constants import SUPPORTED_FIAT
+
+
+logger = logging.getLogger(__name__)
+
+
+class CryptoFiat(object):
+    """
+    Object to describe what is the price of Crypto-currency in a FIAT
+    """
+    # Constants
+    CACHE_DURATION = 6 * 60 * 60  # 6 hours
+
+    def __init__(self, crypto_symbol: str, fiat_symbol: str, price: float) -> None:
+        """
+        Create an object that will contains the price for a crypto-currency in fiat
+        :param crypto_symbol: Crypto-currency you want to convert (e.g BTC)
+        :param fiat_symbol: FIAT currency you want to convert to (e.g USD)
+        :param price: Price in FIAT
+        """
+
+        # Public attributes
+        self.crypto_symbol = None
+        self.fiat_symbol = None
+        self.price = 0.0
+
+        # Private attributes
+        self._expiration = 0.0
+
+        self.crypto_symbol = crypto_symbol.upper()
+        self.fiat_symbol = fiat_symbol.upper()
+        self.set_price(price=price)
+
+    def set_price(self, price: float) -> None:
+        """
+        Set the price of the Crypto-currency in FIAT and set the expiration time
+        :param price: Price of the current Crypto currency in the fiat
+        :return: None
+        """
+        self.price = price
+        self._expiration = time.time() + self.CACHE_DURATION
+
+    def is_expired(self) -> bool:
+        """
+        Return if the current price is still valid or needs to be refreshed
+        :return: bool, true the price is expired and needs to be refreshed, false the price is
+         still valid
+        """
+        return self._expiration - time.time() <= 0
+
+
+class CryptoToFiatConverter(object):
+    """
+    Main class to initiate Crypto to FIAT.
+    This object contains a list of pair Crypto, FIAT
+    This object is also a Singleton
+    """
+    __instance = None
+    _coinmarketcap: Market = None
+
+    _cryptomap: Dict = {}
+
+    def __new__(cls):
+        if CryptoToFiatConverter.__instance is None:
+            CryptoToFiatConverter.__instance = object.__new__(cls)
+            try:
+                CryptoToFiatConverter._coinmarketcap = Market()
+            except BaseException:
+                CryptoToFiatConverter._coinmarketcap = None
+        return CryptoToFiatConverter.__instance
+
+    def __init__(self) -> None:
+        self._pairs: List[CryptoFiat] = []
+        self._load_cryptomap()
+
+    def _load_cryptomap(self) -> None:
+        try:
+            coinlistings = self._coinmarketcap.listings()
+            self._cryptomap = dict(map(lambda coin: (coin["symbol"], str(coin["id"])),
+                                       coinlistings["data"]))
+        except (BaseException) as exception:
+            logger.error(
+                "Could not load FIAT Cryptocurrency map for the following problem: %s",
+                type(exception).__name__
+            )
+
+    def convert_amount(self, crypto_amount: float, crypto_symbol: str, fiat_symbol: str) -> float:
+        """
+        Convert an amount of crypto-currency to fiat
+        :param crypto_amount: amount of crypto-currency to convert
+        :param crypto_symbol: crypto-currency used
+        :param fiat_symbol: fiat to convert to
+        :return: float, value in fiat of the crypto-currency amount
+        """
+        if crypto_symbol == fiat_symbol:
+            return crypto_amount
+        price = self.get_price(crypto_symbol=crypto_symbol, fiat_symbol=fiat_symbol)
+        return float(crypto_amount) * float(price)
+
+    def get_price(self, crypto_symbol: str, fiat_symbol: str) -> float:
+        """
+        Return the price of the Crypto-currency in Fiat
+        :param crypto_symbol: Crypto-currency you want to convert (e.g BTC)
+        :param fiat_symbol: FIAT currency you want to convert to (e.g USD)
+        :return: Price in FIAT
+        """
+        crypto_symbol = crypto_symbol.upper()
+        fiat_symbol = fiat_symbol.upper()
+
+        # Check if the fiat convertion you want is supported
+        if not self._is_supported_fiat(fiat=fiat_symbol):
+            raise ValueError(f'The fiat {fiat_symbol} is not supported.')
+
+        # Get the pair that interest us and return the price in fiat
+        for pair in self._pairs:
+            if pair.crypto_symbol == crypto_symbol and pair.fiat_symbol == fiat_symbol:
+                # If the price is expired we refresh it, avoid to call the API all the time
+                if pair.is_expired():
+                    pair.set_price(
+                        price=self._find_price(
+                            crypto_symbol=pair.crypto_symbol,
+                            fiat_symbol=pair.fiat_symbol
+                        )
+                    )
+
+                # return the last price we have for this pair
+                return pair.price
+
+        # The pair does not exist, so we create it and return the price
+        return self._add_pair(
+            crypto_symbol=crypto_symbol,
+            fiat_symbol=fiat_symbol,
+            price=self._find_price(
+                crypto_symbol=crypto_symbol,
+                fiat_symbol=fiat_symbol
+            )
+        )
+
+    def _add_pair(self, crypto_symbol: str, fiat_symbol: str, price: float) -> float:
+        """
+        :param crypto_symbol: Crypto-currency you want to convert (e.g BTC)
+        :param fiat_symbol: FIAT currency you want to convert to (e.g USD)
+        :return: price in FIAT
+        """
+        self._pairs.append(
+            CryptoFiat(
+                crypto_symbol=crypto_symbol,
+                fiat_symbol=fiat_symbol,
+                price=price
+            )
+        )
+
+        return price
+
+    def _is_supported_fiat(self, fiat: str) -> bool:
+        """
+        Check if the FIAT your want to convert to is supported
+        :param fiat: FIAT to check (e.g USD)
+        :return: bool, True supported, False not supported
+        """
+
+        fiat = fiat.upper()
+
+        return fiat in SUPPORTED_FIAT
+
+    def _find_price(self, crypto_symbol: str, fiat_symbol: str) -> float:
+        """
+        Call CoinMarketCap API to retrieve the price in the FIAT
+        :param crypto_symbol: Crypto-currency you want to convert (e.g BTC)
+        :param fiat_symbol: FIAT currency you want to convert to (e.g USD)
+        :return: float, price of the crypto-currency in Fiat
+        """
+        # Check if the fiat convertion you want is supported
+        if not self._is_supported_fiat(fiat=fiat_symbol):
+            raise ValueError(f'The fiat {fiat_symbol} is not supported.')
+
+        # No need to convert if both crypto and fiat are the same
+        if crypto_symbol == fiat_symbol:
+            return 1.0
+
+        if crypto_symbol not in self._cryptomap:
+            # return 0 for unsupported stake currencies (fiat-convert should not break the bot)
+            logger.warning("unsupported crypto-symbol %s - returning 0.0", crypto_symbol)
+            return 0.0
+
+        try:
+            return float(
+                self._coinmarketcap.ticker(
+                    currency=self._cryptomap[crypto_symbol],
+                    convert=fiat_symbol
+                )['data']['quotes'][fiat_symbol.upper()]['price']
+            )
+        except BaseException as exception:
+            logger.error("Error in _find_price: %s", exception)
+            return 0.0

freqtrade/rpc/rpc.py

@@ -0,0 +1,496 @@
+"""
+This module contains class to define a RPC communications
+"""
+import logging
+from abc import abstractmethod
+from datetime import timedelta, datetime, date
+from decimal import Decimal
+from enum import Enum
+from typing import Dict, Any, List, Optional
+
+import arrow
+import sqlalchemy as sql
+from numpy import mean, nan_to_num, NAN
+from pandas import DataFrame
+
+from freqtrade import TemporaryError, DependencyException
+from freqtrade.misc import shorten_date
+from freqtrade.persistence import Trade
+from freqtrade.rpc.fiat_convert import CryptoToFiatConverter
+from freqtrade.state import State
+from freqtrade.strategy.interface import SellType
+
+logger = logging.getLogger(__name__)
+
+
+class RPCMessageType(Enum):
+    STATUS_NOTIFICATION = 'status'
+    WARNING_NOTIFICATION = 'warning'
+    CUSTOM_NOTIFICATION = 'custom'
+    BUY_NOTIFICATION = 'buy'
+    SELL_NOTIFICATION = 'sell'
+
+    def __repr__(self):
+        return self.value
+
+
+class RPCException(Exception):
+    """
+    Should be raised with a rpc-formatted message in an _rpc_* method
+    if the required state is wrong, i.e.:
+
+    raise RPCException('*Status:* `no active trade`')
+    """
+    def __init__(self, message: str) -> None:
+        super().__init__(self)
+        self.message = message
+
+    def __str__(self):
+        return self.message
+
+
+class RPC(object):
+    """
+    RPC class can be used to have extra feature, like bot data, and access to DB data
+    """
+    # Bind _fiat_converter if needed in each RPC handler
+    _fiat_converter: Optional[CryptoToFiatConverter] = None
+
+    def __init__(self, freqtrade) -> None:
+        """
+        Initializes all enabled rpc modules
+        :param freqtrade: Instance of a freqtrade bot
+        :return: None
+        """
+        self._freqtrade = freqtrade
+
+    @property
+    def name(self) -> str:
+        """ Returns the lowercase name of the implementation """
+        return self.__class__.__name__.lower()
+
+    @abstractmethod
+    def cleanup(self) -> None:
+        """ Cleanup pending module resources """
+
+    @abstractmethod
+    def send_msg(self, msg: Dict[str, str]) -> None:
+        """ Sends a message to all registered rpc modules """
+
+    def _rpc_trade_status(self) -> List[Dict[str, Any]]:
+        """
+        Below follows the RPC backend it is prefixed with rpc_ to raise awareness that it is
+        a remotely exposed function
+        """
+        # Fetch open trade
+        trades = Trade.get_open_trades()
+        if not trades:
+            raise RPCException('no active trade')
+        else:
+            results = []
+            for trade in trades:
+                order = None
+                if trade.open_order_id:
+                    order = self._freqtrade.exchange.get_order(trade.open_order_id, trade.pair)
+                # calculate profit and send message to user
+                try:
+                    current_rate = self._freqtrade.get_sell_rate(trade.pair, False)
+                except DependencyException:
+                    current_rate = NAN
+                current_profit = trade.calc_profit_percent(current_rate)
+                fmt_close_profit = (f'{round(trade.close_profit * 100, 2):.2f}%'
+                                    if trade.close_profit else None)
+                results.append(dict(
+                    trade_id=trade.id,
+                    pair=trade.pair,
+                    base_currency=self._freqtrade.config['stake_currency'],
+                    date=arrow.get(trade.open_date),
+                    open_rate=trade.open_rate,
+                    close_rate=trade.close_rate,
+                    current_rate=current_rate,
+                    amount=round(trade.amount, 8),
+                    stake_amount=round(trade.stake_amount, 8),
+                    close_profit=fmt_close_profit,
+                    current_profit=round(current_profit * 100, 2),
+                    stop_loss=trade.stop_loss,
+                    stop_loss_pct=(trade.stop_loss_pct * 100)
+                    if trade.stop_loss_pct else None,
+                    initial_stop_loss=trade.initial_stop_loss,
+                    initial_stop_loss_pct=(trade.initial_stop_loss_pct * 100)
+                    if trade.initial_stop_loss_pct else None,
+                    open_order='({} {} rem={:.8f})'.format(
+                        order['type'], order['side'], order['remaining']
+                    ) if order else None,
+                ))
+            return results
+
+    def _rpc_status_table(self) -> DataFrame:
+        trades = Trade.get_open_trades()
+        if not trades:
+            raise RPCException('no active order')
+        else:
+            trades_list = []
+            for trade in trades:
+                # calculate profit and send message to user
+                try:
+                    current_rate = self._freqtrade.get_sell_rate(trade.pair, False)
+                except DependencyException:
+                    current_rate = NAN
+                trade_perc = (100 * trade.calc_profit_percent(current_rate))
+                trades_list.append([
+                    trade.id,
+                    trade.pair,
+                    shorten_date(arrow.get(trade.open_date).humanize(only_distance=True)),
+                    f'{trade_perc:.2f}%'
+                ])
+
+            columns = ['ID', 'Pair', 'Since', 'Profit']
+            df_statuses = DataFrame.from_records(trades_list, columns=columns)
+            df_statuses = df_statuses.set_index(columns[0])
+            return df_statuses
+
+    def _rpc_daily_profit(
+            self, timescale: int,
+            stake_currency: str, fiat_display_currency: str) -> List[List[Any]]:
+        today = datetime.utcnow().date()
+        profit_days: Dict[date, Dict] = {}
+
+        if not (isinstance(timescale, int) and timescale > 0):
+            raise RPCException('timescale must be an integer greater than 0')
+
+        for day in range(0, timescale):
+            profitday = today - timedelta(days=day)
+            trades = Trade.query \
+                .filter(Trade.is_open.is_(False)) \
+                .filter(Trade.close_date >= profitday)\
+                .filter(Trade.close_date < (profitday + timedelta(days=1)))\
+                .order_by(Trade.close_date)\
+                .all()
+            curdayprofit = sum(trade.calc_profit() for trade in trades)
+            profit_days[profitday] = {
+                'amount': f'{curdayprofit:.8f}',
+                'trades': len(trades)
+            }
+
+        return [
+            [
+                key,
+                '{value:.8f} {symbol}'.format(
+                    value=float(value['amount']),
+                    symbol=stake_currency
+                ),
+                '{value:.3f} {symbol}'.format(
+                    value=self._fiat_converter.convert_amount(
+                        value['amount'],
+                        stake_currency,
+                        fiat_display_currency
+                    ) if self._fiat_converter else 0,
+                    symbol=fiat_display_currency
+                ),
+                '{value} trade{s}'.format(
+                    value=value['trades'],
+                    s='' if value['trades'] < 2 else 's'
+                ),
+            ]
+            for key, value in profit_days.items()
+        ]
+
+    def _rpc_trade_statistics(
+            self, stake_currency: str, fiat_display_currency: str) -> Dict[str, Any]:
+        """ Returns cumulative profit statistics """
+        trades = Trade.query.order_by(Trade.id).all()
+
+        profit_all_coin = []
+        profit_all_percent = []
+        profit_closed_coin = []
+        profit_closed_percent = []
+        durations = []
+
+        for trade in trades:
+            current_rate: float = 0.0
+
+            if not trade.open_rate:
+                continue
+            if trade.close_date:
+                durations.append((trade.close_date - trade.open_date).total_seconds())
+
+            if not trade.is_open:
+                profit_percent = trade.calc_profit_percent()
+                profit_closed_coin.append(trade.calc_profit())
+                profit_closed_percent.append(profit_percent)
+            else:
+                # Get current rate
+                try:
+                    current_rate = self._freqtrade.get_sell_rate(trade.pair, False)
+                except DependencyException:
+                    current_rate = NAN
+                profit_percent = trade.calc_profit_percent(rate=current_rate)
+
+            profit_all_coin.append(
+                trade.calc_profit(rate=Decimal(trade.close_rate or current_rate))
+            )
+            profit_all_percent.append(profit_percent)
+
+        best_pair = Trade.session.query(
+            Trade.pair, sql.func.sum(Trade.close_profit).label('profit_sum')
+        ).filter(Trade.is_open.is_(False)) \
+            .group_by(Trade.pair) \
+            .order_by(sql.text('profit_sum DESC')).first()
+
+        if not best_pair:
+            raise RPCException('no closed trade')
+
+        bp_pair, bp_rate = best_pair
+
+        # Prepare data to display
+        profit_closed_coin_sum = round(sum(profit_closed_coin), 8)
+        profit_closed_percent = round(nan_to_num(mean(profit_closed_percent)) * 100, 2)
+        profit_closed_fiat = self._fiat_converter.convert_amount(
+            profit_closed_coin_sum,
+            stake_currency,
+            fiat_display_currency
+        ) if self._fiat_converter else 0
+
+        profit_all_coin_sum = round(sum(profit_all_coin), 8)
+        profit_all_percent = round(nan_to_num(mean(profit_all_percent)) * 100, 2)
+        profit_all_fiat = self._fiat_converter.convert_amount(
+            profit_all_coin_sum,
+            stake_currency,
+            fiat_display_currency
+        ) if self._fiat_converter else 0
+
+        num = float(len(durations) or 1)
+        return {
+            'profit_closed_coin': profit_closed_coin_sum,
+            'profit_closed_percent': profit_closed_percent,
+            'profit_closed_fiat': profit_closed_fiat,
+            'profit_all_coin': profit_all_coin_sum,
+            'profit_all_percent': profit_all_percent,
+            'profit_all_fiat': profit_all_fiat,
+            'trade_count': len(trades),
+            'first_trade_date': arrow.get(trades[0].open_date).humanize(),
+            'latest_trade_date': arrow.get(trades[-1].open_date).humanize(),
+            'avg_duration': str(timedelta(seconds=sum(durations) / num)).split('.')[0],
+            'best_pair': bp_pair,
+            'best_rate': round(bp_rate * 100, 2),
+        }
+
+    def _rpc_balance(self, fiat_display_currency: str) -> Dict:
+        """ Returns current account balance per crypto """
+        output = []
+        total = 0.0
+        for coin, balance in self._freqtrade.exchange.get_balances().items():
+            if not balance['total']:
+                continue
+
+            if coin == 'BTC':
+                rate = 1.0
+            else:
+                try:
+                    if coin == 'USDT':
+                        rate = 1.0 / self._freqtrade.get_sell_rate('BTC/USDT', False)
+                    else:
+                        rate = self._freqtrade.get_sell_rate(coin + '/BTC', False)
+                except (TemporaryError, DependencyException):
+                    continue
+            est_btc: float = rate * balance['total']
+            total = total + est_btc
+            output.append({
+                'currency': coin,
+                'available': balance['free'],
+                'balance': balance['total'],
+                'pending': balance['used'],
+                'est_btc': est_btc,
+            })
+        if total == 0.0:
+            raise RPCException('all balances are zero')
+
+        symbol = fiat_display_currency
+        value = self._fiat_converter.convert_amount(total, 'BTC',
+                                                    symbol) if self._fiat_converter else 0
+        return {
+            'currencies': output,
+            'total': total,
+            'symbol': symbol,
+            'value': value,
+        }
+
+    def _rpc_start(self) -> Dict[str, str]:
+        """ Handler for start """
+        if self._freqtrade.state == State.RUNNING:
+            return {'status': 'already running'}
+
+        self._freqtrade.state = State.RUNNING
+        return {'status': 'starting trader ...'}
+
+    def _rpc_stop(self) -> Dict[str, str]:
+        """ Handler for stop """
+        if self._freqtrade.state == State.RUNNING:
+            self._freqtrade.state = State.STOPPED
+            return {'status': 'stopping trader ...'}
+
+        return {'status': 'already stopped'}
+
+    def _rpc_reload_conf(self) -> Dict[str, str]:
+        """ Handler for reload_conf. """
+        self._freqtrade.state = State.RELOAD_CONF
+        return {'status': 'reloading config ...'}
+
+    def _rpc_stopbuy(self) -> Dict[str, str]:
+        """
+        Handler to stop buying, but handle open trades gracefully.
+        """
+        if self._freqtrade.state == State.RUNNING:
+            # Set 'max_open_trades' to 0
+            self._freqtrade.config['max_open_trades'] = 0
+
+        return {'status': 'No more buy will occur from now. Run /reload_conf to reset.'}
+
+    def _rpc_forcesell(self, trade_id) -> None:
+        """
+        Handler for forcesell <id>.
+        Sells the given trade at current price
+        """
+        def _exec_forcesell(trade: Trade) -> None:
+            # Check if there is there is an open order
+            if trade.open_order_id:
+                order = self._freqtrade.exchange.get_order(trade.open_order_id, trade.pair)
+
+                # Cancel open LIMIT_BUY orders and close trade
+                if order and order['status'] == 'open' \
+                        and order['type'] == 'limit' \
+                        and order['side'] == 'buy':
+                    self._freqtrade.exchange.cancel_order(trade.open_order_id, trade.pair)
+                    trade.close(order.get('price') or trade.open_rate)
+                    # Do the best effort, if we don't know 'filled' amount, don't try selling
+                    if order['filled'] is None:
+                        return
+                    trade.amount = order['filled']
+
+                # Ignore trades with an attached LIMIT_SELL order
+                if order and order['status'] == 'open' \
+                        and order['type'] == 'limit' \
+                        and order['side'] == 'sell':
+                    return
+
+            # Get current rate and execute sell
+            current_rate = self._freqtrade.get_sell_rate(trade.pair, False)
+            self._freqtrade.execute_sell(trade, current_rate, SellType.FORCE_SELL)
+        # ---- EOF def _exec_forcesell ----
+
+        if self._freqtrade.state != State.RUNNING:
+            raise RPCException('trader is not running')
+
+        if trade_id == 'all':
+            # Execute sell for all open orders
+            for trade in Trade.get_open_trades():
+                _exec_forcesell(trade)
+            Trade.session.flush()
+            return
+
+        # Query for trade
+        trade = Trade.query.filter(
+            sql.and_(
+                Trade.id == trade_id,
+                Trade.is_open.is_(True)
+            )
+        ).first()
+        if not trade:
+            logger.warning('forcesell: Invalid argument received')
+            raise RPCException('invalid argument')
+
+        _exec_forcesell(trade)
+        Trade.session.flush()
+
+    def _rpc_forcebuy(self, pair: str, price: Optional[float]) -> Optional[Trade]:
+        """
+        Handler for forcebuy <asset> <price>
+        Buys a pair trade at the given or current price
+        """
+
+        if not self._freqtrade.config.get('forcebuy_enable', False):
+            raise RPCException('Forcebuy not enabled.')
+
+        if self._freqtrade.state != State.RUNNING:
+            raise RPCException('trader is not running')
+
+        # Check pair is in stake currency
+        stake_currency = self._freqtrade.config.get('stake_currency')
+        if not pair.endswith(stake_currency):
+            raise RPCException(
+                f'Wrong pair selected. Please pairs with stake {stake_currency} pairs only')
+        # check if valid pair
+
+        # check if pair already has an open pair
+        trade = Trade.query.filter(Trade.is_open.is_(True)).filter(Trade.pair.is_(pair)).first()
+        if trade:
+            raise RPCException(f'position for {pair} already open - id: {trade.id}')
+
+        # gen stake amount
+        stakeamount = self._freqtrade._get_trade_stake_amount(pair)
+
+        # execute buy
+        if self._freqtrade.execute_buy(pair, stakeamount, price):
+            trade = Trade.query.filter(Trade.is_open.is_(True)).filter(Trade.pair.is_(pair)).first()
+            return trade
+        else:
+            return None
+
+    def _rpc_performance(self) -> List[Dict]:
+        """
+        Handler for performance.
+        Shows a performance statistic from finished trades
+        """
+
+        pair_rates = Trade.session.query(Trade.pair,
+                                         sql.func.sum(Trade.close_profit).label('profit_sum'),
+                                         sql.func.count(Trade.pair).label('count')) \
+            .filter(Trade.is_open.is_(False)) \
+            .group_by(Trade.pair) \
+            .order_by(sql.text('profit_sum DESC')) \
+            .all()
+        return [
+            {'pair': pair, 'profit': round(rate * 100, 2), 'count': count}
+            for pair, rate, count in pair_rates
+        ]
+
+    def _rpc_count(self) -> Dict[str, float]:
+        """ Returns the number of trades running """
+        if self._freqtrade.state != State.RUNNING:
+            raise RPCException('trader is not running')
+
+        trades = Trade.get_open_trades()
+        return {
+            'current': len(trades),
+            'max': float(self._freqtrade.config['max_open_trades']),
+            'total_stake': sum((trade.open_rate * trade.amount) for trade in trades)
+        }
+
+    def _rpc_whitelist(self) -> Dict:
+        """ Returns the currently active whitelist"""
+        res = {'method': self._freqtrade.pairlists.name,
+               'length': len(self._freqtrade.active_pair_whitelist),
+               'whitelist': self._freqtrade.active_pair_whitelist
+               }
+        return res
+
+    def _rpc_blacklist(self, add: List[str]) -> Dict:
+        """ Returns the currently active blacklist"""
+        if add:
+            stake_currency = self._freqtrade.config.get('stake_currency')
+            for pair in add:
+                if (pair.endswith(stake_currency)
+                        and pair not in self._freqtrade.pairlists.blacklist):
+                    self._freqtrade.pairlists.blacklist.append(pair)
+
+        res = {'method': self._freqtrade.pairlists.name,
+               'length': len(self._freqtrade.pairlists.blacklist),
+               'blacklist': self._freqtrade.pairlists.blacklist,
+               }
+        return res
+
+    def _rpc_edge(self) -> List[Dict[str, Any]]:
+        """ Returns information related to Edge """
+        if not self._freqtrade.edge:
+            raise RPCException(f'Edge is not enabled.')
+        return self._freqtrade.edge.accepted_pairs()

freqtrade/rpc/rpc_manager.py

@@ -0,0 +1,82 @@
+"""
+This module contains class to manage RPC communications (Telegram, Slack, ...)
+"""
+import logging
+from typing import Any, Dict, List
+
+from freqtrade.rpc import RPC, RPCMessageType
+
+logger = logging.getLogger(__name__)
+
+
+class RPCManager(object):
+    """
+    Class to manage RPC objects (Telegram, Slack, ...)
+    """
+    def __init__(self, freqtrade) -> None:
+        """ Initializes all enabled rpc modules """
+        self.registered_modules: List[RPC] = []
+
+        # Enable telegram
+        if freqtrade.config['telegram'].get('enabled', False):
+            logger.info('Enabling rpc.telegram ...')
+            from freqtrade.rpc.telegram import Telegram
+            self.registered_modules.append(Telegram(freqtrade))
+
+        # Enable Webhook
+        if freqtrade.config.get('webhook', {}).get('enabled', False):
+            logger.info('Enabling rpc.webhook ...')
+            from freqtrade.rpc.webhook import Webhook
+            self.registered_modules.append(Webhook(freqtrade))
+
+    def cleanup(self) -> None:
+        """ Stops all enabled rpc modules """
+        logger.info('Cleaning up rpc modules ...')
+        while self.registered_modules:
+            mod = self.registered_modules.pop()
+            logger.debug('Cleaning up rpc.%s ...', mod.name)
+            mod.cleanup()
+            del mod
+
+    def send_msg(self, msg: Dict[str, Any]) -> None:
+        """
+        Send given message to all registered rpc modules.
+        A message consists of one or more key value pairs of strings.
+        e.g.:
+        {
+            'status': 'stopping bot'
+        }
+        """
+        logger.info('Sending rpc message: %s', msg)
+        for mod in self.registered_modules:
+            logger.debug('Forwarding message to rpc.%s', mod.name)
+            mod.send_msg(msg)
+
+    def startup_messages(self, config, pairlist) -> None:
+        if config.get('dry_run', False):
+            self.send_msg({
+                'type': RPCMessageType.WARNING_NOTIFICATION,
+                'status': 'Dry run is enabled. All trades are simulated.'
+            })
+        stake_currency = config['stake_currency']
+        stake_amount = config['stake_amount']
+        minimal_roi = config['minimal_roi']
+        stoploss = config['stoploss']
+        trailing_stop = config['trailing_stop']
+        ticker_interval = config['ticker_interval']
+        exchange_name = config['exchange']['name']
+        strategy_name = config.get('strategy', '')
+        self.send_msg({
+            'type': RPCMessageType.CUSTOM_NOTIFICATION,
+            'status': f'*Exchange:* `{exchange_name}`\n'
+                      f'*Stake per trade:* `{stake_amount} {stake_currency}`\n'
+                      f'*Minimum ROI:* `{minimal_roi}`\n'
+                      f'*{"Trailing " if trailing_stop else ""}Stoploss:* `{stoploss}`\n'
+                      f'*Ticker Interval:* `{ticker_interval}`\n'
+                      f'*Strategy:* `{strategy_name}`'
+        })
+        self.send_msg({
+            'type': RPCMessageType.STATUS_NOTIFICATION,
+            'status': f'Searching for {stake_currency} pairs to buy and sell '
+                      f'based on {pairlist.short_desc()}'
+        })

freqtrade/rpc/webhook.py

@@ -0,0 +1,66 @@
+"""
+This module manages webhook communication
+"""
+import logging
+from typing import Any,  Dict
+
+from requests import post, RequestException
+
+from freqtrade.rpc import RPC, RPCMessageType
+
+
+logger = logging.getLogger(__name__)
+
+logger.debug('Included module rpc.webhook ...')
+
+
+class Webhook(RPC):
+    """  This class handles all webhook communication """
+
+    def __init__(self, freqtrade) -> None:
+        """
+        Init the Webhook class, and init the super class RPC
+        :param freqtrade: Instance of a freqtrade bot
+        :return: None
+        """
+        super().__init__(freqtrade)
+
+        self._config = freqtrade.config
+        self._url = self._config['webhook']['url']
+
+    def cleanup(self) -> None:
+        """
+        Cleanup pending module resources.
+        This will do nothing for webhooks, they will simply not be called anymore
+        """
+        pass
+
+    def send_msg(self, msg: Dict[str, Any]) -> None:
+        """ Send a message to telegram channel """
+        try:
+
+            if msg['type'] == RPCMessageType.BUY_NOTIFICATION:
+                valuedict = self._config['webhook'].get('webhookbuy', None)
+            elif msg['type'] == RPCMessageType.SELL_NOTIFICATION:
+                valuedict = self._config['webhook'].get('webhooksell', None)
+            elif msg['type'] == RPCMessageType.STATUS_NOTIFICATION:
+                valuedict = self._config['webhook'].get('webhookstatus', None)
+            else:
+                raise NotImplementedError('Unknown message type: {}'.format(msg['type']))
+            if not valuedict:
+                logger.info("Message type %s not configured for webhooks", msg['type'])
+                return
+
+            payload = {key: value.format(**msg) for (key, value) in valuedict.items()}
+            self._send_msg(payload)
+        except KeyError as exc:
+            logger.exception("Problem calling Webhook. Please check your webhook configuration. "
+                             "Exception: %s", exc)
+
+    def _send_msg(self, payload: dict) -> None:
+        """do the actual call to the webhook"""
+
+        try:
+            post(self._url, data=payload)
+        except RequestException as exc:
+            logger.warning("Could not call webhook url. Exception: %s", exc)

freqtrade/state.py

@@ -0,0 +1,28 @@
+# pragma pylint: disable=too-few-public-methods
+
+"""
+Bot state constant
+"""
+from enum import Enum
+
+
+class State(Enum):
+    """
+    Bot application states
+    """
+    RUNNING = 1
+    STOPPED = 2
+    RELOAD_CONF = 3
+
+
+class RunMode(Enum):
+    """
+    Bot running mode (backtest, hyperopt, ...)
+    can be "live", "dry-run", "backtest", "edgecli", "hyperopt".
+    """
+    LIVE = "live"
+    DRY_RUN = "dry_run"
+    BACKTEST = "backtest"
+    EDGECLI = "edgecli"
+    HYPEROPT = "hyperopt"
+    OTHER = "other"  # Used for plotting scripts and test

freqtrade/strategy/__init__.py

@@ -0,0 +1,44 @@
+import logging
+import sys
+from copy import deepcopy
+
+from freqtrade.strategy.interface import IStrategy
+# Import Default-Strategy to have hyperopt correctly resolve
+from freqtrade.strategy.default_strategy import DefaultStrategy  # noqa: F401
+
+logger = logging.getLogger(__name__)
+
+
+def import_strategy(strategy: IStrategy, config: dict) -> IStrategy:
+    """
+    Imports given Strategy instance to global scope
+    of freqtrade.strategy and returns an instance of it
+    """
+
+    # Copy all attributes from base class and class
+
+    comb = {**strategy.__class__.__dict__, **strategy.__dict__}
+
+    # Delete '_abc_impl' from dict as deepcopy fails on 3.7 with
+    # `TypeError: can't pickle _abc_data objects``
+    # This will only apply to python 3.7
+    if sys.version_info.major == 3 and sys.version_info.minor == 7 and '_abc_impl' in comb:
+        del comb['_abc_impl']
+
+    attr = deepcopy(comb)
+    # Adjust module name
+    attr['__module__'] = 'freqtrade.strategy'
+
+    name = strategy.__class__.__name__
+    clazz = type(name, (IStrategy,), attr)
+
+    logger.debug(
+        'Imported strategy %s.%s as %s.%s',
+        strategy.__module__, strategy.__class__.__name__,
+        clazz.__module__, strategy.__class__.__name__,
+    )
+
+    # Modify global scope to declare class
+    globals()[name] = clazz
+
+    return clazz(config)

freqtrade/strategy/default_strategy.py

@@ -0,0 +1,272 @@
+# pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement
+
+import talib.abstract as ta
+from pandas import DataFrame
+
+import freqtrade.vendor.qtpylib.indicators as qtpylib
+from freqtrade.indicator_helpers import fishers_inverse
+from freqtrade.strategy.interface import IStrategy
+
+
+class DefaultStrategy(IStrategy):
+    """
+    Default Strategy provided by freqtrade bot.
+    You can override it with your own strategy
+    """
+
+    # Minimal ROI designed for the strategy
+    minimal_roi = {
+        "40": 0.0,
+        "30": 0.01,
+        "20": 0.02,
+        "0": 0.04
+    }
+
+    # Optimal stoploss designed for the strategy
+    stoploss = -0.10
+
+    # Optimal ticker interval for the strategy
+    ticker_interval = '5m'
+
+    # Optional order type mapping
+    order_types = {
+        'buy': 'limit',
+        'sell': 'limit',
+        'stoploss': 'limit',
+        'stoploss_on_exchange': False
+    }
+
+    # Optional time in force for orders
+    order_time_in_force = {
+        'buy': 'gtc',
+        'sell': 'gtc',
+    }
+
+    def informative_pairs(self):
+        """
+        Define additional, informative pair/interval combinations to be cached from the exchange.
+        These pair/interval combinations are non-tradeable, unless they are part
+        of the whitelist as well.
+        For more information, please consult the documentation
+        :return: List of tuples in the format (pair, interval)
+            Sample: return [("ETH/USDT", "5m"),
+                            ("BTC/USDT", "15m"),
+                            ]
+        """
+        return []
+
+    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Adds several different TA indicators to the given DataFrame
+
+        Performance Note: For the best performance be frugal on the number of indicators
+        you are using. Let uncomment only the indicator you are using in your strategies
+        or your hyperopt configuration, otherwise you will waste your memory and CPU usage.
+        :param dataframe: Raw data from the exchange and parsed by parse_ticker_dataframe()
+        :param metadata: Additional information, like the currently traded pair
+        :return: a Dataframe with all mandatory indicators for the strategies
+        """
+
+        # Momentum Indicator
+        # ------------------------------------
+
+        # ADX
+        dataframe['adx'] = ta.ADX(dataframe)
+
+        # Awesome oscillator
+        dataframe['ao'] = qtpylib.awesome_oscillator(dataframe)
+        """
+        # Commodity Channel Index: values Oversold:<-100, Overbought:>100
+        dataframe['cci'] = ta.CCI(dataframe)
+        """
+        # MACD
+        macd = ta.MACD(dataframe)
+        dataframe['macd'] = macd['macd']
+        dataframe['macdsignal'] = macd['macdsignal']
+        dataframe['macdhist'] = macd['macdhist']
+
+        # MFI
+        dataframe['mfi'] = ta.MFI(dataframe)
+
+        # Minus Directional Indicator / Movement
+        dataframe['minus_dm'] = ta.MINUS_DM(dataframe)
+        dataframe['minus_di'] = ta.MINUS_DI(dataframe)
+
+        # Plus Directional Indicator / Movement
+        dataframe['plus_dm'] = ta.PLUS_DM(dataframe)
+        dataframe['plus_di'] = ta.PLUS_DI(dataframe)
+        dataframe['minus_di'] = ta.MINUS_DI(dataframe)
+
+        """
+        # ROC
+        dataframe['roc'] = ta.ROC(dataframe)
+        """
+        # RSI
+        dataframe['rsi'] = ta.RSI(dataframe)
+
+        # Inverse Fisher transform on RSI, values [-1.0, 1.0] (https://goo.gl/2JGGoy)
+        dataframe['fisher_rsi'] = fishers_inverse(dataframe['rsi'])
+
+        # Inverse Fisher transform on RSI normalized, value [0.0, 100.0] (https://goo.gl/2JGGoy)
+        dataframe['fisher_rsi_norma'] = 50 * (dataframe['fisher_rsi'] + 1)
+
+        # Stoch
+        stoch = ta.STOCH(dataframe)
+        dataframe['slowd'] = stoch['slowd']
+        dataframe['slowk'] = stoch['slowk']
+
+        # Stoch fast
+        stoch_fast = ta.STOCHF(dataframe)
+        dataframe['fastd'] = stoch_fast['fastd']
+        dataframe['fastk'] = stoch_fast['fastk']
+        """
+        # Stoch RSI
+        stoch_rsi = ta.STOCHRSI(dataframe)
+        dataframe['fastd_rsi'] = stoch_rsi['fastd']
+        dataframe['fastk_rsi'] = stoch_rsi['fastk']
+        """
+
+        # Overlap Studies
+        # ------------------------------------
+
+        # Previous Bollinger bands
+        # Because ta.BBANDS implementation is broken with small numbers, it actually
+        # returns middle band for all the three bands. Switch to qtpylib.bollinger_bands
+        # and use middle band instead.
+        dataframe['blower'] = ta.BBANDS(dataframe, nbdevup=2, nbdevdn=2)['lowerband']
+
+        # Bollinger bands
+        bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
+        dataframe['bb_lowerband'] = bollinger['lower']
+        dataframe['bb_middleband'] = bollinger['mid']
+        dataframe['bb_upperband'] = bollinger['upper']
+
+        # EMA - Exponential Moving Average
+        dataframe['ema3'] = ta.EMA(dataframe, timeperiod=3)
+        dataframe['ema5'] = ta.EMA(dataframe, timeperiod=5)
+        dataframe['ema10'] = ta.EMA(dataframe, timeperiod=10)
+        dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50)
+        dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100)
+
+        # SAR Parabol
+        dataframe['sar'] = ta.SAR(dataframe)
+
+        # SMA - Simple Moving Average
+        dataframe['sma'] = ta.SMA(dataframe, timeperiod=40)
+
+        # TEMA - Triple Exponential Moving Average
+        dataframe['tema'] = ta.TEMA(dataframe, timeperiod=9)
+
+        # Cycle Indicator
+        # ------------------------------------
+        # Hilbert Transform Indicator - SineWave
+        hilbert = ta.HT_SINE(dataframe)
+        dataframe['htsine'] = hilbert['sine']
+        dataframe['htleadsine'] = hilbert['leadsine']
+
+        # Pattern Recognition - Bullish candlestick patterns
+        # ------------------------------------
+        """
+        # Hammer: values [0, 100]
+        dataframe['CDLHAMMER'] = ta.CDLHAMMER(dataframe)
+        # Inverted Hammer: values [0, 100]
+        dataframe['CDLINVERTEDHAMMER'] = ta.CDLINVERTEDHAMMER(dataframe)
+        # Dragonfly Doji: values [0, 100]
+        dataframe['CDLDRAGONFLYDOJI'] = ta.CDLDRAGONFLYDOJI(dataframe)
+        # Piercing Line: values [0, 100]
+        dataframe['CDLPIERCING'] = ta.CDLPIERCING(dataframe) # values [0, 100]
+        # Morningstar: values [0, 100]
+        dataframe['CDLMORNINGSTAR'] = ta.CDLMORNINGSTAR(dataframe) # values [0, 100]
+        # Three White Soldiers: values [0, 100]
+        dataframe['CDL3WHITESOLDIERS'] = ta.CDL3WHITESOLDIERS(dataframe) # values [0, 100]
+        """
+
+        # Pattern Recognition - Bearish candlestick patterns
+        # ------------------------------------
+        """
+        # Hanging Man: values [0, 100]
+        dataframe['CDLHANGINGMAN'] = ta.CDLHANGINGMAN(dataframe)
+        # Shooting Star: values [0, 100]
+        dataframe['CDLSHOOTINGSTAR'] = ta.CDLSHOOTINGSTAR(dataframe)
+        # Gravestone Doji: values [0, 100]
+        dataframe['CDLGRAVESTONEDOJI'] = ta.CDLGRAVESTONEDOJI(dataframe)
+        # Dark Cloud Cover: values [0, 100]
+        dataframe['CDLDARKCLOUDCOVER'] = ta.CDLDARKCLOUDCOVER(dataframe)
+        # Evening Doji Star: values [0, 100]
+        dataframe['CDLEVENINGDOJISTAR'] = ta.CDLEVENINGDOJISTAR(dataframe)
+        # Evening Star: values [0, 100]
+        dataframe['CDLEVENINGSTAR'] = ta.CDLEVENINGSTAR(dataframe)
+        """
+
+        # Pattern Recognition - Bullish/Bearish candlestick patterns
+        # ------------------------------------
+        """
+        # Three Line Strike: values [0, -100, 100]
+        dataframe['CDL3LINESTRIKE'] = ta.CDL3LINESTRIKE(dataframe)
+        # Spinning Top: values [0, -100, 100]
+        dataframe['CDLSPINNINGTOP'] = ta.CDLSPINNINGTOP(dataframe) # values [0, -100, 100]
+        # Engulfing: values [0, -100, 100]
+        dataframe['CDLENGULFING'] = ta.CDLENGULFING(dataframe) # values [0, -100, 100]
+        # Harami: values [0, -100, 100]
+        dataframe['CDLHARAMI'] = ta.CDLHARAMI(dataframe) # values [0, -100, 100]
+        # Three Outside Up/Down: values [0, -100, 100]
+        dataframe['CDL3OUTSIDE'] = ta.CDL3OUTSIDE(dataframe) # values [0, -100, 100]
+        # Three Inside Up/Down: values [0, -100, 100]
+        dataframe['CDL3INSIDE'] = ta.CDL3INSIDE(dataframe) # values [0, -100, 100]
+        """
+
+        # Chart type
+        # ------------------------------------
+        # Heikinashi stategy
+        heikinashi = qtpylib.heikinashi(dataframe)
+        dataframe['ha_open'] = heikinashi['open']
+        dataframe['ha_close'] = heikinashi['close']
+        dataframe['ha_high'] = heikinashi['high']
+        dataframe['ha_low'] = heikinashi['low']
+
+        return 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
+        :param metadata: Additional information, like the currently traded pair
+        :return: DataFrame with buy column
+        """
+        dataframe.loc[
+            (
+                (dataframe['rsi'] < 35) &
+                (dataframe['fastd'] < 35) &
+                (dataframe['adx'] > 30) &
+                (dataframe['plus_di'] > 0.5)
+            ) |
+            (
+                (dataframe['adx'] > 65) &
+                (dataframe['plus_di'] > 0.5)
+            ),
+            'buy'] = 1
+
+        return dataframe
+
+    def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Based on TA indicators, populates the sell signal for the given dataframe
+        :param dataframe: DataFrame
+        :param metadata: Additional information, like the currently traded pair
+        :return: DataFrame with buy column
+        """
+        dataframe.loc[
+            (
+                (
+                    (qtpylib.crossed_above(dataframe['rsi'], 70)) |
+                    (qtpylib.crossed_above(dataframe['fastd'], 70))
+                ) &
+                (dataframe['adx'] > 10) &
+                (dataframe['minus_di'] > 0)
+            ) |
+            (
+                (dataframe['adx'] > 70) &
+                (dataframe['minus_di'] > 0.5)
+            ),
+            'sell'] = 1
+        return dataframe

freqtrade/strategy/interface.py

@@ -0,0 +1,414 @@
+"""
+IStrategy interface
+This module defines the interface to apply for strategies
+"""
+import logging
+from abc import ABC, abstractmethod
+from datetime import datetime
+from enum import Enum
+from typing import Dict, List, NamedTuple, Tuple
+import warnings
+
+import arrow
+from pandas import DataFrame
+
+from freqtrade.data.dataprovider import DataProvider
+from freqtrade.misc import timeframe_to_minutes
+from freqtrade.persistence import Trade
+from freqtrade.wallets import Wallets
+
+logger = logging.getLogger(__name__)
+
+
+class SignalType(Enum):
+    """
+    Enum to distinguish between buy and sell signals
+    """
+    BUY = "buy"
+    SELL = "sell"
+
+
+class SellType(Enum):
+    """
+    Enum to distinguish between sell reasons
+    """
+    ROI = "roi"
+    STOP_LOSS = "stop_loss"
+    STOPLOSS_ON_EXCHANGE = "stoploss_on_exchange"
+    TRAILING_STOP_LOSS = "trailing_stop_loss"
+    SELL_SIGNAL = "sell_signal"
+    FORCE_SELL = "force_sell"
+    NONE = ""
+
+
+class SellCheckTuple(NamedTuple):
+    """
+    NamedTuple for Sell type + reason
+    """
+    sell_flag: bool
+    sell_type: SellType
+
+
+class IStrategy(ABC):
+    """
+    Interface for freqtrade strategies
+    Defines the mandatory structure must follow any custom strategies
+
+    Attributes you can use:
+        minimal_roi -> Dict: Minimal ROI designed for the strategy
+        stoploss -> float: optimal stoploss designed for the strategy
+        ticker_interval -> str: value of the ticker interval to use for the strategy
+    """
+
+    _populate_fun_len: int = 0
+    _buy_fun_len: int = 0
+    _sell_fun_len: int = 0
+    # associated minimal roi
+    minimal_roi: Dict
+
+    # associated stoploss
+    stoploss: float
+
+    # trailing stoploss
+    trailing_stop: bool = False
+    trailing_stop_positive: float
+    trailing_stop_positive_offset: float
+    trailing_only_offset_is_reached = False
+
+    # associated ticker interval
+    ticker_interval: str
+
+    # Optional order types
+    order_types: Dict = {
+        'buy': 'limit',
+        'sell': 'limit',
+        'stoploss': 'limit',
+        'stoploss_on_exchange': False,
+        'stoploss_on_exchange_interval': 60,
+    }
+
+    # Optional time in force
+    order_time_in_force: Dict = {
+        'buy': 'gtc',
+        'sell': 'gtc',
+    }
+
+    # run "populate_indicators" only for new candle
+    process_only_new_candles: bool = False
+
+    # Class level variables (intentional) containing
+    # the dataprovider (dp) (access to other candles, historic data, ...)
+    # and wallets - access to the current balance.
+    dp: DataProvider
+    wallets: Wallets
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        # Dict to determine if analysis is necessary
+        self._last_candle_seen_per_pair: Dict[str, datetime] = {}
+
+    @abstractmethod
+    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Populate indicators that will be used in the Buy and Sell strategy
+        :param dataframe: Raw data from the exchange and parsed by parse_ticker_dataframe()
+        :param metadata: Additional information, like the currently traded pair
+        :return: a Dataframe with all mandatory indicators for the strategies
+        """
+
+    @abstractmethod
+    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
+        :param metadata: Additional information, like the currently traded pair
+        :return: DataFrame with buy column
+        """
+
+    @abstractmethod
+    def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Based on TA indicators, populates the sell signal for the given dataframe
+        :param dataframe: DataFrame
+        :param metadata: Additional information, like the currently traded pair
+        :return: DataFrame with sell column
+        """
+
+    def informative_pairs(self) -> List[Tuple[str, str]]:
+        """
+        Define additional, informative pair/interval combinations to be cached from the exchange.
+        These pair/interval combinations are non-tradeable, unless they are part
+        of the whitelist as well.
+        For more information, please consult the documentation
+        :return: List of tuples in the format (pair, interval)
+            Sample: return [("ETH/USDT", "5m"),
+                            ("BTC/USDT", "15m"),
+                            ]
+        """
+        return []
+
+    def get_strategy_name(self) -> str:
+        """
+        Returns strategy class name
+        """
+        return self.__class__.__name__
+
+    def analyze_ticker(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Parses the given ticker history and returns a populated DataFrame
+        add several TA indicators and buy signal to it
+        :return DataFrame with ticker data and indicator data
+        """
+
+        pair = str(metadata.get('pair'))
+
+        # Test if seen this pair and last candle before.
+        # always run if process_only_new_candles is set to false
+        if (not self.process_only_new_candles or
+                self._last_candle_seen_per_pair.get(pair, None) != dataframe.iloc[-1]['date']):
+            # Defs that only make change on new candle data.
+            logger.debug("TA Analysis Launched")
+            dataframe = self.advise_indicators(dataframe, metadata)
+            dataframe = self.advise_buy(dataframe, metadata)
+            dataframe = self.advise_sell(dataframe, metadata)
+            self._last_candle_seen_per_pair[pair] = dataframe.iloc[-1]['date']
+        else:
+            logger.debug("Skipping TA Analysis for already analyzed candle")
+            dataframe['buy'] = 0
+            dataframe['sell'] = 0
+
+        # Other Defs in strategy that want to be called every loop here
+        # twitter_sell = self.watch_twitter_feed(dataframe, metadata)
+        logger.debug("Loop Analysis Launched")
+
+        return dataframe
+
+    def get_signal(self, pair: str, interval: str,
+                   dataframe: DataFrame) -> Tuple[bool, bool]:
+        """
+        Calculates current signal based several technical analysis indicators
+        :param pair: pair in format ANT/BTC
+        :param interval: Interval to use (in min)
+        :param dataframe: Dataframe to analyze
+        :return: (Buy, Sell) A bool-tuple indicating buy/sell signal
+        """
+        if not isinstance(dataframe, DataFrame) or dataframe.empty:
+            logger.warning('Empty ticker history for pair %s', pair)
+            return False, False
+
+        try:
+            dataframe = self.analyze_ticker(dataframe, {'pair': pair})
+        except ValueError as error:
+            logger.warning(
+                'Unable to analyze ticker for pair %s: %s',
+                pair,
+                str(error)
+            )
+            return False, False
+        except Exception as error:
+            logger.exception(
+                'Unexpected error when analyzing ticker for pair %s: %s',
+                pair,
+                str(error)
+            )
+            return False, False
+
+        if dataframe.empty:
+            logger.warning('Empty dataframe for pair %s', pair)
+            return False, False
+
+        latest = dataframe.iloc[-1]
+
+        # Check if dataframe is out of date
+        signal_date = arrow.get(latest['date'])
+        interval_minutes = timeframe_to_minutes(interval)
+        offset = self.config.get('exchange', {}).get('outdated_offset', 5)
+        if signal_date < (arrow.utcnow().shift(minutes=-(interval_minutes * 2 + offset))):
+            logger.warning(
+                'Outdated history for pair %s. Last tick is %s minutes old',
+                pair,
+                (arrow.utcnow() - signal_date).seconds // 60
+            )
+            return False, False
+
+        (buy, sell) = latest[SignalType.BUY.value] == 1, latest[SignalType.SELL.value] == 1
+        logger.debug(
+            'trigger: %s (pair=%s) buy=%s sell=%s',
+            latest['date'],
+            pair,
+            str(buy),
+            str(sell)
+        )
+        return buy, sell
+
+    def should_sell(self, trade: Trade, rate: float, date: datetime, buy: bool,
+                    sell: bool, low: float = None, high: float = None,
+                    force_stoploss: float = 0) -> SellCheckTuple:
+        """
+        This function evaluate if on the condition required to trigger a sell has been reached
+        if the threshold is reached and updates the trade record.
+        :param low: Only used during backtesting to simulate stoploss
+        :param high: Only used during backtesting, to simulate ROI
+        :param force_stoploss: Externally provided stoploss
+        :return: True if trade should be sold, False otherwise
+        """
+
+        # Set current rate to low for backtesting sell
+        current_rate = low or rate
+        current_profit = trade.calc_profit_percent(current_rate)
+
+        trade.adjust_min_max_rates(high or current_rate)
+
+        stoplossflag = self.stop_loss_reached(current_rate=current_rate, trade=trade,
+                                              current_time=date, current_profit=current_profit,
+                                              force_stoploss=force_stoploss, high=high)
+
+        if stoplossflag.sell_flag:
+            return stoplossflag
+
+        # Set current rate to high for backtesting sell
+        current_rate = high or rate
+        current_profit = trade.calc_profit_percent(current_rate)
+        experimental = self.config.get('experimental', {})
+
+        if buy and experimental.get('ignore_roi_if_buy_signal', False):
+            logger.debug('Buy signal still active - not selling.')
+            return SellCheckTuple(sell_flag=False, sell_type=SellType.NONE)
+
+        # Check if minimal roi has been reached and no longer in buy conditions (avoiding a fee)
+        if self.min_roi_reached(trade=trade, current_profit=current_profit, current_time=date):
+            logger.debug('Required profit reached. Selling..')
+            return SellCheckTuple(sell_flag=True, sell_type=SellType.ROI)
+
+        if experimental.get('sell_profit_only', False):
+            logger.debug('Checking if trade is profitable..')
+            if trade.calc_profit(rate=rate) <= 0:
+                return SellCheckTuple(sell_flag=False, sell_type=SellType.NONE)
+        if sell and not buy and experimental.get('use_sell_signal', False):
+            logger.debug('Sell signal received. Selling..')
+            return SellCheckTuple(sell_flag=True, sell_type=SellType.SELL_SIGNAL)
+
+        return SellCheckTuple(sell_flag=False, sell_type=SellType.NONE)
+
+    def stop_loss_reached(self, current_rate: float, trade: Trade,
+                          current_time: datetime, current_profit: float,
+                          force_stoploss: float, high: float = None) -> SellCheckTuple:
+        """
+        Based on current profit of the trade and configured (trailing) stoploss,
+        decides to sell or not
+        :param current_profit: current profit in percent
+        """
+
+        trailing_stop = self.config.get('trailing_stop', False)
+        stop_loss_value = force_stoploss if force_stoploss else self.stoploss
+
+        # Initiate stoploss with open_rate. Does nothing if stoploss is already set.
+        trade.adjust_stop_loss(trade.open_rate, stop_loss_value, initial=True)
+
+        if trailing_stop:
+            # trailing stoploss handling
+
+            sl_offset = self.config.get('trailing_stop_positive_offset') or 0.0
+            tsl_only_offset = self.config.get('trailing_only_offset_is_reached', False)
+
+            # Don't update stoploss if trailing_only_offset_is_reached is true.
+            if not (tsl_only_offset and current_profit < sl_offset):
+                # Specific handling for trailing_stop_positive
+                if 'trailing_stop_positive' in self.config and current_profit > sl_offset:
+                    # Ignore mypy error check in configuration that this is a float
+                    stop_loss_value = self.config.get('trailing_stop_positive')  # type: ignore
+                    logger.debug(f"using positive stop loss: {stop_loss_value} "
+                                 f"offset: {sl_offset:.4g} profit: {current_profit:.4f}%")
+
+                trade.adjust_stop_loss(high or current_rate, stop_loss_value)
+
+        # evaluate if the stoploss was hit if stoploss is not on exchange
+        if ((self.stoploss is not None) and
+            (trade.stop_loss >= current_rate) and
+                (not self.order_types.get('stoploss_on_exchange'))):
+
+            selltype = SellType.STOP_LOSS
+            # If Trailing stop (and max-rate did move above open rate)
+            if trailing_stop and trade.open_rate != trade.max_rate:
+                selltype = SellType.TRAILING_STOP_LOSS
+                logger.debug(
+                    f"HIT STOP: current price at {current_rate:.6f}, "
+                    f"stop loss is {trade.stop_loss:.6f}, "
+                    f"initial stop loss was at {trade.initial_stop_loss:.6f}, "
+                    f"trade opened at {trade.open_rate:.6f}")
+                logger.debug(f"trailing stop saved {trade.stop_loss - trade.initial_stop_loss:.6f}")
+
+            logger.debug('Stop loss hit.')
+            return SellCheckTuple(sell_flag=True, sell_type=selltype)
+
+        return SellCheckTuple(sell_flag=False, sell_type=SellType.NONE)
+
+    def min_roi_reached(self, trade: Trade, current_profit: float, current_time: datetime) -> bool:
+        """
+        Based an earlier trade and current price and ROI configuration, decides whether bot should
+        sell. Requires current_profit to be in percent!!
+        :return True if bot should sell at current rate
+        """
+
+        # Check if time matches and current rate is above threshold
+        trade_dur = (current_time.timestamp() - trade.open_date.timestamp()) / 60
+
+        # Get highest entry in ROI dict where key >= trade-duration
+        roi_entry = max(list(filter(lambda x: trade_dur >= x, self.minimal_roi.keys())))
+        threshold = self.minimal_roi[roi_entry]
+        if current_profit > threshold:
+            return True
+
+        return False
+
+    def tickerdata_to_dataframe(self, tickerdata: Dict[str, List]) -> Dict[str, DataFrame]:
+        """
+        Creates a dataframe and populates indicators for given ticker data
+        """
+        return {pair: self.advise_indicators(pair_data, {'pair': pair})
+                for pair, pair_data in tickerdata.items()}
+
+    def advise_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Populate indicators that will be used in the Buy and Sell strategy
+        This method should not be overridden.
+        :param dataframe: Raw data from the exchange and parsed by parse_ticker_dataframe()
+        :param metadata: Additional information, like the currently traded pair
+        :return: a Dataframe with all mandatory indicators for the strategies
+        """
+        if self._populate_fun_len == 2:
+            warnings.warn("deprecated - check out the Sample strategy to see "
+                          "the current function headers!", DeprecationWarning)
+            return self.populate_indicators(dataframe)  # type: ignore
+        else:
+            return self.populate_indicators(dataframe, metadata)
+
+    def advise_buy(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Based on TA indicators, populates the buy signal for the given dataframe
+        This method should not be overridden.
+        :param dataframe: DataFrame
+        :param pair: Additional information, like the currently traded pair
+        :return: DataFrame with buy column
+        """
+        if self._buy_fun_len == 2:
+            warnings.warn("deprecated - check out the Sample strategy to see "
+                          "the current function headers!", DeprecationWarning)
+            return self.populate_buy_trend(dataframe)  # type: ignore
+        else:
+            return self.populate_buy_trend(dataframe, metadata)
+
+    def advise_sell(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Based on TA indicators, populates the sell signal for the given dataframe
+        This method should not be overridden.
+        :param dataframe: DataFrame
+        :param pair: Additional information, like the currently traded pair
+        :return: DataFrame with sell column
+        """
+        if self._sell_fun_len == 2:
+            warnings.warn("deprecated - check out the Sample strategy to see "
+                          "the current function headers!", DeprecationWarning)
+            return self.populate_sell_trend(dataframe)  # type: ignore
+        else:
+            return self.populate_sell_trend(dataframe, metadata)

freqtrade/tests/data/test_btanalysis.py

@@ -0,0 +1,21 @@
+import pytest
+from pandas import DataFrame
+
+from freqtrade.data.btanalysis import BT_DATA_COLUMNS, load_backtest_data
+from freqtrade.data.history import make_testdata_path
+
+
+def test_load_backtest_data():
+
+    filename = make_testdata_path(None) / "backtest-result_test.json"
+    bt_data = load_backtest_data(filename)
+    assert isinstance(bt_data, DataFrame)
+    assert list(bt_data.columns) == BT_DATA_COLUMNS + ["profitabs"]
+    assert len(bt_data) == 179
+
+    # Test loading from string (must yield same result)
+    bt_data2 = load_backtest_data(str(filename))
+    assert bt_data.equals(bt_data2)
+
+    with pytest.raises(ValueError, match=r"File .* does not exist\."):
+        load_backtest_data(str("filename") + "nofile")

freqtrade/tests/data/test_converter.py

@@ -0,0 +1,99 @@
+# pragma pylint: disable=missing-docstring, C0103
+import logging
+
+from freqtrade.data.converter import parse_ticker_dataframe, ohlcv_fill_up_missing_data
+from freqtrade.data.history import load_pair_history
+from freqtrade.optimize import validate_backtest_data, get_timeframe
+from freqtrade.tests.conftest import log_has
+
+
+def test_dataframe_correct_columns(result):
+    assert result.columns.tolist() == ['date', 'open', 'high', 'low', 'close', 'volume']
+
+
+def test_parse_ticker_dataframe(ticker_history_list, caplog):
+    columns = ['date', 'open', 'high', 'low', 'close', 'volume']
+
+    caplog.set_level(logging.DEBUG)
+    # Test file with BV data
+    dataframe = parse_ticker_dataframe(ticker_history_list, '5m', fill_missing=True)
+    assert dataframe.columns.tolist() == columns
+    assert log_has('Parsing tickerlist to dataframe', caplog.record_tuples)
+
+
+def test_ohlcv_fill_up_missing_data(caplog):
+    data = load_pair_history(datadir=None,
+                             ticker_interval='1m',
+                             refresh_pairs=False,
+                             pair='UNITTEST/BTC',
+                             fill_up_missing=False)
+    caplog.set_level(logging.DEBUG)
+    data2 = ohlcv_fill_up_missing_data(data, '1m')
+    assert len(data2) > len(data)
+    # Column names should not change
+    assert (data.columns == data2.columns).all()
+
+    assert log_has(f"Missing data fillup: before: {len(data)} - after: {len(data2)}",
+                   caplog.record_tuples)
+
+    # Test fillup actually fixes invalid backtest data
+    min_date, max_date = get_timeframe({'UNITTEST/BTC': data})
+    assert validate_backtest_data({'UNITTEST/BTC': data}, min_date, max_date, 1)
+    assert not validate_backtest_data({'UNITTEST/BTC': data2}, min_date, max_date, 1)
+
+
+def test_ohlcv_fill_up_missing_data2(caplog):
+    ticker_interval = '5m'
+    ticks = [[
+            1511686200000,  # 8:50:00
+            8.794e-05,  # open
+            8.948e-05,  # high
+            8.794e-05,  # low
+            8.88e-05,  # close
+            2255,  # volume (in quote currency)
+        ],
+        [
+            1511686500000,  # 8:55:00
+            8.88e-05,
+            8.942e-05,
+            8.88e-05,
+            8.893e-05,
+            9911,
+        ],
+        [
+            1511687100000,  # 9:05:00
+            8.891e-05,
+            8.893e-05,
+            8.875e-05,
+            8.877e-05,
+            2251
+        ],
+        [
+            1511687400000,  # 9:10:00
+            8.877e-05,
+            8.883e-05,
+            8.895e-05,
+            8.817e-05,
+            123551
+    ]
+    ]
+
+    # Generate test-data without filling missing
+    data = parse_ticker_dataframe(ticks, ticker_interval, fill_missing=False)
+    assert len(data) == 3
+    caplog.set_level(logging.DEBUG)
+    data2 = ohlcv_fill_up_missing_data(data, ticker_interval)
+    assert len(data2) == 4
+    # 3rd candle has been filled
+    row = data2.loc[2, :]
+    assert row['volume'] == 0
+    # close shoult match close of previous candle
+    assert row['close'] == data.loc[1, 'close']
+    assert row['open'] == row['close']
+    assert row['high'] == row['close']
+    assert row['low'] == row['close']
+    # Column names should not change
+    assert (data.columns == data2.columns).all()
+
+    assert log_has(f"Missing data fillup: before: {len(data)} - after: {len(data2)}",
+                   caplog.record_tuples)

freqtrade/tests/data/test_dataprovider.py

@@ -0,0 +1,92 @@
+from unittest.mock import MagicMock
+
+from pandas import DataFrame
+
+from freqtrade.data.dataprovider import DataProvider
+from freqtrade.state import RunMode
+from freqtrade.tests.conftest import get_patched_exchange
+
+
+def test_ohlcv(mocker, default_conf, ticker_history):
+    default_conf["runmode"] = RunMode.DRY_RUN
+    ticker_interval = default_conf["ticker_interval"]
+    exchange = get_patched_exchange(mocker, default_conf)
+    exchange._klines[("XRP/BTC", ticker_interval)] = ticker_history
+    exchange._klines[("UNITTEST/BTC", ticker_interval)] = ticker_history
+    dp = DataProvider(default_conf, exchange)
+    assert dp.runmode == RunMode.DRY_RUN
+    assert ticker_history.equals(dp.ohlcv("UNITTEST/BTC", ticker_interval))
+    assert isinstance(dp.ohlcv("UNITTEST/BTC", ticker_interval), DataFrame)
+    assert dp.ohlcv("UNITTEST/BTC", ticker_interval) is not ticker_history
+    assert dp.ohlcv("UNITTEST/BTC", ticker_interval, copy=False) is ticker_history
+    assert not dp.ohlcv("UNITTEST/BTC", ticker_interval).empty
+    assert dp.ohlcv("NONESENSE/AAA", ticker_interval).empty
+
+    # Test with and without parameter
+    assert dp.ohlcv("UNITTEST/BTC", ticker_interval).equals(dp.ohlcv("UNITTEST/BTC"))
+
+    default_conf["runmode"] = RunMode.LIVE
+    dp = DataProvider(default_conf, exchange)
+    assert dp.runmode == RunMode.LIVE
+    assert isinstance(dp.ohlcv("UNITTEST/BTC", ticker_interval), DataFrame)
+
+    default_conf["runmode"] = RunMode.BACKTEST
+    dp = DataProvider(default_conf, exchange)
+    assert dp.runmode == RunMode.BACKTEST
+    assert dp.ohlcv("UNITTEST/BTC", ticker_interval).empty
+
+
+def test_historic_ohlcv(mocker, default_conf, ticker_history):
+
+    historymock = MagicMock(return_value=ticker_history)
+    mocker.patch("freqtrade.data.dataprovider.load_pair_history", historymock)
+
+    # exchange = get_patched_exchange(mocker, default_conf)
+    dp = DataProvider(default_conf, None)
+    data = dp.historic_ohlcv("UNITTEST/BTC", "5m")
+    assert isinstance(data, DataFrame)
+    assert historymock.call_count == 1
+    assert historymock.call_args_list[0][1]["datadir"] is None
+    assert historymock.call_args_list[0][1]["refresh_pairs"] is False
+    assert historymock.call_args_list[0][1]["ticker_interval"] == "5m"
+
+
+def test_available_pairs(mocker, default_conf, ticker_history):
+    exchange = get_patched_exchange(mocker, default_conf)
+
+    ticker_interval = default_conf["ticker_interval"]
+    exchange._klines[("XRP/BTC", ticker_interval)] = ticker_history
+    exchange._klines[("UNITTEST/BTC", ticker_interval)] = ticker_history
+    dp = DataProvider(default_conf, exchange)
+
+    assert len(dp.available_pairs) == 2
+    assert dp.available_pairs == [
+        ("XRP/BTC", ticker_interval),
+        ("UNITTEST/BTC", ticker_interval),
+    ]
+
+
+def test_refresh(mocker, default_conf, ticker_history):
+    refresh_mock = MagicMock()
+    mocker.patch("freqtrade.exchange.Exchange.refresh_latest_ohlcv", refresh_mock)
+
+    exchange = get_patched_exchange(mocker, default_conf, id="binance")
+    ticker_interval = default_conf["ticker_interval"]
+    pairs = [("XRP/BTC", ticker_interval), ("UNITTEST/BTC", ticker_interval)]
+
+    pairs_non_trad = [("ETH/USDT", ticker_interval), ("BTC/TUSD", "1h")]
+
+    dp = DataProvider(default_conf, exchange)
+    dp.refresh(pairs)
+
+    assert refresh_mock.call_count == 1
+    assert len(refresh_mock.call_args[0]) == 1
+    assert len(refresh_mock.call_args[0][0]) == len(pairs)
+    assert refresh_mock.call_args[0][0] == pairs
+
+    refresh_mock.reset_mock()
+    dp.refresh(pairs, pairs_non_trad)
+    assert refresh_mock.call_count == 1
+    assert len(refresh_mock.call_args[0]) == 1
+    assert len(refresh_mock.call_args[0][0]) == len(pairs) + len(pairs_non_trad)
+    assert refresh_mock.call_args[0][0] == pairs + pairs_non_trad