Merge branch 'develop' into fix/backtest_toomanyopen

2018-11-24 10:38:30 +01:00 · 2018-11-24 10:38:30 +01:00 · 805f509498
commit 805f509498
parent 59cd4fe0ef e4d9d72ff1
47 changed files with 2615 additions and 301 deletions
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -2,50 +2,52 @@
 ## Contribute to freqtrade
-Feel like our bot is missing a feature? We welcome your pull requests! Few pointers for contributions:
+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 
+- New features need to contain unit tests and must be PEP8 conformant (max-line-length = 100).
 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.
-**Before sending the PR:**
+## Before sending the PR:
-## 1. Run unit tests
+### 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
+#### Test the whole project
 ```bash
 pytest freqtrade
 ```
-### Test only one file
+#### Test only one file
 ```bash
 pytest freqtrade/tests/test_<file_name>.py
 ```
-### Test only one method from one file
+#### 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
+### 2. Test if your code is PEP8 compliant
-### Install packages
+#### Install packages
 ```bash
 pip3.6 install flake8 coveralls
 ```
-### Run Flake8
+#### Run Flake8
 ```bash
 flake8 freqtrade
@ -56,15 +58,15 @@ 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
+### 3. Test if all type-hints are correct
-### Install packages 
+#### Install packages 
 ``` bash
 pip3.6 install mypy
 ```
-### Run mypy
+#### Run mypy
 ``` bash
 mypy freqtrade
--- a/README.md
+++ b/README.md
@ -62,6 +62,7 @@ hesitate to read the source code and understand the mechanism of this bot.
 - [Requirements](#requirements)
  - [Min hardware required](#min-hardware-required)
  - [Software requirements](#software-requirements)
 - [Wanna help?]
 ## Quick start
@ -190,10 +191,14 @@ in the bug reports.
 ### [Pull Requests](https://github.com/freqtrade/freqtrade/pulls)
 Feel like our bot is missing a feature? We welcome your pull requests!
 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`.
@ -218,3 +223,4 @@ To run this bot we recommend you a cloud instance with a minimum of:
 - [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)
--- a/config.json.example
+++ b/config.json.example
@ -53,6 +53,21 @@
        "sell_profit_only": false,
        "ignore_roi_if_buy_signal": false
    },
    "edge": {
        "enabled": false,
        "process_throttle_secs": 3600,
        "calculate_since_number_of_days": 7,
        "total_capital_in_stake_currency": 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": "your_telegram_token",
--- a/config_full.json.example
+++ b/config_full.json.example
@ -33,6 +33,11 @@
        "order_book_min": 1,
        "order_book_max": 9
    },
    "order_types": {
        "buy": "limit",
        "sell": "limit",
        "stoploss": "market"
    },
    "exchange": {
        "name": "bittrex",
        "key": "your_exchange_key",
@ -59,6 +64,20 @@
        ],
        "outdated_offset": 5
    },
    "edge": {
        "enabled": false,
        "process_throttle_secs": 3600,
        "calculate_since_number_of_days": 2,
        "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,
--- a/docs/bot-usage.md
+++ b/docs/bot-usage.md
@ -204,6 +204,8 @@ optional arguments:
                        number)
  --timerange TIMERANGE
                        specify what timerange of data to use.
  --hyperopt PATH       specify hyperopt file (default:
                        freqtrade/optimize/default_hyperopt.py)
  -e INT, --epochs INT  specify number of epochs (default: 100)
  -s {all,buy,roi,stoploss} [{all,buy,roi,stoploss} ...], --spaces {all,buy,roi,stoploss} [{all,buy,roi,stoploss} ...]
                        Specify which parameters to hyperopt. Space separate
@ -211,6 +213,31 @@ optional arguments:
 ```
 ## Edge commands
 To know your trade expectacny and winrate against historical data, you can use Edge.
 ```
 usage: main.py 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 strategythe format is "min,max,step"
                        (without any space).example:
                        --stoplosses=-0.01,-0.1,-0.001
 ```
 ## A parameter missing in the configuration?
 All parameters for `main.py`, `backtesting`, `hyperopt` are referenced
--- a/docs/configuration.md
+++ b/docs/configuration.md
@ -17,7 +17,7 @@ The table below will list all configuration parameters.
 |  Command | Default | Mandatory | Description |
 |----------|---------|----------|-------------|
-| `max_open_trades` | 3 | Yes | Number of trades open your bot will have.
+| `max_open_trades` | 3 | Yes | Number of trades open your bot will have. If -1 then it is ignored (i.e. potentially unlimited open trades)
 | `stake_currency` | BTC | Yes | Crypto-currency used for trading.
 | `stake_amount` | 0.05 | Yes | 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 avaliable balance.
 | `ticker_interval` | [1m, 5m, 30m, 1h, 1d] | No | The ticker interval to use (1min, 5 min, 30 min, 1 hour or 1 day). Default is 5 minutes
@ -39,6 +39,7 @@ The table below will list all configuration parameters.
 | `ask_strategy.use_order_book` | false | No | Allows selling of open traded pair using the rates in Order Book Asks.
 | `ask_strategy.order_book_min` | 0 | No | Bot will scan from the top min to max Order Book Asks searching for a profitable rate.
 | `ask_strategy.order_book_max` | 0 | No | Bot will scan from the top min to max Order Book Asks searching for a profitable rate.
 | `order_types` | None | No | Configure order-types depending on the action (`"buy"`, `"sell"`, `"stoploss"`).
 | `exchange.name` | bittrex | Yes | Name of the exchange class to use. [List below](#user-content-what-values-for-exchangename).
 | `exchange.key` | key | No | API key to use for the exchange. Only required when you are in production mode.
 | `exchange.secret` | secret | No | API secret to use for the exchange. Only required when you are in production mode.
@ -47,6 +48,7 @@ The table below will list all configuration parameters.
 | `exchange.ccxt_rate_limit` | True | No | DEPRECATED!! Have CCXT handle Exchange rate limits. Depending on the exchange, having this to false can lead to temporary bans from the exchange.
 | `exchange.ccxt_config` | None | No | 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 | No | 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)
 | `edge` | false | No | Please refer to [edge configuration document](edge.md) for detailed explanation.
 | `experimental.use_sell_signal` | false | No | Use your sell strategy in addition of the `minimal_roi`.
 | `experimental.sell_profit_only` | false | No | waits until you have made a positive profit before taking a sell decision.
 | `experimental.ignore_roi_if_buy_signal` | false | No | Does not sell if the buy-signal is still active. Takes preference over `minimal_roi` and `use_sell_signal`
@ -137,6 +139,22 @@ 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
 `order_types` contains a dict mapping order-types to market-types. This allows to buy using limit orders, sell using limit-orders, and create stoploss orders using market.
 This can be set in the configuration or in the strategy. Configuration overwrites strategy configurations.
 If this is configured, all 3 values (`"buy"`, `"sell"` and `"stoploss"`) need to be present, otherwise the bot warn about it and will fail to start.
 The below is the default which is used if this is not configured in either Strategy or configuration.
 ``` json
    "order_types": {
        "buy": "limit",
        "sell": "limit",
        "stoploss": "market"
    },
 ```
 ### What values for exchange.name?
 Freqtrade is based on [CCXT library](https://github.com/ccxt/ccxt) that supports 115 cryptocurrency
--- a/docs/edge.md
+++ b/docs/edge.md
@ -0,0 +1,207 @@
 #  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.
 **NOTICE:** Edge positioning is not compatible with dynamic whitelist. it overrides dynamic whitelist.
 **NOTICE2:** Edge won't consider anything else than buy/sell/stoploss signals. So trailing stoploss, ROI, and everything else will be ignored in its calculation.
 ## Table of Contents
 - [Introduction](#introduction)
 - [How does it work?](#how-does-it-work?)
 - [Configurations](#configurations)
 - [Running Edge independently](#running-edge-independently)
 ## 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.<br/><br/>
 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 is quite boring, isn't it?<br/><br/>
 But let's say the probability that we have heads is 80%, 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.<br/><br/>
 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% * 2$ versus 20% * 8$. It is becoming boring again because overtime you win $1.6$ (80% x 2$) and me $1.6 (20% * 8$) too.<br/><br/>
 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
 Means over X trades 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) / (Number of losing trades)`
 ### Risk Reward Ratio
 Risk Reward Ratio 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
 So lets say your Win rate is 28% and your Risk Reward Ratio is 5:
 `Expectancy = (5 * 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 losers. 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 number 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 X trades for each stoploss. Here is an example:
 | Pair   |      Stoploss      |  Win Rate | Risk Reward Ratio | Expectancy |
 |----------|:-------------:|-------------:|------------------:|-----------:|
 | XZC/ETH  |  -0.03        |   0.52       |1.359670           | 0.228      |
 | XZC/ETH  |  -0.01        |   0.50       |1.176384           | 0.088      |
 | XZC/ETH  |  -0.02        |   0.51       |1.115941           | 0.079      |
 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 then forces stoploss to your strategy dynamically.
 ### Position size
 Edge 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** = **total capital** X **allowed risk per trade**
 **total capital** is your stake amount.
 **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 your stake amount is 3 ETH, you would allow 1% of risk for each trade. thus your allowed capital at risk would be **3 x 0.01 = 0.03 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.03 / 0.02= 1.5ETH**.<br/>
 ## Configurations
 Edge has following configurations:
 #### enabled
 If true, then Edge will run periodically<br/>
 (default to false)
 #### process_throttle_secs
 How often should Edge run in seconds? <br/>
 (default 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<br/>
 (default to 7)
 #### allowed_risk
 Percentage of allowed risk per trade<br/>
 (default to 0.01 [1%])
 #### stoploss_range_min
 Minimum stoploss <br/>
 (default to -0.01)
 #### stoploss_range_max
 Maximum stoploss <br/>
 (default 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. <br/>
 if you set this parameter to -0.001, you then slow down the Edge calculation by a factor of 10. <br/>
 (default to -0.01)
 #### minimum_winrate
 It filters 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 favor of risk reward ratio.<br/>
 (default to 0.60)
 #### minimum_expectancy
 It filters paris which have an expectancy lower than this number .
 Having an expectancy of 0.20 means if you put 10$ on a trade you expect a 12$ return.<br/>
 (default to 0.20)
 #### min_trade_number
 When calculating W and 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. <br/>
 (default 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.<br/>
 **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).<br/>
 (default to 1 day, 1440 = 60 * 24)
 #### 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.<br/>
 (default 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/main.py 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/main.py edge --refresh-pairs-cached
 ```
 ### Precising stoploss range
 ```bash
 python3 ./freqtrade/main.py edge --stoplosses=-0.01,-0.1,-0.001 #min,max,step
 ```
 ### Advanced use of timerange
 ```bash
 python3 ./freqtrade/main.py 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
--- a/docs/hyperopt.md
+++ b/docs/hyperopt.md
@ -19,18 +19,27 @@ and still take a long time.
 ## Prepare Hyperopting
-We recommend you start by taking a look at `hyperopt.py` file located in [freqtrade/optimize](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/optimize/hyperopt.py)
+Before we start digging in Hyperopt, we recommend you to take a look at 
 an example hyperopt file located into [user_data/hyperopts/](https://github.com/gcarq/freqtrade/blob/develop/user_data/hyperopts/test_hyperopt.py)
-### Configure your Guards and Triggers
+### 1. Install a Custom Hyperopt File
 This is very simple. Put your hyperopt file into the folder 
 `user_data/hyperopts`.
-There are two places you need to change to add a new buy strategy for testing:
+Let assume you want a hyperopt file `awesome_hyperopt.py`:
- Inside [populate_buy_trend()](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/optimize/hyperopt.py#L231-L264).
+1. Copy the file `user_data/hyperopts/sample_hyperopt.py` into `user_data/hyperopts/awesome_hyperopt.py`
 - Inside [hyperopt_space()](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/optimize/hyperopt.py#L213-L224) 
 and the associated methods `indicator_space`, `roi_space`, `stoploss_space`.
-There you have two different type of indicators: 1. `guards` and 2. `triggers`.
+ 
-1. Guards are conditions like "never buy if ADX < 10", or "never buy if 
+### 2. Configure your Guards and Triggers
-current price is over EMA10".
+There are two places you need to change in your hyperopt file to add a 
 new buy hyperopt for testing:
 - Inside [populate_buy_trend()](https://github.com/freqtrade/freqtrade/blob/develop/user_data/hyperopts/test_hyperopt.py#L230-L251).
 - Inside [indicator_space()](https://github.com/freqtrade/freqtrade/blob/develop/user_data/hyperopts/test_hyperopt.py#L207-L223).
 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".
@ -124,9 +133,12 @@ Because hyperopt tries a lot of combinations to find the best parameters it will
 We strongly recommend to use `screen` or `tmux` to prevent any connection loss.
 ```bash
-python3 ./freqtrade/main.py -c config.json hyperopt -e 5000
+python3 ./freqtrade/main.py -s <strategyname> --hyperopt <hyperoptname> -c config.json hyperopt -e 5000
 ```
 Use `<strategyname>` and `<hyperoptname>` as the names of the custom strategy 
 (only required for generating sells) and the custom hyperopt used.
 The `-e` flag will set how many evaluations hyperopt will do. We recommend
 running at least several thousand evaluations.
--- a/docs/index.md
+++ b/docs/index.md
@ -21,10 +21,12 @@ Pull-request. Do not hesitate to reach us on
    - [Bot commands](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#bot-commands)
    - [Backtesting commands](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#backtesting-commands)
    - [Hyperopt commands](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#hyperopt-commands)
    - [Edge commands](https://github.com/mishaker/freqtrade/blob/develop/docs/bot-usage.md#edge-commands)
 - [Bot Optimization](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md)
 	- [Change your strategy](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md#change-your-strategy)
    - [Add more Indicator](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md#add-more-indicator)
    - [Test your strategy with Backtesting](https://github.com/freqtrade/freqtrade/blob/develop/docs/backtesting.md)
    - [Edge positioning](https://github.com/mishaker/freqtrade/blob/money_mgt/docs/edge.md)
    - [Find optimal parameters with Hyperopt](https://github.com/freqtrade/freqtrade/blob/develop/docs/hyperopt.md)
 - [Control the bot with telegram](https://github.com/freqtrade/freqtrade/blob/develop/docs/telegram-usage.md)
 - [Receive notifications via webhook](https://github.com/freqtrade/freqtrade/blob/develop/docs/webhook-config.md)
--- a/freqtrade/arguments.py
+++ b/freqtrade/arguments.py
@ -104,6 +104,14 @@ class Arguments(object):
            type=str,
            metavar='PATH',
        )
        self.parser.add_argument(
            '--customhyperopt',
            help='specify hyperopt class name (default: %(default)s)',
            dest='hyperopt',
            default=constants.DEFAULT_HYPEROPT,
            type=str,
            metavar='NAME',
        )
        self.parser.add_argument(
            '--dynamic-whitelist',
            help='dynamically generate and update whitelist'
@ -128,6 +136,22 @@ class Arguments(object):
        """
        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='using live data',
@ -171,6 +195,27 @@ class Arguments(object):
            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:
        """
@ -184,6 +229,20 @@ class Arguments(object):
            dest='ticker_interval',
            type=str,
        )
        parser.add_argument(
            '--timerange',
            help='specify what timerange of data to use.',
            default=None,
            type=str,
            dest='timerange',
        )
    @staticmethod
    def hyperopt_options(parser: argparse.ArgumentParser) -> None:
        """
        Parses given arguments for Hyperopt scripts.
        """
        parser.add_argument(
            '--eps', '--enable-position-stacking',
            help='Allow buying the same pair multiple times (position stacking)',
@ -200,20 +259,6 @@ class Arguments(object):
            dest='use_max_market_positions',
            default=True
        )
        parser.add_argument(
            '--timerange',
            help='specify what timerange of data to use.',
            default=None,
            type=str,
            dest='timerange',
        )
    @staticmethod
    def hyperopt_options(parser: argparse.ArgumentParser) -> None:
        """
        Parses given arguments for Hyperopt scripts.
        """
        parser.add_argument(
            '-e', '--epochs',
            help='specify number of epochs (default: %(default)d)',
@ -237,7 +282,7 @@ class Arguments(object):
        Builds and attaches all subcommands
        :return: None
        """
-        from freqtrade.optimize import backtesting, hyperopt
+        from freqtrade.optimize import backtesting, hyperopt, edge_cli
        subparsers = self.parser.add_subparsers(dest='subparser')
@ -247,6 +292,12 @@ class Arguments(object):
        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)
--- a/freqtrade/configuration.py
+++ b/freqtrade/configuration.py
@ -33,6 +33,7 @@ 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) -> None:
        self.args = args
        self.config: Optional[Dict[str, Any]] = None
@ -52,12 +53,18 @@ class Configuration(object):
        if self.args.strategy_path:
            config.update({'strategy_path': self.args.strategy_path})
        # Add the hyperopt file to use
        config.update({'hyperopt': self.args.hyperopt})
        # 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)
@ -130,6 +137,10 @@ class Configuration(object):
        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
@ -213,6 +224,32 @@ class Configuration(object):
        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
--- a/freqtrade/constants.py
+++ b/freqtrade/constants.py
@ -9,9 +9,12 @@ 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'
 REQUIRED_ORDERTYPES = ['buy', 'sell', 'stoploss']
 ORDERTYPE_POSSIBILITIES = ['limit', 'market']
 TICKER_INTERVAL_MINUTES = {
@ -43,7 +46,7 @@ SUPPORTED_FIAT = [
 CONF_SCHEMA = {
    'type': 'object',
    'properties': {
-        'max_open_trades': {'type': 'integer', 'minimum': 0},
+        'max_open_trades': {'type': 'integer', 'minimum': -1},
        'ticker_interval': {'type': 'string', 'enum': list(TICKER_INTERVAL_MINUTES.keys())},
        'stake_currency': {'type': 'string', 'enum': ['BTC', 'XBT', 'ETH', 'USDT', 'EUR', 'USD']},
        'stake_amount': {
@ -101,7 +104,17 @@ CONF_SCHEMA = {
                '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}
            },
            'required': ['buy', 'sell', 'stoploss']
        },
        'exchange': {'$ref': '#/definitions/exchange'},
        'edge': {'$ref': '#/definitions/edge'},
        'experimental': {
            'type': 'object',
            'properties': {
@ -170,6 +183,23 @@ CONF_SCHEMA = {
                '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'},
                "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'}
            }
        }
    },
    'anyOf': [
--- a/freqtrade/edge/init.py
+++ b/freqtrade/edge/init.py
@ -0,0 +1,414 @@
 # pragma pylint: disable=W0603
 """ Edge positioning package """
 import logging
 from typing import Any, Dict, NamedTuple
 import arrow
 import numpy as np
 import utils_find_1st as utf1st
 from pandas import DataFrame
 import freqtrade.optimize as optimize
 from freqtrade.arguments import Arguments
 from freqtrade.arguments import TimeRange
 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 = optimize.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._total_capital: float = self.config['stake_amount']
        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 = optimize.load_data(
            self.config['datadir'],
            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
        # Not a nice hack but probably simplest solution:
        # When backtest load data it loads the delta between disk and exchange
        # The problem is that exchange consider that recent.
        # it is but it is incomplete (c.f. _async_get_candle_history)
        # So it causes get_signal to exit cause incomplete ticker_hist
        # A patch to that would be update _pairs_last_refresh_time of exchange
        # so it will download again all pairs
        # Another solution is to add new data to klines instead of reassigning it:
        # self.klines[pair].update(data) instead of self.klines[pair] = data in exchange package.
        # But that means indexing timestamp and having a verification so that
        # there is no empty range between two timestaps (recently added and last
        # one)
        self.exchange._pairs_last_refresh_time = {}
        return True
    def stake_amount(self, pair: str) -> float:
        stoploss = self._cached_pairs[pair].stoploss
        allowed_capital_at_risk = round(self._total_capital * self._allowed_risk, 5)
        position_size = abs(round((allowed_capital_at_risk / stoploss), 5))
        return position_size
    def stoploss(self, pair: str) -> float:
        return self._cached_pairs[pair].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 final:
            logger.info('Edge validated only %s', final)
        else:
            logger.info('Edge removed all pairs as no pair with minimum expectancy was found !')
        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
        stake = self.config.get('stake_amount')
        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, start_point=0):
        """
        Iterate through ohlc_columns recursively 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 calls itself cutting OHLC, buy_column, sell_colum and date_column
        Cut from (the exit trade index) + 1
        Author: https://github.com/mishaker
        """
        result: list = []
        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 of array
        if open_trade_index == -1 or open_trade_index == len(buy_column) - 1:
            return []
        else:
            open_trade_index += 1  # when a buy signal is seen,
            # trade opens in reality on the next candle
        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'):
            return []
        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:
                return []
            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)
        # Calling again the same function recursively but giving
        # it a view of exit_index till the end of array
        return result + self._detect_next_stop_or_sell_point(
            buy_column[exit_index:],
            sell_column[exit_index:],
            date_column[exit_index:],
            ohlc_columns[exit_index:],
            stoploss,
            pair,
            (start_point + exit_index)
        )
--- a/freqtrade/exchange/init.py
+++ b/freqtrade/exchange/init.py
@ -102,7 +102,7 @@ class Exchange(object):
        self.markets = self._load_markets()
        # Check if all pairs are available
        self.validate_pairs(config['exchange']['pair_whitelist'])
-
+        self.validate_ordertypes(config.get('order_types', {}))
        if config.get('ticker_interval'):
            # Check if timeframe is available
            self.validate_timeframes(config['ticker_interval'])
@ -218,6 +218,15 @@ class Exchange(object):
            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.')
    def exchange_has(self, endpoint: str) -> bool:
        """
        Checks if exchange implements a specific API endpoint.
@ -249,14 +258,14 @@ class Exchange(object):
            price = ceil(big_price) / pow(10, symbol_prec)
        return price
-    def buy(self, pair: str, rate: float, amount: float) -> Dict:
+    def buy(self, pair: str, ordertype: str, amount: float, rate: float) -> Dict:
        if self._conf['dry_run']:
            order_id = f'dry_run_buy_{randint(0, 10**6)}'
            self._dry_run_open_orders[order_id] = {
                'pair': pair,
                'price': rate,
                'amount': amount,
-                'type': 'limit',
+                'type': ordertype,
                'side': 'buy',
                'remaining': 0.0,
                'datetime': arrow.utcnow().isoformat(),
@ -268,9 +277,9 @@ class Exchange(object):
        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)
+            rate = self.symbol_price_prec(pair, rate) if ordertype != 'market' else None
-            return self._api.create_limit_buy_order(pair, amount, rate)
+            return self._api.create_order(pair, ordertype, 'buy', amount, rate)
        except ccxt.InsufficientFunds as e:
            raise DependencyException(
                f'Insufficient funds to create limit buy order on market {pair}.'
@ -287,14 +296,14 @@ class Exchange(object):
        except ccxt.BaseError as e:
            raise OperationalException(e)
-    def sell(self, pair: str, rate: float, amount: float) -> Dict:
+    def sell(self, pair: str, ordertype: str, amount: float, rate: float) -> Dict:
        if self._conf['dry_run']:
            order_id = f'dry_run_sell_{randint(0, 10**6)}'
            self._dry_run_open_orders[order_id] = {
                'pair': pair,
                'price': rate,
                'amount': amount,
-                'type': 'limit',
+                'type': ordertype,
                'side': 'sell',
                'remaining': 0.0,
                'datetime': arrow.utcnow().isoformat(),
@ -305,9 +314,9 @@ class Exchange(object):
        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)
+            rate = self.symbol_price_prec(pair, rate) if ordertype != 'market' else None
-            return self._api.create_limit_sell_order(pair, amount, rate)
+            return self._api.create_order(pair, ordertype, 'sell', amount, rate)
        except ccxt.InsufficientFunds as e:
            raise DependencyException(
                f'Insufficient funds to create limit sell order on market {pair}.'
--- a/freqtrade/freqtradebot.py
+++ b/freqtrade/freqtradebot.py
@ -17,6 +17,8 @@ from cachetools import TTLCache, cached
 from freqtrade import (DependencyException, OperationalException,
                       TemporaryError, __version__, constants, persistence)
 from freqtrade.exchange import Exchange
 from freqtrade.wallets import Wallets
 from freqtrade.edge import Edge
 from freqtrade.persistence import Trade
 from freqtrade.rpc import RPCManager, RPCMessageType
 from freqtrade.state import State
@ -24,6 +26,7 @@ from freqtrade.strategy.interface import SellType
 from freqtrade.strategy.resolver import IStrategy, StrategyResolver
 from freqtrade.exchange.exchange_helpers import order_book_to_dataframe
 logger = logging.getLogger(__name__)
@ -54,6 +57,12 @@ class FreqtradeBot(object):
        self.rpc: RPCManager = RPCManager(self)
        self.persistence = None
        self.exchange = Exchange(self.config)
        self.wallets = Wallets(self.exchange)
        # 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']
        self._init_modules()
@ -133,7 +142,7 @@ class FreqtradeBot(object):
                      f'*Strategy:* `{strategy_name}`'
        })
        if self.config.get('dynamic_whitelist', False):
-            top_pairs = 'top ' + str(self.config.get('dynamic_whitelist', 20))
+            top_pairs = 'top volume ' + str(self.config.get('dynamic_whitelist', 20))
            specific_pairs = ''
        else:
            top_pairs = 'whitelisted'
@ -179,6 +188,14 @@ class FreqtradeBot(object):
            # Keep only the subsets of pairs wanted (up to nb_assets)
            self.active_pair_whitelist = sanitized_list[:nb_assets] if nb_assets else sanitized_list
            # Calculating Edge positiong
            # Should be called before refresh_tickers
            # Otherwise it will override cached klines in exchange
            # with delta value (klines only from last refresh_pairs)
            if self.edge:
                self.edge.calculate()
                self.active_pair_whitelist = self.edge.adjust(self.active_pair_whitelist)
            # Query trades from persistence layer
            trades = Trade.query.filter(Trade.is_open.is_(True)).all()
@ -309,14 +326,20 @@ class FreqtradeBot(object):
        return used_rate
-    def _get_trade_stake_amount(self) -> Optional[float]:
+    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:
            stake_amount = self.edge.stake_amount(pair)
        else:
            stake_amount = self.config['stake_amount']
        # TODO: should come from the wallet
        avaliable_amount = self.exchange.get_balance(self.config['stake_currency'])
        # avaliable_amount = self.wallets.wallets[self.config['stake_currency']].free
        if stake_amount == constants.UNLIMITED_STAKE_AMOUNT:
            open_trades = len(Trade.query.filter(Trade.is_open.is_(True)).all())
@ -373,15 +396,6 @@ class FreqtradeBot(object):
        :return: True if a trade object has been created and persisted, False otherwise
        """
        interval = self.strategy.ticker_interval
        stake_amount = self._get_trade_stake_amount()
        if not stake_amount:
            return False
        logger.info(
            'Checking buy signals to create a new trade with stake_amount: %f ...',
            stake_amount
        )
        whitelist = copy.deepcopy(self.active_pair_whitelist)
        # Remove currently opened and latest pairs from whitelist
@ -394,10 +408,18 @@ class FreqtradeBot(object):
            raise DependencyException('No currency pairs in whitelist')
        # running get_signal on historical data fetched
        # to find buy signals
        for _pair in whitelist:
            (buy, sell) = self.strategy.get_signal(_pair, interval, self.exchange.klines.get(_pair))
            if buy and not sell:
                stake_amount = self._get_trade_stake_amount(_pair)
                if not stake_amount:
                    return False
                logger.info(
                    '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\
@ -454,7 +476,8 @@ class FreqtradeBot(object):
        amount = stake_amount / buy_limit
-        order_id = self.exchange.buy(pair, buy_limit, amount)['id']
+        order_id = self.exchange.buy(pair=pair, ordertype=self.strategy.order_types['buy'],
                                     amount=amount, rate=buy_limit)['id']
        self.rpc.send_msg({
            'type': RPCMessageType.BUY_NOTIFICATION,
@ -484,6 +507,10 @@ class FreqtradeBot(object):
        )
        Trade.session.add(trade)
        Trade.session.flush()
        # Updating wallets
        self.wallets.update()
        return True
    def process_maybe_execute_buy(self) -> bool:
@ -528,7 +555,14 @@ class FreqtradeBot(object):
            if trade.is_open and trade.open_order_id is None:
                # Check if we can sell our current pair
-                return self.handle_trade(trade)
+                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
@ -624,10 +658,16 @@ class FreqtradeBot(object):
        return False
    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('excuted sell')
+            logger.info('executed sell, reason: %s', should_sell.sell_type)
            return True
        return False
@ -661,14 +701,17 @@ class FreqtradeBot(object):
            # Check if trade is still actually open
            if int(order['remaining']) == 0:
                self.wallets.update()
                continue
            # Check if trade is still actually open
            if 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()
    # FIX: 20180110, why is cancel.order unconditionally here, whereas
    #                it is conditionally called in the
@ -735,8 +778,13 @@ class FreqtradeBot(object):
        :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'
        # Execute sell and update trade record
-        order_id = self.exchange.sell(str(trade.pair), limit, trade.amount)['id']
+        order_id = self.exchange.sell(pair=str(trade.pair),
                                      ordertype=self.strategy.order_types[sell_type],
                                      amount=trade.amount, rate=limit)['id']
        trade.open_order_id = order_id
        trade.close_rate_requested = limit
        trade.sell_reason = sell_reason.value
--- a/freqtrade/optimize/init.py
+++ b/freqtrade/optimize/init.py
@ -20,6 +20,7 @@ from pandas import DataFrame
 from freqtrade import misc, constants, OperationalException
 from freqtrade.exchange import Exchange
 from freqtrade.arguments import TimeRange
 from freqtrade.optimize.default_hyperopt import DefaultHyperOpts  # noqa: F401
 logger = logging.getLogger(__name__)
--- a/freqtrade/optimize/default_hyperopt.py
+++ b/freqtrade/optimize/default_hyperopt.py
@ -0,0 +1,130 @@
 # 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['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 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 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'),
        ]
--- a/freqtrade/optimize/edge_cli.py
+++ b/freqtrade/optimize/edge_cli.py
@ -0,0 +1,106 @@
 # pragma pylint: disable=missing-docstring, W0212, too-many-arguments
 """
 This module contains the backtesting logic
 """
 import logging
 from argparse import Namespace
 from typing import Dict, Any
 from tabulate import tabulate
 from freqtrade.edge import Edge
 from freqtrade.configuration import Configuration
 from freqtrade.arguments import Arguments
 from freqtrade.exchange import Exchange
 from freqtrade.strategy.resolver import StrategyResolver
 logger = logging.getLogger(__name__)
 class EdgeCli(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 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)
                ])
        return tabulate(tabular_data, headers=headers, 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 the backtesting
    :param args: Cli args from Arguments()
    :return: Configuration
    """
    configuration = Configuration(args)
    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()
--- a/freqtrade/optimize/hyperopt.py
+++ b/freqtrade/optimize/hyperopt.py
@ -9,22 +9,21 @@ import multiprocessing
 import os
 import sys
 from argparse import Namespace
 from functools import reduce
 from math import exp
 from operator import itemgetter
-from typing import Any, Callable, Dict, List
+from typing import Any, Dict, List
 import talib.abstract as ta
 from pandas import DataFrame
-from sklearn.externals.joblib import Parallel, delayed, dump, load
+from joblib import Parallel, delayed, dump, load, wrap_non_picklable_objects
 from skopt import Optimizer
-from skopt.space import Categorical, Dimension, Integer, Real
+from skopt.space import Dimension
 import freqtrade.vendor.qtpylib.indicators as qtpylib
 from freqtrade.arguments import Arguments
 from freqtrade.configuration import Configuration
 from freqtrade.optimize import load_data, get_timeframe
 from freqtrade.optimize.backtesting import Backtesting
 from freqtrade.optimize.hyperopt_resolver import HyperOptResolver
 logger = logging.getLogger(__name__)
@ -42,6 +41,9 @@ class Hyperopt(Backtesting):
    """
    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
@ -74,24 +76,6 @@ class Hyperopt(Backtesting):
        arg_dict = {dim.name: value for dim, value in zip(dimensions, params)}
        return arg_dict
    @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['sar'] = ta.SAR(dataframe)
        return dataframe
    def save_trials(self) -> None:
        """
        Save hyperopt trials to file
@ -121,7 +105,8 @@ class Hyperopt(Backtesting):
            best_result['params']
        )
        if 'roi_t1' in best_result['params']:
-            logger.info('ROI table:\n%s', self.generate_roi_table(best_result['params']))
+            logger.info('ROI table:\n%s',
                        self.custom_hyperopt.generate_roi_table(best_result['params']))
    def log_results(self, results) -> None:
        """
@ -149,59 +134,6 @@ class Hyperopt(Backtesting):
        result = trade_loss + profit_loss + duration_loss
        return result
    @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 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'),
        ]
    @staticmethod
    def stoploss_space() -> List[Dimension]:
        """
        Stoploss search space
        """
        return [
            Real(-0.5, -0.02, name='stoploss'),
        ]
    @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')
        ]
    def has_space(self, space: str) -> bool:
        """
        Tell if a space value is contained in the configuration
@ -216,61 +148,20 @@ class Hyperopt(Backtesting):
        """
        spaces: List[Dimension] = []
        if self.has_space('buy'):
-            spaces += Hyperopt.indicator_space()
+            spaces += self.custom_hyperopt.indicator_space()
        if self.has_space('roi'):
-            spaces += Hyperopt.roi_space()
+            spaces += self.custom_hyperopt.roi_space()
        if self.has_space('stoploss'):
-            spaces += Hyperopt.stoploss_space()
+            spaces += self.custom_hyperopt.stoploss_space()
        return spaces
-    @staticmethod
+    def generate_optimizer(self, _params: Dict) -> Dict:
    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 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
    def generate_optimizer(self, _params) -> Dict:
        params = self.get_args(_params)
        if self.has_space('roi'):
-            self.strategy.minimal_roi = self.generate_roi_table(params)
+            self.strategy.minimal_roi = self.custom_hyperopt.generate_roi_table(params)
        if self.has_space('buy'):
-            self.advise_buy = self.buy_strategy_generator(params)
+            self.advise_buy = self.custom_hyperopt.buy_strategy_generator(params)
        if self.has_space('stoploss'):
            self.strategy.stoploss = params['stoploss']
@ -332,7 +223,8 @@ class Hyperopt(Backtesting):
        )
    def run_optimizer_parallel(self, parallel, asked) -> List:
-        return parallel(delayed(self.generate_optimizer)(v) for v in asked)
+        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 """
@ -354,7 +246,8 @@ class Hyperopt(Backtesting):
        )
        if self.has_space('buy'):
-            self.strategy.advise_indicators = Hyperopt.populate_indicators  # type: ignore
+            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()
--- a/freqtrade/optimize/hyperopt_interface.py
+++ b/freqtrade/optimize/hyperopt_interface.py
@ -0,0 +1,66 @@
 """
 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 indicator_space() -> List[Dimension]:
        """
        Create an 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
        """
--- a/freqtrade/optimize/hyperopt_resolver.py
+++ b/freqtrade/optimize/hyperopt_resolver.py
@ -0,0 +1,104 @@
 # pragma pylint: disable=attribute-defined-outside-init
 """
 This module load custom hyperopts
 """
 import importlib.util
 import inspect
 import logging
 import os
 from typing import Optional, Dict, Type
 from freqtrade.constants import DEFAULT_HYPEROPT
 from freqtrade.optimize.hyperopt_interface import IHyperOpt
 logger = logging.getLogger(__name__)
 class HyperOptResolver(object):
    """
    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'))
    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 = os.path.dirname(os.path.realpath(__file__))
        abs_paths = [
            os.path.join(current_path, '..', '..', 'user_data', 'hyperopts'),
            current_path,
        ]
        if extra_dir:
            # Add extra hyperopt directory on top of search paths
            abs_paths.insert(0, extra_dir)
        for path in abs_paths:
            hyperopt = self._search_hyperopt(path, hyperopt_name)
            if hyperopt:
                logger.info('Using resolved hyperopt %s from \'%s\'', hyperopt_name, path)
                return hyperopt
        raise ImportError(
            "Impossible to load Hyperopt '{}'. This class does not exist"
            " or contains Python code errors".format(hyperopt_name)
        )
    @staticmethod
    def _get_valid_hyperopts(module_path: str, hyperopt_name: str) -> Optional[Type[IHyperOpt]]:
        """
        Returns a list of all possible hyperopts for the given module_path
        :param module_path: absolute path to the module
        :param hyperopt_name: Class name of the hyperopt
        :return: Tuple with (name, class) or None
        """
        # Generate spec based on absolute path
        spec = importlib.util.spec_from_file_location('user_data.hyperopts', module_path)
        module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(module)  # type: ignore # importlib does not use typehints
        valid_hyperopts_gen = (
            obj for name, obj in inspect.getmembers(module, inspect.isclass)
            if hyperopt_name == name and IHyperOpt in obj.__bases__
        )
        return next(valid_hyperopts_gen, None)
    @staticmethod
    def _search_hyperopt(directory: str, hyperopt_name: str) -> Optional[IHyperOpt]:
        """
        Search for the hyperopt_name in the given directory
        :param directory: relative or absolute directory path
        :return: name of the hyperopt class
        """
        logger.debug('Searching for hyperopt %s in \'%s\'', hyperopt_name, directory)
        for entry in os.listdir(directory):
            # Only consider python files
            if not entry.endswith('.py'):
                logger.debug('Ignoring %s', entry)
                continue
            hyperopt = HyperOptResolver._get_valid_hyperopts(
                os.path.abspath(os.path.join(directory, entry)), hyperopt_name
            )
            if hyperopt:
                return hyperopt()
        return None
--- a/freqtrade/rpc/rpc.py
+++ b/freqtrade/rpc/rpc.py
@ -410,7 +410,7 @@ class RPC(object):
            raise RPCException(f'position for {pair} already open - id: {trade.id}')
        # gen stake amount
-        stakeamount = self._freqtrade._get_trade_stake_amount()
+        stakeamount = self._freqtrade._get_trade_stake_amount(pair)
        # execute buy
        if self._freqtrade.execute_buy(pair, stakeamount, price):
@ -443,3 +443,10 @@ class RPC(object):
            raise RPCException('trader is not running')
        return Trade.query.filter(Trade.is_open.is_(True)).all()
    def _rpc_whitelist(self) -> Dict:
        """ Returns the currently active whitelist"""
        res = {'method': self._freqtrade.config.get('dynamic_whitelist', 0) or 'static',
               'whitelist': self._freqtrade.active_pair_whitelist
               }
        return res
--- a/freqtrade/rpc/telegram.py
+++ b/freqtrade/rpc/telegram.py
@ -91,6 +91,7 @@ class Telegram(RPC):
            CommandHandler('daily', self._daily),
            CommandHandler('count', self._count),
            CommandHandler('reload_conf', self._reload_conf),
            CommandHandler('whitelist', self._whitelist),
            CommandHandler('help', self._help),
            CommandHandler('version', self._version),
        ]
@ -438,6 +439,25 @@ class Telegram(RPC):
        except RPCException as e:
            self._send_msg(str(e), bot=bot)
    @authorized_only
    def _whitelist(self, bot: Bot, update: Update) -> None:
        """
        Handler for /whitelist
        Shows the currently active whitelist
        """
        try:
            whitelist = self._rpc_whitelist()
            if whitelist['method'] == 'static':
                message = f"Using static whitelist with `{len(whitelist['whitelist'])}` pairs \n"
            else:
                message = f"Dynamic whitelist with `{whitelist['method']}` pairs\n"
            message += f"`{', '.join(whitelist['whitelist'])}`"
            logger.debug(message)
            self._send_msg(message)
        except RPCException as e:
            self._send_msg(str(e), bot=bot)
    @authorized_only
    def _help(self, bot: Bot, update: Update) -> None:
        """
@ -460,6 +480,7 @@ class Telegram(RPC):
                  "\n" \
                  "*/balance:* `Show account balance per currency`\n" \
                  "*/reload_conf:* `Reload configuration file` \n" \
                  "*/whitelist:* `Show current whitelist` \n" \
                  "*/help:* `This help message`\n" \
                  "*/version:* `Show version`"
--- a/freqtrade/strategy/default_strategy.py
+++ b/freqtrade/strategy/default_strategy.py
@ -28,6 +28,13 @@ class DefaultStrategy(IStrategy):
    # Optimal ticker interval for the strategy
    ticker_interval = '5m'
    # Optional order type mapping
    order_types = {
        'buy': 'limit',
        'sell': 'limit',
        'stoploss': 'limit'
    }
    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        Adds several different TA indicators to the given DataFrame
--- a/freqtrade/strategy/interface.py
+++ b/freqtrade/strategy/interface.py
@ -70,6 +70,13 @@ class IStrategy(ABC):
    # associated ticker interval
    ticker_interval: str
    # Optional order types
    order_types: Dict = {
        'buy': 'limit',
        'sell': 'limit',
        'stoploss': 'limit'
    }
    # run "populate_indicators" only for new candle
    process_only_new_candles: bool = False
@ -203,17 +210,20 @@ class IStrategy(ABC):
        return buy, sell
    def should_sell(self, trade: Trade, rate: float, date: datetime, buy: bool,
-                    sell: bool, low: float = None, high: float = None) -> SellCheckTuple:
+                    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.
        :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)
        stoplossflag = self.stop_loss_reached(current_rate=current_rate, trade=trade,
-                                              current_time=date, current_profit=current_profit)
+                                              current_time=date, current_profit=current_profit,
                                              force_stoploss=force_stoploss)
        if stoplossflag.sell_flag:
            return stoplossflag
        # Set current rate to low for backtesting sell
@ -241,7 +251,7 @@ class IStrategy(ABC):
        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) -> SellCheckTuple:
+                          current_profit: float, force_stoploss: float) -> SellCheckTuple:
        """
        Based on current profit of the trade and configured (trailing) stoploss,
        decides to sell or not
@ -250,7 +260,8 @@ class IStrategy(ABC):
        trailing_stop = self.config.get('trailing_stop', False)
-        trade.adjust_stop_loss(trade.open_rate, self.stoploss, initial=True)
+        trade.adjust_stop_loss(trade.open_rate, force_stoploss if force_stoploss
                               else self.stoploss, initial=True)
        # evaluate if the stoploss was hit
        if self.stoploss is not None and trade.stop_loss >= current_rate:
--- a/freqtrade/strategy/resolver.py
+++ b/freqtrade/strategy/resolver.py
@ -75,6 +75,19 @@ class StrategyResolver(object):
        else:
            config['process_only_new_candles'] = self.strategy.process_only_new_candles
        if 'order_types' in config:
            self.strategy.order_types = config['order_types']
            logger.info(
                "Override strategy 'order_types' with value in config file: %s.",
                config['order_types']
            )
        else:
            config['order_types'] = self.strategy.order_types
        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.")
        # Sort and apply type conversions
        self.strategy.minimal_roi = OrderedDict(sorted(
            {int(key): value for (key, value) in self.strategy.minimal_roi.items()}.items(),
--- a/freqtrade/tests/conftest.py
+++ b/freqtrade/tests/conftest.py
@ -4,6 +4,7 @@ import logging
 from datetime import datetime
 from functools import reduce
 from typing import Dict, Optional
 from collections import namedtuple
 from unittest.mock import MagicMock, PropertyMock
 import arrow
@ -12,6 +13,7 @@ from telegram import Chat, Message, Update
 from freqtrade.exchange.exchange_helpers import parse_ticker_dataframe
 from freqtrade.exchange import Exchange
 from freqtrade.edge import Edge
 from freqtrade.freqtradebot import FreqtradeBot
 logging.getLogger('').setLevel(logging.INFO)
@ -28,6 +30,7 @@ def log_has(line, logs):
 def patch_exchange(mocker, api_mock=None) -> None:
    mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
    mocker.patch('freqtrade.exchange.Exchange.validate_timeframes', MagicMock())
    mocker.patch('freqtrade.exchange.Exchange.validate_ordertypes', MagicMock())
    mocker.patch('freqtrade.exchange.Exchange.name', PropertyMock(return_value="Bittrex"))
    mocker.patch('freqtrade.exchange.Exchange.id', PropertyMock(return_value="bittrex"))
    if api_mock:
@ -42,7 +45,32 @@ def get_patched_exchange(mocker, config, api_mock=None) -> Exchange:
    return exchange
 def patch_edge(mocker) -> None:
    # "ETH/BTC",
    # "LTC/BTC",
    # "XRP/BTC",
    # "NEO/BTC"
    pair_info = namedtuple(
        'pair_info',
        'stoploss, winrate, risk_reward_ratio, required_risk_reward, expectancy')
    mocker.patch('freqtrade.edge.Edge._cached_pairs', mocker.PropertyMock(
        return_value={
            'NEO/BTC': pair_info(-0.20, 0.66, 3.71, 0.50, 1.71),
            'LTC/BTC': pair_info(-0.21, 0.66, 3.71, 0.50, 1.71),
        }
    ))
    mocker.patch('freqtrade.edge.Edge.stoploss', MagicMock(return_value=-0.20))
    mocker.patch('freqtrade.edge.Edge.calculate', MagicMock(return_value=True))
 def get_patched_edge(mocker, config) -> Edge:
    patch_edge(mocker)
    edge = Edge(config)
    return edge
 # Functions for recurrent object patching
 def get_patched_freqtradebot(mocker, config) -> FreqtradeBot:
    """
    This function patch _init_modules() to not call dependencies
@ -752,3 +780,23 @@ def buy_order_fee():
        'status': 'closed',
        'fee': None
    }
@pytest.fixture(scope="function")
 def edge_conf(default_conf):
    default_conf['edge'] = {
        "enabled": True,
        "process_throttle_secs": 1800,
        "calculate_since_number_of_days": 14,
        "allowed_risk": 0.01,
        "stoploss_range_min": -0.01,
        "stoploss_range_max": -0.1,
        "stoploss_range_step": -0.01,
        "maximum_winrate": 0.80,
        "minimum_expectancy": 0.20,
        "min_trade_number": 15,
        "max_trade_duration_minute": 1440,
        "remove_pumps": False
    }
    return default_conf
--- a/freqtrade/tests/edge/init.py
+++ b/freqtrade/tests/edge/init.py
--- a/freqtrade/tests/edge/test_edge.py
+++ b/freqtrade/tests/edge/test_edge.py
@ -0,0 +1,310 @@
 # pragma pylint: disable=missing-docstring, C0103, C0330
 # pragma pylint: disable=protected-access, too-many-lines, invalid-name, too-many-arguments
 import pytest
 import logging
 from freqtrade.tests.conftest import get_patched_freqtradebot
 from freqtrade.edge import Edge, PairInfo
 from pandas import DataFrame, to_datetime
 from freqtrade.strategy.interface import SellType
 from freqtrade.tests.optimize import (BTrade, BTContainer, _build_backtest_dataframe,
                                      _get_frame_time_from_offset)
 import arrow
 import numpy as np
 import math
 from unittest.mock import MagicMock
 # Cases to be tested:
 # 1) Open trade should be removed from the end
 # 2) Two complete trades within dataframe (with sell hit for all)
 # 3) Entered, sl 1%, candle drops 8% => Trade closed, 1% loss
 # 4) Entered, sl 3%, candle drops 4%, recovers to 1% => Trade closed, 3% loss
 # 5) Stoploss and sell are hit. should sell on stoploss
 ####################################################################
 ticker_start_time = arrow.get(2018, 10, 3)
 ticker_interval_in_minute = 60
 _ohlc = {'date': 0, 'buy': 1, 'open': 2, 'high': 3, 'low': 4, 'close': 5, 'sell': 6, 'volume': 7}
 # Open trade should be removed from the end
 tc0 = BTContainer(data=[
    # D  O     H     L     C     V    B  S
    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
    [1, 5000, 5025, 4975, 4987, 6172, 0, 1]],  # enter trade (signal on last candle)
    stop_loss=-0.99, roi=float('inf'), profit_perc=0.00,
    trades=[]
 )
 # Two complete trades within dataframe(with sell hit for all)
 tc1 = BTContainer(data=[
    # D  O     H     L     C     V    B  S
    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
    [1, 5000, 5025, 4975, 4987, 6172, 0, 1],  # enter trade (signal on last candle)
    [2, 5000, 5025, 4975, 4987, 6172, 0, 0],  # exit at open
    [3, 5000, 5025, 4975, 4987, 6172, 1, 0],  # no action
    [4, 5000, 5025, 4975, 4987, 6172, 0, 0],  # should enter the trade
    [5, 5000, 5025, 4975, 4987, 6172, 0, 1],  # no action
    [6, 5000, 5025, 4975, 4987, 6172, 0, 0],  # should sell
 ],
    stop_loss=-0.99, roi=float('inf'), profit_perc=0.00,
    trades=[BTrade(sell_reason=SellType.SELL_SIGNAL, open_tick=1, close_tick=2),
            BTrade(sell_reason=SellType.SELL_SIGNAL, open_tick=4, close_tick=6)]
 )
 # 3) Entered, sl 1%, candle drops 8% => Trade closed, 1% loss
 tc2 = BTContainer(data=[
    # D  O     H     L     C     V    B  S
    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
    [1, 5000, 5025, 4600, 4987, 6172, 0, 0],  # enter trade, stoploss hit
    [2, 5000, 5025, 4975, 4987, 6172, 0, 0],
 ],
    stop_loss=-0.01, roi=float('inf'), profit_perc=-0.01,
    trades=[BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=1)]
 )
 # 4) Entered, sl 3 %, candle drops 4%, recovers to 1 % = > Trade closed, 3 % loss
 tc3 = BTContainer(data=[
    # D  O     H     L     C     V    B  S
    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
    [1, 5000, 5025, 4800, 4987, 6172, 0, 0],  # enter trade, stoploss hit
    [2, 5000, 5025, 4975, 4987, 6172, 0, 0],
 ],
    stop_loss=-0.03, roi=float('inf'), profit_perc=-0.03,
    trades=[BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=1)]
 )
 # 5) Stoploss and sell are hit. should sell on stoploss
 tc4 = BTContainer(data=[
    # D  O     H     L     C     V    B  S
    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
    [1, 5000, 5025, 4800, 4987, 6172, 0, 1],  # enter trade, stoploss hit, sell signal
    [2, 5000, 5025, 4975, 4987, 6172, 0, 0],
 ],
    stop_loss=-0.03, roi=float('inf'), profit_perc=-0.03,
    trades=[BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=1)]
 )
 TESTS = [
    tc0,
    tc1,
    tc2,
    tc3,
    tc4
 ]
@pytest.mark.parametrize("data", TESTS)
 def test_edge_results(edge_conf, mocker, caplog, data) -> None:
    """
    run functional tests
    """
    freqtrade = get_patched_freqtradebot(mocker, edge_conf)
    edge = Edge(edge_conf, freqtrade.exchange, freqtrade.strategy)
    frame = _build_backtest_dataframe(data.data)
    caplog.set_level(logging.DEBUG)
    edge.fee = 0
    trades = edge._find_trades_for_stoploss_range(frame, 'TEST/BTC', [data.stop_loss])
    results = edge._fill_calculable_fields(DataFrame(trades)) if trades else DataFrame()
    print(results)
    assert len(trades) == len(data.trades)
    if not results.empty:
        assert round(results["profit_percent"].sum(), 3) == round(data.profit_perc, 3)
    for c, trade in enumerate(data.trades):
        res = results.iloc[c]
        assert res.exit_type == trade.sell_reason
        assert res.open_time == _get_frame_time_from_offset(trade.open_tick)
        assert res.close_time == _get_frame_time_from_offset(trade.close_tick)
 def test_adjust(mocker, default_conf):
    freqtrade = get_patched_freqtradebot(mocker, default_conf)
    edge = Edge(default_conf, freqtrade.exchange, freqtrade.strategy)
    mocker.patch('freqtrade.edge.Edge._cached_pairs', mocker.PropertyMock(
        return_value={
            'E/F': PairInfo(-0.01, 0.66, 3.71, 0.50, 1.71, 10, 60),
            'C/D': PairInfo(-0.01, 0.66, 3.71, 0.50, 1.71, 10, 60),
            'N/O': PairInfo(-0.01, 0.66, 3.71, 0.50, 1.71, 10, 60)
        }
    ))
    pairs = ['A/B', 'C/D', 'E/F', 'G/H']
    assert(edge.adjust(pairs) == ['E/F', 'C/D'])
 def test_stoploss(mocker, default_conf):
    freqtrade = get_patched_freqtradebot(mocker, default_conf)
    edge = Edge(default_conf, freqtrade.exchange, freqtrade.strategy)
    mocker.patch('freqtrade.edge.Edge._cached_pairs', mocker.PropertyMock(
        return_value={
            'E/F': PairInfo(-0.01, 0.66, 3.71, 0.50, 1.71, 10, 60),
            'C/D': PairInfo(-0.01, 0.66, 3.71, 0.50, 1.71, 10, 60),
            'N/O': PairInfo(-0.01, 0.66, 3.71, 0.50, 1.71, 10, 60)
        }
    ))
    assert edge.stoploss('E/F') == -0.01
 def _validate_ohlc(buy_ohlc_sell_matrice):
    for index, ohlc in enumerate(buy_ohlc_sell_matrice):
        # if not high < open < low or not high < close < low
        if not ohlc[3] >= ohlc[2] >= ohlc[4] or not ohlc[3] >= ohlc[5] >= ohlc[4]:
            raise Exception('Line ' + str(index + 1) + ' of ohlc has invalid values!')
    return True
 def _build_dataframe(buy_ohlc_sell_matrice):
    _validate_ohlc(buy_ohlc_sell_matrice)
    tickers = []
    for ohlc in buy_ohlc_sell_matrice:
        ticker = {
            'date': ticker_start_time.shift(
                minutes=(
                    ohlc[0] *
                    ticker_interval_in_minute)).timestamp *
            1000,
            'buy': ohlc[1],
            'open': ohlc[2],
            'high': ohlc[3],
            'low': ohlc[4],
            'close': ohlc[5],
            'sell': ohlc[6]}
        tickers.append(ticker)
    frame = DataFrame(tickers)
    frame['date'] = to_datetime(frame['date'],
                                unit='ms',
                                utc=True,
                                infer_datetime_format=True)
    return frame
 def _time_on_candle(number):
    return np.datetime64(ticker_start_time.shift(
        minutes=(number * ticker_interval_in_minute)).timestamp * 1000, 'ms')
 def test_edge_heartbeat_calculate(mocker, edge_conf):
    freqtrade = get_patched_freqtradebot(mocker, edge_conf)
    edge = Edge(edge_conf, freqtrade.exchange, freqtrade.strategy)
    heartbeat = edge_conf['edge']['process_throttle_secs']
    # should not recalculate if heartbeat not reached
    edge._last_updated = arrow.utcnow().timestamp - heartbeat + 1
    assert edge.calculate() is False
 def mocked_load_data(datadir, pairs=[], ticker_interval='0m', refresh_pairs=False,
                     timerange=None, exchange=None):
    hz = 0.1
    base = 0.001
    ETHBTC = [
        [
            ticker_start_time.shift(minutes=(x * ticker_interval_in_minute)).timestamp * 1000,
            math.sin(x * hz) / 1000 + base,
            math.sin(x * hz) / 1000 + base + 0.0001,
            math.sin(x * hz) / 1000 + base - 0.0001,
            math.sin(x * hz) / 1000 + base,
            123.45
        ] for x in range(0, 500)]
    hz = 0.2
    base = 0.002
    LTCBTC = [
        [
            ticker_start_time.shift(minutes=(x * ticker_interval_in_minute)).timestamp * 1000,
            math.sin(x * hz) / 1000 + base,
            math.sin(x * hz) / 1000 + base + 0.0001,
            math.sin(x * hz) / 1000 + base - 0.0001,
            math.sin(x * hz) / 1000 + base,
            123.45
        ] for x in range(0, 500)]
    pairdata = {'NEO/BTC': ETHBTC, 'LTC/BTC': LTCBTC}
    return pairdata
 def test_edge_process_downloaded_data(mocker, default_conf):
    default_conf['datadir'] = None
    freqtrade = get_patched_freqtradebot(mocker, default_conf)
    mocker.patch('freqtrade.exchange.Exchange.get_fee', MagicMock(return_value=0.001))
    mocker.patch('freqtrade.optimize.load_data', mocked_load_data)
    edge = Edge(default_conf, freqtrade.exchange, freqtrade.strategy)
    assert edge.calculate()
    assert len(edge._cached_pairs) == 2
    assert edge._last_updated <= arrow.utcnow().timestamp + 2
 def test_process_expectancy(mocker, edge_conf):
    edge_conf['edge']['min_trade_number'] = 2
    freqtrade = get_patched_freqtradebot(mocker, edge_conf)
    def get_fee():
        return 0.001
    freqtrade.exchange.get_fee = get_fee
    edge = Edge(edge_conf, freqtrade.exchange, freqtrade.strategy)
    trades = [
        {'pair': 'TEST/BTC',
         'stoploss': -0.9,
         'profit_percent': '',
         'profit_abs': '',
         'open_time': np.datetime64('2018-10-03T00:05:00.000000000'),
         'close_time': np.datetime64('2018-10-03T00:10:00.000000000'),
         'open_index': 1,
         'close_index': 1,
         'trade_duration': '',
         'open_rate': 17,
         'close_rate': 17,
         'exit_type': 'sell_signal'},
        {'pair': 'TEST/BTC',
         'stoploss': -0.9,
         'profit_percent': '',
         'profit_abs': '',
         'open_time': np.datetime64('2018-10-03T00:20:00.000000000'),
         'close_time': np.datetime64('2018-10-03T00:25:00.000000000'),
         'open_index': 4,
         'close_index': 4,
         'trade_duration': '',
         'open_rate': 20,
         'close_rate': 20,
         'exit_type': 'sell_signal'},
        {'pair': 'TEST/BTC',
         'stoploss': -0.9,
         'profit_percent': '',
         'profit_abs': '',
         'open_time': np.datetime64('2018-10-03T00:30:00.000000000'),
         'close_time': np.datetime64('2018-10-03T00:40:00.000000000'),
         'open_index': 6,
         'close_index': 7,
         'trade_duration': '',
         'open_rate': 26,
         'close_rate': 34,
         'exit_type': 'sell_signal'}
    ]
    trades_df = DataFrame(trades)
    trades_df = edge._fill_calculable_fields(trades_df)
    final = edge._process_expectancy(trades_df)
    assert len(final) == 1
    assert 'TEST/BTC' in final
    assert final['TEST/BTC'].stoploss == -0.9
    assert round(final['TEST/BTC'].winrate, 10) == 0.3333333333
    assert round(final['TEST/BTC'].risk_reward_ratio, 10) == 306.5384615384
    assert round(final['TEST/BTC'].required_risk_reward, 10) == 2.0
    assert round(final['TEST/BTC'].expectancy, 10) == 101.5128205128
--- a/freqtrade/tests/exchange/test_exchange.py
+++ b/freqtrade/tests/exchange/test_exchange.py
@ -355,6 +355,36 @@ def test_validate_timeframes_not_in_config(default_conf, mocker):
    Exchange(default_conf)
 def test_validate_order_types(default_conf, mocker):
    api_mock = MagicMock()
    type(api_mock).has = PropertyMock(return_value={'createMarketOrder': True})
    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
    mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
    mocker.patch('freqtrade.exchange.Exchange.validate_timeframes', MagicMock())
    default_conf['order_types'] = {'buy': 'limit', 'sell': 'limit', 'stoploss': 'market'}
    Exchange(default_conf)
    type(api_mock).has = PropertyMock(return_value={'createMarketOrder': False})
    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
    default_conf['order_types'] = {'buy': 'limit', 'sell': 'limit', 'stoploss': 'market'}
    with pytest.raises(OperationalException,
                       match=r'Exchange .* does not support market orders.'):
        Exchange(default_conf)
 def test_validate_order_types_not_in_config(default_conf, mocker):
    api_mock = MagicMock()
    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
    mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
    mocker.patch('freqtrade.exchange.Exchange.validate_timeframes', MagicMock())
    conf = copy.deepcopy(default_conf)
    Exchange(conf)
 def test_exchange_has(default_conf, mocker):
    exchange = get_patched_exchange(mocker, default_conf)
    assert not exchange.exchange_has('ASDFASDF')
@ -373,7 +403,7 @@ def test_buy_dry_run(default_conf, mocker):
    default_conf['dry_run'] = True
    exchange = get_patched_exchange(mocker, default_conf)
-    order = exchange.buy(pair='ETH/BTC', rate=200, amount=1)
+    order = exchange.buy(pair='ETH/BTC', ordertype='limit', amount=1, rate=200)
    assert 'id' in order
    assert 'dry_run_buy_' in order['id']
@ -381,47 +411,64 @@ def test_buy_dry_run(default_conf, mocker):
 def test_buy_prod(default_conf, mocker):
    api_mock = MagicMock()
    order_id = 'test_prod_buy_{}'.format(randint(0, 10 ** 6))
-    api_mock.create_limit_buy_order = MagicMock(return_value={
+    order_type = 'market'
    api_mock.create_order = MagicMock(return_value={
        'id': order_id,
        'info': {
            'foo': 'bar'
        }
    })
    default_conf['dry_run'] = False
    mocker.patch('freqtrade.exchange.Exchange.symbol_amount_prec', lambda s, x, y: y)
    mocker.patch('freqtrade.exchange.Exchange.symbol_price_prec', lambda s, x, y: y)
    exchange = get_patched_exchange(mocker, default_conf, api_mock)
-    order = exchange.buy(pair='ETH/BTC', rate=200, amount=1)
+    order = exchange.buy(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
    assert 'id' in order
    assert 'info' in order
    assert order['id'] == order_id
    assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
    assert api_mock.create_order.call_args[0][1] == order_type
    assert api_mock.create_order.call_args[0][2] == 'buy'
    assert api_mock.create_order.call_args[0][3] == 1
    assert api_mock.create_order.call_args[0][4] is None
    api_mock.create_order.reset_mock()
    order_type = 'limit'
    order = exchange.buy(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
    assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
    assert api_mock.create_order.call_args[0][1] == order_type
    assert api_mock.create_order.call_args[0][2] == 'buy'
    assert api_mock.create_order.call_args[0][3] == 1
    assert api_mock.create_order.call_args[0][4] == 200
    # test exception handling
    with pytest.raises(DependencyException):
-        api_mock.create_limit_buy_order = MagicMock(side_effect=ccxt.InsufficientFunds)
+        api_mock.create_order = MagicMock(side_effect=ccxt.InsufficientFunds)
        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.buy(pair='ETH/BTC', rate=200, amount=1)
+        exchange.buy(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
    with pytest.raises(DependencyException):
-        api_mock.create_limit_buy_order = MagicMock(side_effect=ccxt.InvalidOrder)
+        api_mock.create_order = MagicMock(side_effect=ccxt.InvalidOrder)
        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.buy(pair='ETH/BTC', rate=200, amount=1)
+        exchange.buy(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
    with pytest.raises(TemporaryError):
-        api_mock.create_limit_buy_order = MagicMock(side_effect=ccxt.NetworkError)
+        api_mock.create_order = MagicMock(side_effect=ccxt.NetworkError)
        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.buy(pair='ETH/BTC', rate=200, amount=1)
+        exchange.buy(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
    with pytest.raises(OperationalException):
-        api_mock.create_limit_buy_order = MagicMock(side_effect=ccxt.BaseError)
+        api_mock.create_order = MagicMock(side_effect=ccxt.BaseError)
        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.buy(pair='ETH/BTC', rate=200, amount=1)
+        exchange.buy(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
 def test_sell_dry_run(default_conf, mocker):
    default_conf['dry_run'] = True
    exchange = get_patched_exchange(mocker, default_conf)
-    order = exchange.sell(pair='ETH/BTC', rate=200, amount=1)
+    order = exchange.sell(pair='ETH/BTC', ordertype='limit', amount=1, rate=200)
    assert 'id' in order
    assert 'dry_run_sell_' in order['id']
@ -429,7 +476,8 @@ def test_sell_dry_run(default_conf, mocker):
 def test_sell_prod(default_conf, mocker):
    api_mock = MagicMock()
    order_id = 'test_prod_sell_{}'.format(randint(0, 10 ** 6))
-    api_mock.create_limit_sell_order = MagicMock(return_value={
+    order_type = 'market'
    api_mock.create_order = MagicMock(return_value={
        'id': order_id,
        'info': {
            'foo': 'bar'
@ -438,32 +486,48 @@ def test_sell_prod(default_conf, mocker):
    default_conf['dry_run'] = False
    exchange = get_patched_exchange(mocker, default_conf, api_mock)
    mocker.patch('freqtrade.exchange.Exchange.symbol_amount_prec', lambda s, x, y: y)
    mocker.patch('freqtrade.exchange.Exchange.symbol_price_prec', lambda s, x, y: y)
-    order = exchange.sell(pair='ETH/BTC', rate=200, amount=1)
+    order = exchange.sell(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
    assert 'id' in order
    assert 'info' in order
    assert order['id'] == order_id
    assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
    assert api_mock.create_order.call_args[0][1] == order_type
    assert api_mock.create_order.call_args[0][2] == 'sell'
    assert api_mock.create_order.call_args[0][3] == 1
    assert api_mock.create_order.call_args[0][4] is None
    api_mock.create_order.reset_mock()
    order_type = 'limit'
    order = exchange.sell(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
    assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
    assert api_mock.create_order.call_args[0][1] == order_type
    assert api_mock.create_order.call_args[0][2] == 'sell'
    assert api_mock.create_order.call_args[0][3] == 1
    assert api_mock.create_order.call_args[0][4] == 200
    # test exception handling
    with pytest.raises(DependencyException):
-        api_mock.create_limit_sell_order = MagicMock(side_effect=ccxt.InsufficientFunds)
+        api_mock.create_order = MagicMock(side_effect=ccxt.InsufficientFunds)
        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.sell(pair='ETH/BTC', rate=200, amount=1)
+        exchange.sell(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
    with pytest.raises(DependencyException):
-        api_mock.create_limit_sell_order = MagicMock(side_effect=ccxt.InvalidOrder)
+        api_mock.create_order = MagicMock(side_effect=ccxt.InvalidOrder)
        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.sell(pair='ETH/BTC', rate=200, amount=1)
+        exchange.sell(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
    with pytest.raises(TemporaryError):
-        api_mock.create_limit_sell_order = MagicMock(side_effect=ccxt.NetworkError)
+        api_mock.create_order = MagicMock(side_effect=ccxt.NetworkError)
        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.sell(pair='ETH/BTC', rate=200, amount=1)
+        exchange.sell(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
    with pytest.raises(OperationalException):
-        api_mock.create_limit_sell_order = MagicMock(side_effect=ccxt.BaseError)
+        api_mock.create_order = MagicMock(side_effect=ccxt.BaseError)
        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.sell(pair='ETH/BTC', rate=200, amount=1)
+        exchange.sell(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
 def test_get_balance_dry_run(default_conf, mocker):
--- a/freqtrade/tests/optimize/init.py
+++ b/freqtrade/tests/optimize/init.py
@ -31,8 +31,8 @@ class BTContainer(NamedTuple):
 def _get_frame_time_from_offset(offset):
-    return ticker_start_time.shift(
+    return ticker_start_time.shift(minutes=(offset * TICKER_INTERVAL_MINUTES[tests_ticker_interval])
-        minutes=(offset * TICKER_INTERVAL_MINUTES[tests_ticker_interval])).datetime
+                                   ).datetime.replace(tzinfo=None)
 def _build_backtest_dataframe(ticker_with_signals):
--- a/freqtrade/tests/optimize/test_backtest_detail.py
+++ b/freqtrade/tests/optimize/test_backtest_detail.py
@ -1,4 +1,4 @@
-# pragma pylint: disable=missing-docstring, W0212, line-too-long, C0103, unused-argument
+# pragma pylint: disable=missing-docstring, W0212, line-too-long, C0103, C0330, unused-argument
 import logging
 from unittest.mock import MagicMock
--- a/freqtrade/tests/optimize/test_backtesting.py
+++ b/freqtrade/tests/optimize/test_backtesting.py
@ -638,6 +638,7 @@ def test_backtest_only_sell(mocker, default_conf):
 def test_backtest_alternate_buy_sell(default_conf, fee, mocker):
    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
    mocker.patch('freqtrade.optimize.backtesting.file_dump_json', MagicMock())
    backtest_conf = _make_backtest_conf(mocker, conf=default_conf, pair='UNITTEST/BTC')
    # We need to enable sell-signal - otherwise it sells on ROI!!
    default_conf['experimental'] = {"use_sell_signal": True}
--- a/freqtrade/tests/optimize/test_edge_cli.py
+++ b/freqtrade/tests/optimize/test_edge_cli.py
@ -0,0 +1,131 @@
 # pragma pylint: disable=missing-docstring, C0103, C0330
 # pragma pylint: disable=protected-access, too-many-lines, invalid-name, too-many-arguments
 from unittest.mock import MagicMock
 import json
 from typing import List
 from freqtrade.edge import PairInfo
 from freqtrade.arguments import Arguments
 from freqtrade.optimize.edge_cli import (EdgeCli, setup_configuration, start)
 from freqtrade.tests.conftest import log_has, patch_exchange
 def get_args(args) -> List[str]:
    return Arguments(args, '').get_parsed_arg()
 def test_setup_configuration_without_arguments(mocker, default_conf, caplog) -> None:
    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
        read_data=json.dumps(default_conf)
    ))
    args = [
        '--config', 'config.json',
        '--strategy', 'DefaultStrategy',
        'edge'
    ]
    config = setup_configuration(get_args(args))
    assert 'max_open_trades' in config
    assert 'stake_currency' in config
    assert 'stake_amount' in config
    assert 'exchange' in config
    assert 'pair_whitelist' in config['exchange']
    assert 'datadir' in config
    assert log_has(
        'Using data folder: {} ...'.format(config['datadir']),
        caplog.record_tuples
    )
    assert 'ticker_interval' in config
    assert not log_has('Parameter -i/--ticker-interval detected ...', caplog.record_tuples)
    assert 'refresh_pairs' not in config
    assert not log_has('Parameter -r/--refresh-pairs-cached detected ...', caplog.record_tuples)
    assert 'timerange' not in config
    assert 'stoploss_range' not in config
 def test_setup_configuration_with_arguments(mocker, edge_conf, caplog) -> None:
    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
        read_data=json.dumps(edge_conf)
    ))
    args = [
        '--config', 'config.json',
        '--strategy', 'DefaultStrategy',
        '--datadir', '/foo/bar',
        'edge',
        '--ticker-interval', '1m',
        '--refresh-pairs-cached',
        '--timerange', ':100',
        '--stoplosses=-0.01,-0.10,-0.001'
    ]
    config = setup_configuration(get_args(args))
    assert 'max_open_trades' in config
    assert 'stake_currency' in config
    assert 'stake_amount' in config
    assert 'exchange' in config
    assert 'pair_whitelist' in config['exchange']
    assert 'datadir' in config
    assert log_has(
        'Using data folder: {} ...'.format(config['datadir']),
        caplog.record_tuples
    )
    assert 'ticker_interval' in config
    assert log_has('Parameter -i/--ticker-interval detected ...', caplog.record_tuples)
    assert log_has(
        'Using ticker_interval: 1m ...',
        caplog.record_tuples
    )
    assert 'refresh_pairs' in config
    assert log_has('Parameter -r/--refresh-pairs-cached detected ...', caplog.record_tuples)
    assert 'timerange' in config
    assert log_has(
        'Parameter --timerange detected: {} ...'.format(config['timerange']),
        caplog.record_tuples
    )
 def test_start(mocker, fee, edge_conf, caplog) -> None:
    start_mock = MagicMock()
    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
    patch_exchange(mocker)
    mocker.patch('freqtrade.optimize.edge_cli.EdgeCli.start', start_mock)
    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
        read_data=json.dumps(edge_conf)
    ))
    args = [
        '--config', 'config.json',
        '--strategy', 'DefaultStrategy',
        'edge'
    ]
    args = get_args(args)
    start(args)
    assert log_has(
        'Starting freqtrade in Edge mode',
        caplog.record_tuples
    )
    assert start_mock.call_count == 1
 def test_edge_init(mocker, edge_conf) -> None:
    patch_exchange(mocker)
    edge_cli = EdgeCli(edge_conf)
    assert edge_cli.config == edge_conf
    assert callable(edge_cli.edge.calculate)
 def test_generate_edge_table(edge_conf, mocker):
    patch_exchange(mocker)
    edge_cli = EdgeCli(edge_conf)
    results = {}
    results['ETH/BTC'] = PairInfo(-0.01, 0.60, 2, 1, 3, 10, 60)
    assert edge_cli._generate_edge_table(results).count(':|') == 7
    assert edge_cli._generate_edge_table(results).count('| ETH/BTC |') == 1
    assert edge_cli._generate_edge_table(results).count(
        '|   risk reward ratio |   required risk reward |   expectancy |') == 1
--- a/freqtrade/tests/optimize/test_hyperopt.py
+++ b/freqtrade/tests/optimize/test_hyperopt.py
@ -176,7 +176,7 @@ def test_roi_table_generation(hyperopt) -> None:
        'roi_p3': 3,
    }
-    assert hyperopt.generate_roi_table(params) == {0: 6, 15: 3, 25: 1, 30: 0}
+    assert hyperopt.custom_hyperopt.generate_roi_table(params) == {0: 6, 15: 3, 25: 1, 30: 0}
 def test_start_calls_optimizer(mocker, default_conf, caplog) -> None:
@ -244,7 +244,8 @@ def test_populate_indicators(hyperopt) -> None:
    tick = load_tickerdata_file(None, 'UNITTEST/BTC', '1m')
    tickerlist = {'UNITTEST/BTC': tick}
    dataframes = hyperopt.strategy.tickerdata_to_dataframe(tickerlist)
-    dataframe = hyperopt.populate_indicators(dataframes['UNITTEST/BTC'], {'pair': 'UNITTEST/BTC'})
+    dataframe = hyperopt.custom_hyperopt.populate_indicators(dataframes['UNITTEST/BTC'],
                                                             {'pair': 'UNITTEST/BTC'})
    # Check if some indicators are generated. We will not test all of them
    assert 'adx' in dataframe
@ -256,9 +257,10 @@ def test_buy_strategy_generator(hyperopt) -> None:
    tick = load_tickerdata_file(None, 'UNITTEST/BTC', '1m')
    tickerlist = {'UNITTEST/BTC': tick}
    dataframes = hyperopt.strategy.tickerdata_to_dataframe(tickerlist)
-    dataframe = hyperopt.populate_indicators(dataframes['UNITTEST/BTC'], {'pair': 'UNITTEST/BTC'})
+    dataframe = hyperopt.custom_hyperopt.populate_indicators(dataframes['UNITTEST/BTC'],
                                                             {'pair': 'UNITTEST/BTC'})
-    populate_buy_trend = hyperopt.buy_strategy_generator(
+    populate_buy_trend = hyperopt.custom_hyperopt.buy_strategy_generator(
        {
            'adx-value': 20,
            'fastd-value': 20,
--- a/freqtrade/tests/rpc/test_rpc.py
+++ b/freqtrade/tests/rpc/test_rpc.py
@ -645,3 +645,28 @@ def test_rpcforcebuy_disabled(mocker, default_conf) -> None:
    pair = 'ETH/BTC'
    with pytest.raises(RPCException, match=r'Forcebuy not enabled.'):
        rpc._rpc_forcebuy(pair, None)
 def test_rpc_whitelist(mocker, default_conf) -> None:
    patch_coinmarketcap(mocker)
    patch_exchange(mocker)
    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
    freqtradebot = FreqtradeBot(default_conf)
    rpc = RPC(freqtradebot)
    ret = rpc._rpc_whitelist()
    assert ret['method'] == 'static'
    assert ret['whitelist'] == default_conf['exchange']['pair_whitelist']
 def test_rpc_whitelist_dynamic(mocker, default_conf) -> None:
    patch_coinmarketcap(mocker)
    patch_exchange(mocker)
    default_conf['dynamic_whitelist'] = 4
    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
    freqtradebot = FreqtradeBot(default_conf)
    rpc = RPC(freqtradebot)
    ret = rpc._rpc_whitelist()
    assert ret['method'] == 4
    assert ret['whitelist'] == default_conf['exchange']['pair_whitelist']
--- a/freqtrade/tests/rpc/test_rpc_telegram.py
+++ b/freqtrade/tests/rpc/test_rpc_telegram.py
@ -72,7 +72,8 @@ def test_init(default_conf, mocker, caplog) -> None:
    message_str = "rpc.telegram is listening for following commands: [['status'], ['profit'], " \
                  "['balance'], ['start'], ['stop'], ['forcesell'], ['forcebuy'], " \
-                  "['performance'], ['daily'], ['count'], ['reload_conf'], ['help'], ['version']]"
+                  "['performance'], ['daily'], ['count'], ['reload_conf'], " \
                  "['whitelist'], ['help'], ['version']]"
    assert log_has(message_str, caplog.record_tuples)
@ -1006,6 +1007,43 @@ def test_count_handle(default_conf, update, ticker, fee, markets, mocker) -> Non
    assert msg in msg_mock.call_args_list[0][0][0]
 def test_whitelist_static(default_conf, update, mocker) -> None:
    patch_coinmarketcap(mocker)
    msg_mock = MagicMock()
    mocker.patch.multiple(
        'freqtrade.rpc.telegram.Telegram',
        _init=MagicMock(),
        _send_msg=msg_mock
    )
    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
    telegram = Telegram(freqtradebot)
    telegram._whitelist(bot=MagicMock(), update=update)
    assert msg_mock.call_count == 1
    assert ('Using static whitelist with `4` pairs \n`ETH/BTC, LTC/BTC, XRP/BTC, NEO/BTC`'
            in msg_mock.call_args_list[0][0][0])
 def test_whitelist_dynamic(default_conf, update, mocker) -> None:
    patch_coinmarketcap(mocker)
    msg_mock = MagicMock()
    mocker.patch.multiple(
        'freqtrade.rpc.telegram.Telegram',
        _init=MagicMock(),
        _send_msg=msg_mock
    )
    default_conf['dynamic_whitelist'] = 4
    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
    telegram = Telegram(freqtradebot)
    telegram._whitelist(bot=MagicMock(), update=update)
    assert msg_mock.call_count == 1
    assert ('Dynamic whitelist with `4` pairs\n`ETH/BTC, LTC/BTC, XRP/BTC, NEO/BTC`'
            in msg_mock.call_args_list[0][0][0])
 def test_help_handle(default_conf, update, mocker) -> None:
    patch_coinmarketcap(mocker)
    msg_mock = MagicMock()
--- a/freqtrade/tests/strategy/test_strategy.py
+++ b/freqtrade/tests/strategy/test_strategy.py
@ -88,8 +88,8 @@ def test_load_strategy_invalid_directory(result, caplog):
 def test_load_not_found_strategy():
    strategy = StrategyResolver()
    with pytest.raises(ImportError,
-                       match=r'Impossible to load Strategy \'NotFoundStrategy\'.'
+                       match=r"Impossible to load Strategy 'NotFoundStrategy'."
-                             r' This class does not exist or contains Python code errors'):
+                             r" This class does not exist or contains Python code errors"):
        strategy._load_strategy(strategy_name='NotFoundStrategy', config={})
@ -182,6 +182,42 @@ def test_strategy_override_process_only_new_candles(caplog):
            ) in caplog.record_tuples
 def test_strategy_override_order_types(caplog):
    caplog.set_level(logging.INFO)
    order_types = {
        'buy': 'market',
        'sell': 'limit',
        'stoploss': 'limit'
    }
    config = {
        'strategy': 'DefaultStrategy',
        'order_types': order_types
    }
    resolver = StrategyResolver(config)
    assert resolver.strategy.order_types
    for method in ['buy', 'sell', 'stoploss']:
        assert resolver.strategy.order_types[method] == order_types[method]
    assert ('freqtrade.strategy.resolver',
            logging.INFO,
            "Override strategy 'order_types' with value in config file:"
            " {'buy': 'market', 'sell': 'limit', 'stoploss': 'limit'}."
            ) in caplog.record_tuples
    config = {
        'strategy': 'DefaultStrategy',
        'order_types': {'buy': 'market'}
    }
    # Raise error for invalid configuration
    with pytest.raises(ImportError,
                       match=r"Impossible to load Strategy 'DefaultStrategy'. "
                             r"Order-types mapping is incomplete."):
        StrategyResolver(config)
 def test_deprecate_populate_indicators(result):
    default_location = path.join(path.dirname(path.realpath(__file__)))
    resolver = StrategyResolver({'strategy': 'TestStrategyLegacy',
--- a/freqtrade/tests/test_configuration.py
+++ b/freqtrade/tests/test_configuration.py
@ -64,6 +64,22 @@ def test_load_config_max_open_trades_zero(default_conf, mocker, caplog) -> None:
    assert log_has('Validating configuration ...', caplog.record_tuples)
 def test_load_config_max_open_trades_minus_one(default_conf, mocker, caplog) -> None:
    default_conf['max_open_trades'] = -1
    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
        read_data=json.dumps(default_conf)
    ))
    args = Arguments([], '').get_parsed_arg()
    configuration = Configuration(args)
    validated_conf = configuration.load_config()
    print(validated_conf)
    assert validated_conf['max_open_trades'] > 999999999
    assert validated_conf['max_open_trades'] == float('inf')
    assert log_has('Validating configuration ...', caplog.record_tuples)
 def test_load_config_file_exception(mocker) -> None:
    mocker.patch(
        'freqtrade.configuration.open',
--- a/freqtrade/tests/test_freqtradebot.py
+++ b/freqtrade/tests/test_freqtradebot.py
@ -18,7 +18,7 @@ from freqtrade.persistence import Trade
 from freqtrade.rpc import RPCMessageType
 from freqtrade.state import State
 from freqtrade.strategy.interface import SellType, SellCheckTuple
-from freqtrade.tests.conftest import log_has, patch_exchange
+from freqtrade.tests.conftest import log_has, patch_exchange, patch_edge
 # Functions for recurrent object patching
@ -177,7 +177,7 @@ def test_get_trade_stake_amount(default_conf, ticker, limit_buy_order, fee, mock
    freqtrade = FreqtradeBot(default_conf)
-    result = freqtrade._get_trade_stake_amount()
+    result = freqtrade._get_trade_stake_amount('ETH/BTC')
    assert result == default_conf['stake_amount']
@ -195,7 +195,7 @@ def test_get_trade_stake_amount_no_stake_amount(default_conf,
    freqtrade = FreqtradeBot(default_conf)
    with pytest.raises(DependencyException, match=r'.*stake amount.*'):
-        freqtrade._get_trade_stake_amount()
+        freqtrade._get_trade_stake_amount('ETH/BTC')
 def test_get_trade_stake_amount_unlimited_amount(default_conf,
@ -224,28 +224,131 @@ def test_get_trade_stake_amount_unlimited_amount(default_conf,
    patch_get_signal(freqtrade)
    # no open trades, order amount should be 'balance / max_open_trades'
-    result = freqtrade._get_trade_stake_amount()
+    result = freqtrade._get_trade_stake_amount('ETH/BTC')
    assert result == default_conf['stake_amount'] / conf['max_open_trades']
    # create one trade, order amount should be 'balance / (max_open_trades - num_open_trades)'
    freqtrade.create_trade()
-    result = freqtrade._get_trade_stake_amount()
+    result = freqtrade._get_trade_stake_amount('LTC/BTC')
    assert result == default_conf['stake_amount'] / (conf['max_open_trades'] - 1)
    # create 2 trades, order amount should be None
    freqtrade.create_trade()
-    result = freqtrade._get_trade_stake_amount()
+    result = freqtrade._get_trade_stake_amount('XRP/BTC')
    assert result is None
    # set max_open_trades = None, so do not trade
    conf['max_open_trades'] = 0
    freqtrade = FreqtradeBot(conf)
-    result = freqtrade._get_trade_stake_amount()
+    result = freqtrade._get_trade_stake_amount('NEO/BTC')
    assert result is None
 def test_edge_called_in_process(mocker, edge_conf) -> None:
    patch_RPCManager(mocker)
    patch_edge(mocker)
    def _refresh_whitelist(list):
        return ['ETH/BTC', 'LTC/BTC', 'XRP/BTC', 'NEO/BTC']
    patch_exchange(mocker)
    freqtrade = FreqtradeBot(edge_conf)
    freqtrade._refresh_whitelist = _refresh_whitelist
    patch_get_signal(freqtrade)
    freqtrade._process()
    assert freqtrade.active_pair_whitelist == ['NEO/BTC', 'LTC/BTC']
 def test_edge_overrides_stake_amount(mocker, edge_conf) -> None:
    patch_RPCManager(mocker)
    patch_exchange(mocker)
    patch_edge(mocker)
    freqtrade = FreqtradeBot(edge_conf)
    assert freqtrade._get_trade_stake_amount('NEO/BTC') == (0.001 * 0.01) / 0.20
    assert freqtrade._get_trade_stake_amount('LTC/BTC') == (0.001 * 0.01) / 0.20
 def test_edge_overrides_stoploss(limit_buy_order, fee, markets, caplog, mocker, edge_conf) -> None:
    patch_RPCManager(mocker)
    patch_exchange(mocker)
    patch_edge(mocker)
    # Strategy stoploss is -0.1 but Edge imposes a stoploss at -0.2
    # Thus, if price falls 21%, stoploss should be triggered
    #
    # mocking the ticker: price is falling ...
    buy_price = limit_buy_order['price']
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
        get_ticker=MagicMock(return_value={
            'bid': buy_price * 0.79,
            'ask': buy_price * 0.79,
            'last': buy_price * 0.79
        }),
        buy=MagicMock(return_value={'id': limit_buy_order['id']}),
        get_fee=fee,
        get_markets=markets,
    )
    #############################################
    # Create a trade with "limit_buy_order" price
    freqtrade = FreqtradeBot(edge_conf)
    freqtrade.active_pair_whitelist = ['NEO/BTC']
    patch_get_signal(freqtrade)
    freqtrade.strategy.min_roi_reached = lambda trade, current_profit, current_time: False
    freqtrade.create_trade()
    trade = Trade.query.first()
    trade.update(limit_buy_order)
    #############################################
    # stoploss shoud be hit
    assert freqtrade.handle_trade(trade) is True
    assert log_has('executed sell, reason: SellType.STOP_LOSS', caplog.record_tuples)
    assert trade.sell_reason == SellType.STOP_LOSS.value
 def test_edge_should_ignore_strategy_stoploss(limit_buy_order, fee, markets,
                                              mocker, edge_conf) -> None:
    patch_RPCManager(mocker)
    patch_exchange(mocker)
    patch_edge(mocker)
    # Strategy stoploss is -0.1 but Edge imposes a stoploss at -0.2
    # Thus, if price falls 15%, stoploss should not be triggered
    #
    # mocking the ticker: price is falling ...
    buy_price = limit_buy_order['price']
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
        get_ticker=MagicMock(return_value={
            'bid': buy_price * 0.85,
            'ask': buy_price * 0.85,
            'last': buy_price * 0.85
        }),
        buy=MagicMock(return_value={'id': limit_buy_order['id']}),
        get_fee=fee,
        get_markets=markets,
    )
    #############################################
    # Create a trade with "limit_buy_order" price
    freqtrade = FreqtradeBot(edge_conf)
    freqtrade.active_pair_whitelist = ['NEO/BTC']
    patch_get_signal(freqtrade)
    freqtrade.strategy.min_roi_reached = lambda trade, current_profit, current_time: False
    freqtrade.create_trade()
    trade = Trade.query.first()
    trade.update(limit_buy_order)
    #############################################
    # stoploss shoud not be hit
    assert freqtrade.handle_trade(trade) is False
 def test_get_min_pair_stake_amount(mocker, default_conf) -> None:
    patch_RPCManager(mocker)
    patch_exchange(mocker)
@ -450,7 +553,7 @@ def test_create_trade_minimal_amount(default_conf, ticker, limit_buy_order,
    patch_get_signal(freqtrade)
    freqtrade.create_trade()
-    rate, amount = buy_mock.call_args[0][1], buy_mock.call_args[0][2]
+    rate, amount = buy_mock.call_args[1]['rate'], buy_mock.call_args[1]['amount']
    assert rate * amount >= default_conf['stake_amount']
@ -494,7 +597,7 @@ def test_create_trade_limit_reached(default_conf, ticker, limit_buy_order,
    patch_get_signal(freqtrade)
    assert freqtrade.create_trade() is False
-    assert freqtrade._get_trade_stake_amount() is None
+    assert freqtrade._get_trade_stake_amount('ETH/BTC') is None
 def test_create_trade_no_pairs(default_conf, ticker, limit_buy_order, fee, markets, mocker) -> None:
@ -593,7 +696,7 @@ def test_process_trade_creation(default_conf, ticker, limit_buy_order,
    assert trade.amount == 90.99181073703367
    assert log_has(
-        'Checking buy signals to create a new trade with stake_amount: 0.001000 ...',
+        'Buy signal found: about create a new trade with stake_amount: 0.001000 ...',
        caplog.record_tuples
    )
@ -760,10 +863,10 @@ def test_execute_buy(mocker, default_conf, fee, markets, limit_buy_order) -> Non
    assert freqtrade.execute_buy(pair, stake_amount)
    assert get_bid.call_count == 1
    assert buy_mm.call_count == 1
-    call_args = buy_mm.call_args_list[0][0]
+    call_args = buy_mm.call_args_list[0][1]
-    assert call_args[0] == pair
+    assert call_args['pair'] == pair
-    assert call_args[1] == bid
+    assert call_args['rate'] == bid
-    assert call_args[2] == stake_amount / bid
+    assert call_args['amount'] == stake_amount / bid
    # Test calling with price
    fix_price = 0.06
@ -772,10 +875,10 @@ def test_execute_buy(mocker, default_conf, fee, markets, limit_buy_order) -> Non
    assert get_bid.call_count == 1
    assert buy_mm.call_count == 2
-    call_args = buy_mm.call_args_list[1][0]
+    call_args = buy_mm.call_args_list[1][1]
-    assert call_args[0] == pair
+    assert call_args['pair'] == pair
-    assert call_args[1] == fix_price
+    assert call_args['rate'] == fix_price
-    assert call_args[2] == stake_amount / fix_price
+    assert call_args['amount'] == stake_amount / fix_price
 def test_process_maybe_execute_buy(mocker, default_conf) -> None:
@ -1547,7 +1650,7 @@ def test_sell_profit_only_enable_loss(default_conf, limit_buy_order, fee, market
    freqtrade = FreqtradeBot(default_conf)
    patch_get_signal(freqtrade)
    freqtrade.strategy.stop_loss_reached = \
-        lambda current_rate, trade, current_time, current_profit: SellCheckTuple(
+        lambda current_rate, trade, current_time, force_stoploss, current_profit: SellCheckTuple(
            sell_flag=False, sell_type=SellType.NONE)
    freqtrade.create_trade()
--- a/freqtrade/tests/test_wallets.py
+++ b/freqtrade/tests/test_wallets.py
@ -0,0 +1,84 @@
 # pragma pylint: disable=missing-docstring
 from freqtrade.tests.conftest import get_patched_freqtradebot
 from unittest.mock import MagicMock
 def test_sync_wallet_at_boot(mocker, default_conf):
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
        get_balances=MagicMock(return_value={
            "BNT": {
                "free": 1.0,
                "used": 2.0,
                "total": 3.0
            },
            "GAS": {
                "free": 0.260739,
                "used": 0.0,
                "total": 0.260739
            },
        })
    )
    freqtrade = get_patched_freqtradebot(mocker, default_conf)
    assert len(freqtrade.wallets.wallets) == 2
    assert freqtrade.wallets.wallets['BNT'].free == 1.0
    assert freqtrade.wallets.wallets['BNT'].used == 2.0
    assert freqtrade.wallets.wallets['BNT'].total == 3.0
    assert freqtrade.wallets.wallets['GAS'].free == 0.260739
    assert freqtrade.wallets.wallets['GAS'].used == 0.0
    assert freqtrade.wallets.wallets['GAS'].total == 0.260739
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
        get_balances=MagicMock(return_value={
            "BNT": {
                "free": 1.2,
                "used": 1.9,
                "total": 3.5
            },
            "GAS": {
                "free": 0.270739,
                "used": 0.1,
                "total": 0.260439
            },
        })
    )
    freqtrade.wallets.update()
    assert len(freqtrade.wallets.wallets) == 2
    assert freqtrade.wallets.wallets['BNT'].free == 1.2
    assert freqtrade.wallets.wallets['BNT'].used == 1.9
    assert freqtrade.wallets.wallets['BNT'].total == 3.5
    assert freqtrade.wallets.wallets['GAS'].free == 0.270739
    assert freqtrade.wallets.wallets['GAS'].used == 0.1
    assert freqtrade.wallets.wallets['GAS'].total == 0.260439
 def test_sync_wallet_missing_data(mocker, default_conf):
    mocker.patch.multiple(
        'freqtrade.exchange.Exchange',
        get_balances=MagicMock(return_value={
            "BNT": {
                "free": 1.0,
                "used": 2.0,
                "total": 3.0
            },
            "GAS": {
                "free": 0.260739,
                "total": 0.260739
            },
        })
    )
    freqtrade = get_patched_freqtradebot(mocker, default_conf)
    assert len(freqtrade.wallets.wallets) == 2
    assert freqtrade.wallets.wallets['BNT'].free == 1.0
    assert freqtrade.wallets.wallets['BNT'].used == 2.0
    assert freqtrade.wallets.wallets['BNT'].total == 3.0
    assert freqtrade.wallets.wallets['GAS'].free == 0.260739
    assert freqtrade.wallets.wallets['GAS'].used is None
    assert freqtrade.wallets.wallets['GAS'].total == 0.260739
--- a/freqtrade/wallets.py
+++ b/freqtrade/wallets.py
@ -0,0 +1,44 @@
 # pragma pylint: disable=W0603
 """ Wallet """
 import logging
 from typing import Dict, Any, NamedTuple
 from collections import namedtuple
 from freqtrade.exchange import Exchange
 logger = logging.getLogger(__name__)
 class Wallet(NamedTuple):
    exchange: str
    currency: str
    free: float = 0
    used: float = 0
    total: float = 0
 class Wallets(object):
    # wallet data structure
    wallet = namedtuple(
        'wallet',
        ['exchange', 'currency', 'free', 'used', 'total']
    )
    def __init__(self, exchange: Exchange) -> None:
        self.exchange = exchange
        self.wallets: Dict[str, Any] = {}
        self.update()
    def update(self) -> None:
        balances = self.exchange.get_balances()
        for currency in balances:
            self.wallets[currency] = Wallet(
                self.exchange.id,
                currency,
                balances[currency].get('free', None),
                balances[currency].get('used', None),
                balances[currency].get('total', None)
            )
        logger.info('Wallets synced ...')
--- a/requirements.txt
+++ b/requirements.txt
@ -1,18 +1,19 @@
-ccxt==1.17.481
+ccxt==1.17.529
-SQLAlchemy==1.2.13
+SQLAlchemy==1.2.14
 python-telegram-bot==11.1.0
 arrow==0.12.1
 cachetools==3.0.0
-requests==2.20.0
+requests==2.20.1
 urllib3==1.24.1
 wrapt==1.10.11
 pandas==0.23.4
 scikit-learn==0.20.0
 joblib==0.13.0
 scipy==1.1.0
 jsonschema==2.6.0
 numpy==1.15.4
 TA-Lib==0.4.17
-pytest==3.10.0
+pytest==4.0.0
 pytest-mock==1.10.0
 pytest-asyncio==0.9.0
 pytest-cov==2.6.0
@ -24,3 +25,9 @@ scikit-optimize==0.5.2
 # Required for plotting data
 #plotly==3.1.1
 # find first, C search in arrays
 py_find_1st==1.1.3
 #Load ticker files 30% faster
 ujson==1.35
--- a/setup.py
+++ b/setup.py
@ -31,12 +31,15 @@ setup(name='freqtrade',
          'pandas',
          'scikit-learn',
          'scipy',
          'joblib',
          'jsonschema',
          'TA-Lib',
          'tabulate',
          'cachetools',
          'coinmarketcap',
          'scikit-optimize',
          'ujson',
          'py_find_1st'
      ],
      include_package_data=True,
      zip_safe=False,
--- a/user_data/hyperopts/init.py
+++ b/user_data/hyperopts/init.py
--- a/user_data/hyperopts/sample_hyperopt.py
+++ b/user_data/hyperopts/sample_hyperopt.py
@ -0,0 +1,139 @@
 # 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
 import numpy
 from skopt.space import Categorical, Dimension, Integer, Real
 import freqtrade.vendor.qtpylib.indicators as qtpylib
 from freqtrade.optimize.hyperopt_interface import IHyperOpt
 class_name = 'SampleHyperOpts'
 # This class is a sample. Feel free to customize it.
 class SampleHyperOpts(IHyperOpt):
    """
    This is a test hyperopt to inspire you.
    More information in https://github.com/freqtrade/freqtrade/blob/develop/docs/hyperopt.md
     You can:
    - Rename the class name (Do not forget to update class_name)
    - Add any methods you want to build your hyperopt
    - Add any lib you need to build your hyperopt
     You must keep:
    - the prototype for the methods: populate_indicators, indicator_space, buy_strategy_generator,
    roi_space, generate_roi_table, stoploss_space
    """
    @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['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 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 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'),
        ]
--- a/user_data/strategies/test_strategy.py
+++ b/user_data/strategies/test_strategy.py
@ -48,6 +48,13 @@ class TestStrategy(IStrategy):
    # run "populate_indicators" only for new candle
    ta_on_candle = False
    # Optional order type mapping
    order_types = {
        'buy': 'limit',
        'sell': 'limit',
        'stoploss': 'market'
    }
    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        Adds several different TA indicators to the given DataFrame