Merge pull request #6592 from freqtrade/new_release

New release 2022.3

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: [xmatthias]

.github/workflows/ci.yml

@@ -23,10 +23,10 @@ jobs:
         python-version: ["3.8", "3.9", "3.10"]
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
 
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v3
       with:
         python-version: ${{ matrix.python-version }}
 
@@ -118,10 +118,10 @@ jobs:
         python-version: ["3.8", "3.9", "3.10"]
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
 
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v3
       with:
         python-version: ${{ matrix.python-version }}
 
@@ -210,10 +210,10 @@ jobs:
         python-version: ["3.8", "3.9", "3.10"]
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
 
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v3
       with:
         python-version: ${{ matrix.python-version }}
 
@@ -262,14 +262,14 @@ jobs:
   docs_check:
     runs-on: ubuntu-20.04
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
 
     - name: Documentation syntax
       run: |
         ./tests/test_docs.sh
 
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v3
       with:
         python-version: 3.8
 
@@ -325,10 +325,10 @@ jobs:
     if: (github.event_name == 'push' || github.event_name == 'schedule' || github.event_name == 'release') && github.repository == 'freqtrade/freqtrade'
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
 
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v3
       with:
         python-version: 3.8
 
@@ -405,7 +405,7 @@ jobs:
     if: (github.event_name == 'push' || github.event_name == 'schedule' || github.event_name == 'release') && github.repository == 'freqtrade/freqtrade'
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
 
     - name: Extract branch name
       shell: bash

.github/workflows/docker_update_readme.yml

@@ -8,7 +8,7 @@ jobs:
   dockerHubDescription:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v3
     - name: Docker Hub Description
       uses: peter-evans/dockerhub-description@v2.4.3
       env:

.gitignore

@@ -1,6 +1,8 @@
 # Freqtrade rules
 config*.json
 *.sqlite
+*.sqlite-shm
+*.sqlite-wal
 logfile.txt
 user_data/*
 !user_data/strategy/sample_strategy.py
@@ -10,6 +12,9 @@ freqtrade-plot.html
 freqtrade-profit-plot.html
 freqtrade/rpc/api_server/ui/*
 
+# Macos related
+.DS_Store
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]

README.md

@@ -5,10 +5,14 @@
 [![Documentation](https://readthedocs.org/projects/freqtrade/badge/)](https://www.freqtrade.io)
 [![Maintainability](https://api.codeclimate.com/v1/badges/5737e6d668200b7518ff/maintainability)](https://codeclimate.com/github/freqtrade/freqtrade/maintainability)
 
-Freqtrade is a free and open source crypto trading bot written in Python. It is designed to support all major exchanges and be controlled via Telegram. It contains backtesting, plotting and money management tools as well as strategy optimization by machine learning.
+Freqtrade is a free and open source crypto trading bot written in Python. It is designed to support all major exchanges and be controlled via Telegram or webUI. It contains backtesting, plotting and money management tools as well as strategy optimization by machine learning.
 
 ![freqtrade](https://raw.githubusercontent.com/freqtrade/freqtrade/develop/docs/assets/freqtrade-screenshot.png)
 
+## Sponsored promotion
+
+[![tokenbot-promo](https://raw.githubusercontent.com/freqtrade/freqtrade/develop/docs/assets/TokenBot-Freqtrade-banner.png)](https://tokenbot.com/?utm_source=github&utm_medium=freqtrade&utm_campaign=algodevs)
+
 ## Disclaimer
 
 This software is for educational purposes only. Do not risk money which
@@ -26,12 +30,13 @@ hesitate to read the source code and understand the mechanism of this bot.
 
 Please read the [exchange specific notes](docs/exchanges.md) to learn about eventual, special configurations needed for each exchange.
 
-- [X] [Binance](https://www.binance.com/) ([*Note for binance users](docs/exchanges.md#binance-blacklist))
+- [X] [Binance](https://www.binance.com/)
 - [X] [Bittrex](https://bittrex.com/)
-- [X] [FTX](https://ftx.com)
+- [X] [FTX](https://ftx.com/#a=2258149)
 - [X] [Gate.io](https://www.gate.io/ref/6266643)
+- [X] [Huobi](http://huobi.com/)
 - [X] [Kraken](https://kraken.com/)
-- [X] [OKEX](https://www.okex.com/)
+- [X] [OKX](https://okx.com/) (Former OKEX)
 - [ ] [potentially many others](https://github.com/ccxt/ccxt/). _(We cannot guarantee they will work)_
 
 ### Community tested
@@ -57,22 +62,16 @@ Please find the complete documentation on the [freqtrade website](https://www.fr
 - [x] **Edge position sizing** Calculate your win rate, risk reward ratio, the best stoploss and adjust your position size before taking a position for each specific market. [Learn more](https://www.freqtrade.io/en/stable/edge/).
 - [x] **Whitelist crypto-currencies**: Select which crypto-currency you want to trade or use dynamic whitelists.
 - [x] **Blacklist crypto-currencies**: Select which crypto-currency you want to avoid.
+- [x] **Builtin WebUI**: Builtin web UI to manage your bot.
 - [x] **Manageable via Telegram**: Manage the bot with Telegram.
-- [x] **Display profit/loss in fiat**: Display your profit/loss in 33 fiat.
-- [x] **Daily summary of profit/loss**: Provide a daily summary of your profit/loss.
+- [x] **Display profit/loss in fiat**: Display your profit/loss in fiat currency.
 - [x] **Performance status report**: Provide a performance status of your current trades.
 
 ## Quick start
 
-Freqtrade provides a Linux/macOS script to install all dependencies and help you to configure the bot.
+Please refer to the [Docker Quickstart documentation](https://www.freqtrade.io/en/stable/docker_quickstart/) on how to get started quickly.
 
-```bash
-git clone -b develop https://github.com/freqtrade/freqtrade.git
-cd freqtrade
-./setup.sh --install
-```
-
-For any other type of installation please refer to [Installation doc](https://www.freqtrade.io/en/stable/installation/).
+For further (native) installation methods, please refer to the [Installation documentation page](https://www.freqtrade.io/en/stable/installation/).
 
 ## Basic Usage
 

config_examples/config_full.example.json

@@ -8,6 +8,7 @@
     "amend_last_stake_amount": false,
     "last_stake_amount_min_ratio": 0.5,
     "dry_run": true,
+    "dry_run_wallet": 1000,
     "cancel_open_orders_on_exit": false,
     "timeframe": "5m",
     "trailing_stop": false,
@@ -55,7 +56,8 @@
         "forcebuy": "market",
         "stoploss": "market",
         "stoploss_on_exchange": false,
-        "stoploss_on_exchange_interval": 60
+        "stoploss_on_exchange_interval": 60,
+        "stoploss_on_exchange_limit_ratio": 0.99
     },
     "order_time_in_force": {
         "buy": "gtc",
@@ -86,6 +88,7 @@
         "key": "your_exchange_key",
         "secret": "your_exchange_secret",
         "password": "",
+        "log_responses": false,
         "ccxt_config": {},
         "ccxt_async_config": {},
         "pair_whitelist": [

docs/backtesting.md

@@ -26,7 +26,7 @@ usage: freqtrade backtesting [-h] [-v] [--logfile FILE] [-V] [-c PATH]
 
 optional arguments:
   -h, --help            show this help message and exit
-  -i TIMEFRAME, --timeframe TIMEFRAME, --ticker-interval TIMEFRAME
+  -i TIMEFRAME, --timeframe TIMEFRAME
                         Specify timeframe (`1m`, `5m`, `30m`, `1h`, `1d`).
   --timerange TIMERANGE
                         Specify what timerange of data to use.
@@ -63,7 +63,7 @@ optional arguments:
                         `30m`, `1h`, `1d`).
   --strategy-list STRATEGY_LIST [STRATEGY_LIST ...]
                         Provide a space-separated list of strategies to
-                        backtest. Please note that ticker-interval needs to be
+                        backtest. Please note that timeframe needs to be
                         set either in config or via command line. When using
                         this together with `--export trades`, the strategy-
                         name is injected into the filename (so `backtest-
@@ -313,6 +313,7 @@ A backtesting result will look like that:
 | Avg. Duration Winners | 4:23:00             |
 | Avg. Duration Loser   | 6:55:00             |
 | Rejected Buy signals  | 3089                |
+| Entry/Exit Timeouts   | 0 / 0               |
 |                       |                     |
 | Min balance           | 0.00945123 BTC      |
 | Max balance           | 0.01846651 BTC      |
@@ -400,6 +401,7 @@ It contains some useful key metrics about performance of your strategy on backte
 | Avg. Duration Winners | 4:23:00             |
 | Avg. Duration Loser   | 6:55:00             |
 | Rejected Buy signals  | 3089                |
+| Entry/Exit Timeouts   | 0 / 0               |
 |                       |                     |
 | Min balance           | 0.00945123 BTC      |
 | Max balance           | 0.01846651 BTC      |
@@ -429,6 +431,7 @@ It contains some useful key metrics about performance of your strategy on backte
 - `Days win/draw/lose`: Winning / Losing days (draws are usually days without closed trade).
 - `Avg. Duration Winners` / `Avg. Duration Loser`: Average durations for winning and losing trades.
 - `Rejected Buy signals`: Buy signals that could not be acted upon due to max_open_trades being reached.
+- `Entry/Exit Timeouts`: Entry/exit orders which did not fill (only applicable if custom pricing is used).
 - `Min balance` / `Max balance`: Lowest and Highest Wallet balance during the backtest period.
 - `Drawdown (Account)`: Maximum Account Drawdown experienced. Calculated as $(Absolute Drawdown) / (DrawdownHigh + startingBalance)$.
 - `Drawdown`: Maximum, absolute drawdown experienced. Difference between Drawdown High and Subsequent Low point.

docs/bot-basics.md

@@ -24,7 +24,7 @@ By default, loop runs every few seconds (`internals.process_throttle_secs`) and
 
 * Fetch open trades from persistence.
 * Calculate current list of tradable pairs.
-* Download ohlcv data for the pairlist including all [informative pairs](strategy-customization.md#get-data-for-non-tradeable-pairs)  
+* Download OHLCV data for the pairlist including all [informative pairs](strategy-customization.md#get-data-for-non-tradeable-pairs)  
   This step is only executed once per Candle to avoid unnecessary network traffic.
 * Call `bot_loop_start()` strategy callback.
 * Analyze strategy per pair.
@@ -62,6 +62,7 @@ This loop will be repeated again and again until the bot is stopped.
   * Check position adjustments for open trades if enabled and call `adjust_trade_position()` to determine if an additional order is requested.
   * Call `custom_stoploss()` and `custom_sell()` to find custom exit points.
   * For sells based on sell-signal and custom-sell: Call `custom_exit_price()` to determine exit price (Prices are moved to be within the closing candle).
+  * Check for Order timeouts, either via the `unfilledtimeout` configuration, or via `check_buy_timeout()` / `check_sell_timeout()` strategy callbacks.
 * Generate backtest report output
 
 !!! Note

docs/configuration.md

@@ -86,7 +86,7 @@ Mandatory parameters are marked as **Required**, which means that they are requi
 | `amend_last_stake_amount` | Use reduced last stake amount if necessary. [More information below](#configuring-amount-per-trade). <br>*Defaults to `false`.* <br> **Datatype:** Boolean
 | `last_stake_amount_min_ratio` | Defines minimum stake amount that has to be left and executed. Applies only to the last stake amount when it's amended to a reduced value (i.e. if `amend_last_stake_amount` is set to `true`). [More information below](#configuring-amount-per-trade). <br>*Defaults to `0.5`.* <br> **Datatype:** Float (as ratio)
 | `amount_reserve_percent` | Reserve some amount in min pair stake amount. The bot will reserve `amount_reserve_percent` + stoploss value when calculating min pair stake amount in order to avoid possible trade refusals. <br>*Defaults to `0.05` (5%).* <br> **Datatype:** Positive Float as ratio.
-| `timeframe` | The timeframe (former ticker interval) to use (e.g `1m`, `5m`, `15m`, `30m`, `1h` ...). [Strategy Override](#parameters-in-the-strategy). <br> **Datatype:** String
+| `timeframe` | The timeframe to use (e.g `1m`, `5m`, `15m`, `30m`, `1h` ...). [Strategy Override](#parameters-in-the-strategy). <br> **Datatype:** String
 | `fiat_display_currency` | Fiat currency used to show your profits. [More information below](#what-values-can-be-used-for-fiat_display_currency). <br> **Datatype:** String
 | `dry_run` | **Required.** Define if the bot must be in Dry Run or production mode. <br>*Defaults to `true`.* <br> **Datatype:** Boolean
 | `dry_run_wallet` | Define the starting amount in stake currency for the simulated wallet used by the bot running in Dry Run mode.<br>*Defaults to `1000`.* <br> **Datatype:** Float

docs/deprecated.md

@@ -24,6 +24,10 @@ Please refer to [pairlists](plugins.md#pairlists-and-pairlist-handlers) instead.
 Did only download the latest 500 candles, so was ineffective in getting good backtest data.
 Removed in 2019-7-dev (develop branch) and in freqtrade 2019.8.
 
+### `ticker_interval` (now `timeframe`)
+
+Support for `ticker_interval` terminology was deprecated in 2020.6 in favor of `timeframe` - and compatibility code was removed in 2022.3.
+
 ### Allow running multiple pairlists in sequence
 
 The former `"pairlist"` section in the configuration has been removed, and is replaced by `"pairlists"` - being a list to specify a sequence of pairlists.

docs/edge.md

@@ -222,7 +222,7 @@ usage: freqtrade edge [-h] [-v] [--logfile FILE] [-V] [-c PATH] [-d PATH]
 
 optional arguments:
   -h, --help            show this help message and exit
-  -i TIMEFRAME, --timeframe TIMEFRAME, --ticker-interval TIMEFRAME
+  -i TIMEFRAME, --timeframe TIMEFRAME
                         Specify timeframe (`1m`, `5m`, `30m`, `1h`, `1d`).
   --timerange TIMERANGE
                         Specify what timerange of data to use.

docs/exchanges.md

@@ -57,7 +57,7 @@ This configuration enables kraken, as well as rate-limiting to avoid bans from t
 Binance supports [time_in_force](configuration.md#understand-order_time_in_force).
 
 !!! Tip "Stoploss on Exchange"
-    Binance supports `stoploss_on_exchange` and uses stop-loss-limit orders. It provides great advantages, so we recommend to benefit from it.
+    Binance supports `stoploss_on_exchange` and uses `stop-loss-limit` orders. It provides great advantages, so we recommend to benefit from it by enabling stoploss on exchange..
 
 ### Binance Blacklist
 
@@ -177,18 +177,27 @@ Kucoin requires a passphrase for each api key, you will therefore need to add th
 
 Kucoin supports [time_in_force](configuration.md#understand-order_time_in_force).
 
+!!! Tip "Stoploss on Exchange"
+    Kucoin supports `stoploss_on_exchange` and can use both stop-loss-market and stop-loss-limit orders. It provides great advantages, so we recommend to benefit from it.
+    You can use either `"limit"` or `"market"` in the `order_types.stoploss` configuration setting to decide which type of stoploss shall be used.
+
 ### Kucoin Blacklists
 
 For Kucoin, please add `"KCS/<STAKE>"` to your blacklist to avoid issues.
 Accounts having KCS accounts use this to pay for fees - if your first trade happens to be on `KCS`, further trades will consume this position and make the initial KCS trade unsellable as the expected amount is not there anymore.
 
-## OKEX
+## Huobi
 
-OKEX requires a passphrase for each api key, you will therefore need to add this key into the configuration so your exchange section looks as follows:
+!!! Tip "Stoploss on Exchange"
+    Huobi supports `stoploss_on_exchange` and uses `stop-limit` orders. It provides great advantages, so we recommend to benefit from it by enabling stoploss on exchange.
+
+## OKX (former OKEX)
+
+OKX requires a passphrase for each api key, you will therefore need to add this key into the configuration so your exchange section looks as follows:
 
 ```json
 "exchange": {
-    "name": "okex",
+    "name": "okx",
     "key": "your_exchange_key",
     "secret": "your_exchange_secret",
     "password": "your_exchange_api_key_password",
@@ -197,10 +206,13 @@ OKEX requires a passphrase for each api key, you will therefore need to add this
 ```
 
 !!! Warning
-    OKEX only provides 100 candles per api call. Therefore, the strategy will only have a pretty low amount of data available in backtesting mode.
+    OKX only provides 100 candles per api call. Therefore, the strategy will only have a pretty low amount of data available in backtesting mode.
 
 ## Gate.io
 
+!!! Tip "Stoploss on Exchange"
+    Gate.io supports `stoploss_on_exchange` and uses `stop-loss-limit` orders. It provides great advantages, so we recommend to benefit from it by enabling stoploss on exchange..
+
 Gate.io allows the use of `POINT` to pay for fees. As this is not a tradable currency (no regular market available), automatic fee calculations will fail (and default to a fee of 0).
 The configuration parameter `exchange.unknown_fee_rate` can be used to specify the exchange rate between Point and the stake currency. Obviously, changing the stake-currency will also require changes to this value.
 

docs/hyperopt.md

@@ -55,7 +55,7 @@ usage: freqtrade hyperopt [-h] [-v] [--logfile FILE] [-V] [-c PATH] [-d PATH]
 
 optional arguments:
   -h, --help            show this help message and exit
-  -i TIMEFRAME, --timeframe TIMEFRAME, --ticker-interval TIMEFRAME
+  -i TIMEFRAME, --timeframe TIMEFRAME
                         Specify timeframe (`1m`, `5m`, `30m`, `1h`, `1d`).
   --timerange TIMERANGE
                         Specify what timerange of data to use.
@@ -116,7 +116,7 @@ optional arguments:
                         ShortTradeDurHyperOptLoss, OnlyProfitHyperOptLoss,
                         SharpeHyperOptLoss, SharpeHyperOptLossDaily,
                         SortinoHyperOptLoss, SortinoHyperOptLossDaily,
-                        CalmarHyperOptLoss, MaxDrawDownHyperOptLoss
+                        CalmarHyperOptLoss, MaxDrawDownHyperOptLoss, ProfitDrawDownHyperOptLoss
   --disable-param-export
                         Disable automatic hyperopt parameter export.
   --ignore-missing-spaces, --ignore-unparameterized-spaces
@@ -508,6 +508,46 @@ class MyAwesomeStrategy(IStrategy):
 
 You will then obviously also change potential interesting entries to parameters to allow hyper-optimization.
 
+### Optimizing `max_entry_position_adjustment`
+
+While `max_entry_position_adjustment` is not a separate space, it can still be used in hyperopt by using the property approach shown above.
+
+``` python
+from pandas import DataFrame
+from functools import reduce
+
+import talib.abstract as ta
+
+from freqtrade.strategy import (BooleanParameter, CategoricalParameter, DecimalParameter, 
+                                IStrategy, IntParameter)
+import freqtrade.vendor.qtpylib.indicators as qtpylib
+
+class MyAwesomeStrategy(IStrategy):
+    stoploss = -0.05
+    timeframe = '15m'
+
+    # Define the parameter spaces
+    max_epa = CategoricalParameter([-1, 0, 1, 3, 5, 10], default=1, space="buy", optimize=True)
+
+    @property
+    def max_entry_position_adjustment(self):
+        return self.max_epa.value
+        
+
+    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        # ...
+```
+
+??? Tip "Using `IntParameter`"
+    You can also use the `IntParameter` for this optimization, but you must explicitly return an integer:
+    ``` python
+    max_epa = IntParameter(-1, 10, default=1, space="buy", optimize=True)
+
+    @property
+    def max_entry_position_adjustment(self):
+        return int(self.max_epa.value)
+    ```
+
 ## Loss-functions
 
 Each hyperparameter tuning requires a target. This is usually defined as a loss function (sometimes also called objective function), which should decrease for more desirable results, and increase for bad results.
@@ -525,6 +565,7 @@ Currently, the following loss functions are builtin:
 * `SortinoHyperOptLossDaily` - optimizes Sortino Ratio calculated on **daily** trade returns relative to **downside** standard deviation.
 * `MaxDrawDownHyperOptLoss` - Optimizes Maximum drawdown.
 * `CalmarHyperOptLoss` - Optimizes Calmar Ratio calculated on trade returns relative to max drawdown.
+* `ProfitDrawDownHyperOptLoss` - Optimizes by max Profit & min Drawdown objective. `DRAWDOWN_MULT` variable within the hyperoptloss file can be adjusted to be stricter or more flexible on drawdown purposes.
 
 Creation of a custom loss function is covered in the [Advanced Hyperopt](advanced-hyperopt.md) part of the documentation.
 

docs/includes/pairlists.md

@@ -246,7 +246,7 @@ On exchanges that deduct fees from the receiving currency (e.g. FTX) - this can
 The `low_price_ratio` setting removes pairs where a raise of 1 price unit (pip) is above the `low_price_ratio` ratio.
 This option is disabled by default, and will only apply if set to > 0.
 
-For `PriceFiler` at least one of its `min_price`, `max_price` or `low_price_ratio` settings must be applied.
+For `PriceFilter` at least one of its `min_price`, `max_price` or `low_price_ratio` settings must be applied.
 
 Calculation example:
 

docs/includes/pricing.md

@@ -51,9 +51,9 @@ When buying with the orderbook enabled (`bid_strategy.use_order_book=True`), Fre
 
 #### Buy price without Orderbook enabled
 
-The following section uses `side` as the configured `bid_strategy.price_side`.
+The following section uses `side` as the configured `bid_strategy.price_side` (defaults to `"bid"`).
 
-When not using orderbook (`bid_strategy.use_order_book=False`), Freqtrade uses the best `side` price from the ticker if it's below the `last` traded price from the ticker. Otherwise (when the `side` price is above the `last` price), it calculates a rate between `side` and `last` price.
+When not using orderbook (`bid_strategy.use_order_book=False`), Freqtrade uses the best `side` price from the ticker if it's below the `last` traded price from the ticker. Otherwise (when the `side` price is above the `last` price), it calculates a rate between `side` and `last` price based on `bid_strategy.ask_last_balance`..
 
 The `bid_strategy.ask_last_balance` configuration parameter controls this. A value of `0.0` will use `side` price, while `1.0` will use the `last` price and values between those interpolate between ask and last price.
 
@@ -88,9 +88,9 @@ When selling with the orderbook enabled (`ask_strategy.use_order_book=True`), Fr
 
 #### Sell price without Orderbook enabled
 
-When not using orderbook (`ask_strategy.use_order_book=False`), the price at the `ask_strategy.price_side` side (defaults to `"ask"`) from the ticker will be used as the sell price.
+The following section uses `side` as the configured `ask_strategy.price_side` (defaults to `"ask"`).
 
-When not using orderbook (`ask_strategy.use_order_book=False`), Freqtrade uses the best `side` price from the ticker if it's below the `last` traded price from the ticker. Otherwise (when the `side` price is above the `last` price), it calculates a rate between `side` and `last` price.
+When not using orderbook (`ask_strategy.use_order_book=False`), Freqtrade uses the best `side` price from the ticker if it's above the `last` traded price from the ticker. Otherwise (when the `side` price is below the `last` price), it calculates a rate between `side` and `last` price based on `ask_strategy.bid_last_balance`.
 
 The `ask_strategy.bid_last_balance` configuration parameter controls this. A value of `0.0` will use `side` price, while `1.0` will use the last price and values between those interpolate between `side` and last price.
 

docs/index.md

@@ -11,7 +11,7 @@
 
 ## Introduction
 
-Freqtrade is a crypto-currency algorithmic trading software developed in python (3.8+) and supported on Windows, macOS and Linux.
+Freqtrade is a free and open source crypto trading bot written in Python. It is designed to support all major exchanges and be controlled via Telegram or webUI. It contains backtesting, plotting and money management tools as well as strategy optimization by machine learning.
 
 !!! Danger "DISCLAIMER"
     This software is for educational purposes only. Do not risk money which you are afraid to lose. USE THE SOFTWARE AT YOUR OWN RISK. THE AUTHORS AND ALL AFFILIATES ASSUME NO RESPONSIBILITY FOR YOUR TRADING RESULTS.
@@ -20,6 +20,12 @@ Freqtrade is a crypto-currency algorithmic trading software developed in python
 
     We strongly recommend you to have basic coding skills and Python knowledge. Do not hesitate to read the source code and understand the mechanisms of this bot, algorithms and techniques implemented in it.
 
+![freqtrade screenshot](assets/freqtrade-screenshot.png)
+
+## Sponsored promotion
+
+[![tokenbot-promo](assets/TokenBot-Freqtrade-banner.png)](https://tokenbot.com/?utm_source=github&utm_medium=freqtrade&utm_campaign=algodevs)
+
 ## Features
 
 - Develop your Strategy: Write your strategy in python, using [pandas](https://pandas.pydata.org/). Example strategies to inspire you are available in the [strategy repository](https://github.com/freqtrade/freqtrade-strategies).
@@ -29,19 +35,20 @@ Freqtrade is a crypto-currency algorithmic trading software developed in python
 - Select markets: Create your static list or use an automatic one based on top traded volumes and/or prices (not available during backtesting). You can also explicitly blacklist markets you don't want to trade.
 - Run: Test your strategy with simulated money (Dry-Run mode) or deploy it with real money (Live-Trade mode).
 - Run using Edge (optional module): The concept is to find the best historical [trade expectancy](edge.md#expectancy) by markets based on variation of the stop-loss and then allow/reject markets to trade. The sizing of the trade is based on a risk of a percentage of your capital.
-- Control/Monitor: Use Telegram or a REST API (start/stop the bot, show profit/loss, daily summary, current open trades results, etc.).
+- Control/Monitor: Use Telegram or a WebUI (start/stop the bot, show profit/loss, daily summary, current open trades results, etc.).
 - Analyse: Further analysis can be performed on either Backtesting data or Freqtrade trading history (SQL database), including automated standard plots, and methods to load the data into [interactive environments](data-analysis.md).
 
 ## Supported exchange marketplaces
 
 Please read the [exchange specific notes](exchanges.md) to learn about eventual, special configurations needed for each exchange.
 
-- [X] [Binance](https://www.binance.com/) ([*Note for binance users](exchanges.md#binance-blacklist))
+- [X] [Binance](https://www.binance.com/)
 - [X] [Bittrex](https://bittrex.com/)
-- [X] [FTX](https://ftx.com)
+- [X] [FTX](https://ftx.com/#a=2258149)
 - [X] [Gate.io](https://www.gate.io/ref/6266643)
+- [X] [Huobi](http://huobi.com/)
 - [X] [Kraken](https://kraken.com/)
-- [X] [OKEX](https://www.okex.com/)
+- [X] [OKX](https://okx.com/) (Former OKEX)
 - [ ] [potentially many others through <img alt="ccxt" width="30px" src="assets/ccxt-logo.svg" />](https://github.com/ccxt/ccxt/). _(We cannot guarantee they will work)_
 
 ### Community tested

docs/installation.md

@@ -24,7 +24,7 @@ The easiest way to install and run Freqtrade is to clone the bot Github reposito
     The `stable` branch contains the code of the last release (done usually once per month on an approximately one week old snapshot of the `develop` branch to prevent packaging bugs, so potentially it's more stable).
 
 !!! Note
-    Python3.7 or higher and the corresponding `pip` are assumed to be available. The install-script will warn you and stop if that's not the case. `git` is also needed to clone the Freqtrade repository.  
+    Python3.8 or higher and the corresponding `pip` are assumed to be available. The install-script will warn you and stop if that's not the case. `git` is also needed to clone the Freqtrade repository.  
     Also, python headers (`python<yourversion>-dev` / `python<yourversion>-devel`) must be available for the installation to complete successfully.
 
 !!! Warning "Up-to-date clock"
@@ -54,7 +54,7 @@ We've included/collected install instructions for Ubuntu, MacOS, and Windows. Th
 OS Specific steps are listed first, the [Common](#common) section below is necessary for all systems.
 
 !!! Note
-    Python3.7 or higher and the corresponding pip are assumed to be available.
+    Python3.8 or higher and the corresponding pip are assumed to be available.
 
 === "Debian/Ubuntu"
     #### Install necessary dependencies
@@ -69,7 +69,7 @@ OS Specific steps are listed first, the [Common](#common) section below is neces
 
 === "RaspberryPi/Raspbian"
     The following assumes the latest [Raspbian Buster lite image](https://www.raspberrypi.org/downloads/raspbian/).
-    This image comes with python3.7 preinstalled, making it easy to get freqtrade up and running.
+    This image comes with python3.9 preinstalled, making it easy to get freqtrade up and running.
 
     Tested using a Raspberry Pi 3 with the Raspbian Buster lite image, all updates applied.
 
@@ -169,7 +169,7 @@ You can as well update, configure and reset the codebase of your bot with `./scr
 ** --install **
 
 With this option, the script will install the bot and most dependencies:
-You will need to have git and python3.7+ installed beforehand for this to work.
+You will need to have git and python3.8+ installed beforehand for this to work.
 
 * Mandatory software as: `ta-lib`
 * Setup your virtualenv under `.env/`

docs/plotting.md

@@ -65,7 +65,7 @@ optional arguments:
                         _today.json`
   --timerange TIMERANGE
                         Specify what timerange of data to use.
-  -i TIMEFRAME, --timeframe TIMEFRAME, --ticker-interval TIMEFRAME
+  -i TIMEFRAME, --timeframe TIMEFRAME
                         Specify timeframe (`1m`, `5m`, `30m`, `1h`, `1d`).
   --no-trades           Skip using trades from backtesting file and DB.
 
@@ -318,8 +318,8 @@ optional arguments:
                         Specify what timerange of data to use.
   --export EXPORT       Export backtest results, argument are: trades.
                         Example: `--export=trades`
-  --export-filename PATH
-                        Save backtest results to the file with this filename.
+  --export-filename PATH, --backtest-filename PATH
+                        Use backtest results from this filename.
                         Requires `--export` to be set as well. Example:
                         `--export-filename=user_data/backtest_results/backtest
                         _today.json`
@@ -330,7 +330,7 @@ optional arguments:
   --trade-source {DB,file}
                         Specify the source for trades (Can be DB or file
                         (backtest file)) Default: file
-  -i TIMEFRAME, --timeframe TIMEFRAME, --ticker-interval TIMEFRAME
+  -i TIMEFRAME, --timeframe TIMEFRAME
                         Specify timeframe (`1m`, `5m`, `30m`, `1h`, `1d`).
   --auto-open           Automatically open generated plot.
 

docs/requirements-docs.txt

@@ -1,4 +1,5 @@
 mkdocs==1.2.3
-mkdocs-material==8.1.9
+mkdocs-material==8.2.5
 mdx_truly_sane_lists==1.2
-pymdown-extensions==9.1
+pymdown-extensions==9.3
+jinja2==3.0.3

docs/stoploss.md

@@ -2,6 +2,7 @@
 
 The `stoploss` configuration parameter is loss as ratio that should trigger a sale.
 For example, value `-0.10` will cause immediate sell if the profit dips below -10% for a given trade. This parameter is optional.
+Stoploss calculations do include fees, so a stoploss of -10% is placed exactly 10% below the entry point.
 
 Most of the strategy files already include the optimal `stoploss` value.
 
@@ -23,14 +24,14 @@ These modes can be configured with these values:
 ```
 
 !!! Note
-    Stoploss on exchange is only supported for Binance (stop-loss-limit), Kraken (stop-loss-market, stop-loss-limit) and FTX (stop limit and stop-market) as of now.  
+    Stoploss on exchange is only supported for Binance (stop-loss-limit), Huobi (stop-limit), Kraken (stop-loss-market, stop-loss-limit), FTX (stop limit and stop-market) Gateio (stop-limit), and Kucoin (stop-limit and stop-market) as of now.  
     <ins>Do not set too low/tight stoploss value if using stop loss on exchange!</ins>  
     If set to low/tight then you have greater risk of missing fill on the order and stoploss will not work.
 
 ### stoploss_on_exchange and stoploss_on_exchange_limit_ratio
 
 Enable or Disable stop loss on exchange.
-If the stoploss is *on exchange* it means a stoploss limit order is placed on the exchange immediately after buy order happens successfully. This will protect you against sudden crashes in market as the order will be in the queue immediately and if market goes down then the order has more chance of being fulfilled.
+If the stoploss is *on exchange* it means a stoploss limit order is placed on the exchange immediately after buy order fills. This will protect you against sudden crashes in market, as the order execution happens purely within the exchange, and has no potential network overhead.
 
 If `stoploss_on_exchange` uses limit orders, the exchange needs 2 prices, the stoploss_price and the Limit price.  
 `stoploss` defines the stop-price where the limit order is placed - and limit should be slightly below this.  

docs/strategy-advanced.md

@@ -146,7 +146,7 @@ def version(self) -> str:
 
 The strategies can be derived from other strategies. This avoids duplication of your custom strategy code. You can use this technique to override small parts of your main strategy, leaving the rest untouched:
 
-``` python
+``` python title="user_data/strategies/myawesomestrategy.py"
 class MyAwesomeStrategy(IStrategy):
     ...
     stoploss = 0.13
@@ -155,6 +155,10 @@ class MyAwesomeStrategy(IStrategy):
     # should be in any custom strategy...
     ...
 
+```
+
+``` python title="user_data/strategies/MyAwesomeStrategy2.py"
+from myawesomestrategy import MyAwesomeStrategy
 class MyAwesomeStrategy2(MyAwesomeStrategy):
     # Override something
     stoploss = 0.08
@@ -163,16 +167,7 @@ class MyAwesomeStrategy2(MyAwesomeStrategy):
 
 Both attributes and methods may be overridden, altering behavior of the original strategy in a way you need.
 
-!!! Note "Parent-strategy in different files"
-    If you have the parent-strategy in a different file, you'll need to add the following to the top of your "child"-file to ensure proper loading, otherwise freqtrade may not be able to load the parent strategy correctly.
-
-    ``` python
-    import sys
-    from pathlib import Path
-    sys.path.append(str(Path(__file__).parent))
-
-    from myawesomestrategy import MyAwesomeStrategy
-    ```
+While keeping the subclass in the same file is technically possible, it can lead to some problems with hyperopt parameter files, we therefore recommend to use separate strategy files, and import the parent strategy as shown above.
 
 ## Embedding Strategies
 

docs/strategy-callbacks.md

@@ -389,8 +389,8 @@ class AwesomeStrategy(IStrategy):
     If the new_entryprice is 97, the proposed_rate is 100 and the `custom_price_max_distance_ratio` is set to 2%, The retained valid custom entry price will be 98, which is 2% below the current (proposed) rate.
 
 !!! Warning "Backtesting"
-    While Custom prices are supported in backtesting (starting with 2021.12), prices will be moved to within the candle's high/low prices.
-    This behavior is currently being tested, and might be changed at a later point.
+    Custom prices are supported in backtesting (starting with 2021.12), and orders will fill if the price falls within the candle's low/high range.
+    Orders that don't fill immediately are subject to regular timeout handling, which happens once per (detail) candle.
     `custom_exit_price()` is only called for sells of type Sell_signal and Custom sell. All other sell-types will use regular backtesting prices.
 
 ## Custom order timeout rules
@@ -400,7 +400,8 @@ Simple, time-based order-timeouts can be configured either via strategy or in th
 However, freqtrade also offers a custom callback for both order types, which allows you to decide based on custom criteria if an order did time out or not.
 
 !!! Note
-    Unfilled order timeouts are not relevant during backtesting or hyperopt, and are only relevant during real (live) trading. Therefore these methods are only called in these circumstances.
+    Backtesting fills orders if their price falls within the candle's low/high range.
+    The below callbacks will be called once per (detail) candle for orders that don't fill immediately (which use custom pricing).
 
 ### Custom order timeout example
 
@@ -467,7 +468,8 @@ class AwesomeStrategy(IStrategy):
         'sell': 60 * 25
     }
 
-    def check_buy_timeout(self, pair: str, trade: Trade, order: dict, **kwargs) -> bool:
+    def check_buy_timeout(self, pair: str, trade: Trade, order: dict,
+                          current_time: datetime, **kwargs) -> bool:
         ob = self.dp.orderbook(pair, 1)
         current_price = ob['bids'][0][0]
         # Cancel buy order if price is more than 2% above the order.
@@ -476,7 +478,8 @@ class AwesomeStrategy(IStrategy):
         return False
 
 
-    def check_sell_timeout(self, pair: str, trade: Trade, order: dict, **kwargs) -> bool:
+    def check_sell_timeout(self, pair: str, trade: Trade, order: dict,
+                           current_time: datetime, **kwargs) -> bool:
         ob = self.dp.orderbook(pair, 1)
         current_price = ob['asks'][0][0]
         # Cancel sell order if price is more than 2% below the order.

docs/strategy-customization.md

@@ -325,7 +325,7 @@ stoploss = -0.10
 
 For the full documentation on stoploss features, look at the dedicated [stoploss page](stoploss.md).
 
-### Timeframe (formerly ticker interval)
+### Timeframe
 
 This is the set of candles the bot should download and use for the analysis.
 Common values are `"1m"`, `"5m"`, `"15m"`, `"1h"`, however all values supported by your exchange should work.

docs/telegram-usage.md

@@ -277,6 +277,7 @@ Starting capital is either taken from the `available_capital` setting, or calcul
 > **BITTREX:** Buying ETH/BTC with limit `0.03400000` (`1.000000 ETH`, `225.290 USD`)
 
 Omitting the pair will open a query asking for the pair to buy (based on the current whitelist).
+Trades crated through `/forcebuy` will have the buy-tag of `forceentry`.
 
 ![Telegram force-buy screenshot](assets/telegram_forcebuy.png)
 

docs/utils.md

@@ -517,20 +517,25 @@ Requires a configuration with specified `pairlists` attribute.
 Can be used to generate static pairlists to be used during backtesting / hyperopt.
 
 ```
-usage: freqtrade test-pairlist [-h] [-c PATH]
+usage: freqtrade test-pairlist [-h] [-v] [-c PATH]
                                [--quote QUOTE_CURRENCY [QUOTE_CURRENCY ...]]
-                               [-1] [--print-json]
+                               [-1] [--print-json] [--exchange EXCHANGE]
 
 optional arguments:
   -h, --help            show this help message and exit
+  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
   -c PATH, --config PATH
-                        Specify configuration file (default: `config.json`).
-                        Multiple --config options may be used. Can be set to
-                        `-` to read config from stdin.
+                        Specify configuration file (default:
+                        `userdir/config.json` or `config.json` whichever
+                        exists). Multiple --config options may be used. Can be
+                        set to `-` to read config from stdin.
   --quote QUOTE_CURRENCY [QUOTE_CURRENCY ...]
                         Specify quote currency(-ies). Space-separated list.
   -1, --one-column      Print output in one column.
   --print-json          Print list of pairs or market symbols in JSON format.
+  --exchange EXCHANGE   Exchange name (default: `bittrex`). Only valid if no
+                        config is provided.
+
 ```
 
 ### Examples

docs/windows_installation.md

@@ -54,6 +54,8 @@ error: Microsoft Visual C++ 14.0 is required. Get it with "Microsoft Visual C++
 
 Unfortunately, many packages requiring compilation don't provide a pre-built wheel. It is therefore mandatory to have a C/C++ compiler installed and available for your python environment to use.
 
-The easiest way is to download install Microsoft Visual Studio Community [here](https://visualstudio.microsoft.com/downloads/) and make sure to install "Common Tools for Visual C++" to enable building C code on Windows. Unfortunately, this is a heavy download / dependency (~4Gb) so you might want to consider WSL or [docker compose](docker_quickstart.md) first.
+You can download the Visual C++ build tools from [here](https://visualstudio.microsoft.com/visual-cpp-build-tools/) and install "Desktop development with C++" in it's default configuration. Unfortunately, this is a heavy download / dependency so you might want to consider WSL2 or [docker compose](docker_quickstart.md) first.
+
+![Windows installation](assets/windows_install.png)
 
 ---

freqtrade/__init__.py

@@ -1,27 +1,14 @@
 """ Freqtrade bot """
-__version__ = '2022.1'
-
-if __version__ == 'develop':
+__version__ = '2022.3'
 
+if 'dev' in __version__:
     try:
         import subprocess
 
-        __version__ = 'develop-' + subprocess.check_output(
+        __version__ = __version__ + '-' + subprocess.check_output(
             ['git', 'log', '--format="%h"', '-n 1'],
             stderr=subprocess.DEVNULL).decode("utf-8").rstrip().strip('"')
 
-        # from datetime import datetime
-        # last_release = subprocess.check_output(
-        #     ['git', 'tag']
-        # ).decode('utf-8').split()[-1].split(".")
-        # # Releases are in the format "2020.1" - we increment the latest version for dev.
-        # prefix = f"{last_release[0]}.{int(last_release[1]) + 1}"
-        # dev_version = int(datetime.now().timestamp() // 1000)
-        # __version__ = f"{prefix}.dev{dev_version}"
-
-        #  subprocess.check_output(
-        #     ['git', 'log', '--format="%h"', '-n 1'],
-        #     stderr=subprocess.DEVNULL).decode("utf-8").rstrip().strip('"')
     except Exception:  # pragma: no cover
         # git not available, ignore
         try:

freqtrade/commands/arguments.py

@@ -51,7 +51,7 @@ ARGS_LIST_PAIRS = ["exchange", "print_list", "list_pairs_print_json", "print_one
                    "print_csv", "base_currencies", "quote_currencies", "list_pairs_all"]
 
 ARGS_TEST_PAIRLIST = ["verbosity", "config", "quote_currencies", "print_one_column",
-                      "list_pairs_print_json"]
+                      "list_pairs_print_json", "exchange"]
 
 ARGS_CREATE_USERDIR = ["user_data_dir", "reset"]
 
@@ -75,7 +75,7 @@ ARGS_PLOT_DATAFRAME = ["pairs", "indicators1", "indicators2", "plot_limit",
                        "timerange", "timeframe", "no_trades"]
 
 ARGS_PLOT_PROFIT = ["pairs", "timerange", "export", "exportfilename", "db_url",
-                    "trade_source", "timeframe", "plot_auto_open"]
+                    "trade_source", "timeframe", "plot_auto_open", ]
 
 ARGS_INSTALL_UI = ["erase_ui_only", 'ui_version']
 

freqtrade/commands/build_config_commands.py

@@ -108,11 +108,12 @@ def ask_user_config() -> Dict[str, Any]:
                 "binance",
                 "binanceus",
                 "bittrex",
-                "kraken",
                 "ftx",
-                "kucoin",
                 "gateio",
-                "okex",
+                "huobi",
+                "kraken",
+                "kucoin",
+                "okx",
                 Separator(),
                 "other",
             ],
@@ -140,7 +141,7 @@ def ask_user_config() -> Dict[str, Any]:
             "type": "password",
             "name": "exchange_key_password",
             "message": "Insert Exchange API Key password",
-            "when": lambda x: not x['dry_run'] and x['exchange_name'] in ('kucoin', 'okex')
+            "when": lambda x: not x['dry_run'] and x['exchange_name'] in ('kucoin', 'okx')
         },
         {
             "type": "confirm",

freqtrade/commands/cli_options.py

@@ -117,7 +117,7 @@ AVAILABLE_CLI_OPTIONS = {
     ),
     # Optimize common
     "timeframe": Arg(
-        '-i', '--timeframe', '--ticker-interval',
+        '-i', '--timeframe',
         help='Specify timeframe (`1m`, `5m`, `30m`, `1h`, `1d`).',
     ),
     "timerange": Arg(
@@ -169,7 +169,7 @@ AVAILABLE_CLI_OPTIONS = {
     "strategy_list": Arg(
         '--strategy-list',
         help='Provide a space-separated list of strategies to backtest. '
-        'Please note that ticker-interval needs to be set either in config '
+        'Please note that timeframe needs to be set either in config '
         'or via command line. When using this together with `--export trades`, '
         'the strategy-name is injected into the filename '
         '(so `backtest-data.json` becomes `backtest-data-SampleStrategy.json`',
@@ -182,11 +182,12 @@ AVAILABLE_CLI_OPTIONS = {
 
     ),
     "exportfilename": Arg(
-        '--export-filename',
-        help='Save backtest results to the file with this filename. '
-        'Requires `--export` to be set as well. '
-        'Example: `--export-filename=user_data/backtest_results/backtest_today.json`',
-        metavar='PATH',
+        "--export-filename",
+        "--backtest-filename",
+        help="Use this filename for backtest results."
+        "Requires `--export` to be set as well. "
+        "Example: `--export-filename=user_data/backtest_results/backtest_today.json`",
+        metavar="PATH",
     ),
     "disableparamexport": Arg(
         '--disable-param-export',

freqtrade/commands/optimize_commands.py

@@ -25,12 +25,16 @@ def setup_optimize_configuration(args: Dict[str, Any], method: RunMode) -> Dict[
         RunMode.HYPEROPT: 'hyperoptimization',
     }
     if method in no_unlimited_runmodes.keys():
+        wallet_size = config['dry_run_wallet'] * config['tradable_balance_ratio']
+        # tradable_balance_ratio
         if (config['stake_amount'] != constants.UNLIMITED_STAKE_AMOUNT
-                and config['stake_amount'] > config['dry_run_wallet']):
-            wallet = round_coin_value(config['dry_run_wallet'], config['stake_currency'])
+                and config['stake_amount'] > wallet_size):
+            wallet = round_coin_value(wallet_size, config['stake_currency'])
             stake = round_coin_value(config['stake_amount'], config['stake_currency'])
-            raise OperationalException(f"Starting balance ({wallet}) "
-                                       f"is smaller than stake_amount {stake}.")
+            raise OperationalException(
+                f"Starting balance ({wallet}) is smaller than stake_amount {stake}. "
+                f"Wallet is calculated as `dry_run_wallet * tradable_balance_ratio`."
+                )
 
     return config
 

freqtrade/configuration/configuration.py

@@ -431,7 +431,6 @@ class Configuration:
                              logstring='Using "{}" to store trades data.')
 
     def _process_data_options(self, config: Dict[str, Any]) -> None:
-
         self._args_to_config(config, argname='new_pairs_days',
                              logstring='Detected --new-pairs-days: {}')
 

freqtrade/configuration/deprecated_settings.py

@@ -100,16 +100,11 @@ def process_temporary_deprecated_settings(config: Dict[str, Any]) -> None:
             "from the edge configuration."
         )
     if 'ticker_interval' in config:
-        logger.warning(
-            "DEPRECATED: "
+
+        raise OperationalException(
+            "DEPRECATED: 'ticker_interval' detected. "
             "Please use 'timeframe' instead of 'ticker_interval."
         )
-        if 'timeframe' in config:
-            raise OperationalException(
-                "Both 'timeframe' and 'ticker_interval' detected."
-                "Please remove 'ticker_interval' from your configuration to continue operating."
-            )
-        config['timeframe'] = config['ticker_interval']
 
     if 'protections' in config:
         logger.warning("DEPRECATED: Setting 'protections' in the configuration is deprecated.")

freqtrade/constants.py

@@ -26,7 +26,7 @@ HYPEROPT_LOSS_BUILTIN = ['ShortTradeDurHyperOptLoss', 'OnlyProfitHyperOptLoss',
                          'SharpeHyperOptLoss', 'SharpeHyperOptLossDaily',
                          'SortinoHyperOptLoss', 'SortinoHyperOptLossDaily',
                          'CalmarHyperOptLoss',
-                         'MaxDrawDownHyperOptLoss']
+                         'MaxDrawDownHyperOptLoss', 'ProfitDrawDownHyperOptLoss']
 AVAILABLE_PAIRLISTS = ['StaticPairList', 'VolumePairList',
                        'AgeFilter', 'OffsetFilter', 'PerformanceFilter',
                        'PrecisionFilter', 'PriceFilter', 'RangeStabilityFilter',
@@ -140,7 +140,7 @@ CONF_SCHEMA = {
             'minProperties': 1
         },
         'amount_reserve_percent': {'type': 'number', 'minimum': 0.0, 'maximum': 0.5},
-        'stoploss': {'type': 'number', 'maximum': 0, 'exclusiveMaximum': True},
+        'stoploss': {'type': 'number', 'maximum': 0, 'exclusiveMaximum': True, 'minimum': -1},
         'trailing_stop': {'type': 'boolean'},
         'trailing_stop_positive': {'type': 'number', 'minimum': 0, 'maximum': 1},
         'trailing_stop_positive_offset': {'type': 'number', 'minimum': 0, 'maximum': 1},
@@ -440,7 +440,6 @@ SCHEMA_TRADE_REQUIRED = [
     'dry_run_wallet',
     'ask_strategy',
     'bid_strategy',
-    'unfilledtimeout',
     'stoploss',
     'minimal_roi',
     'internals',

freqtrade/edge/edge_positioning.py

@@ -219,9 +219,11 @@ class Edge:
         """
         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:
+            if (
+                info.expectancy > float(self.edge_config.get('minimum_expectancy', 0.2))
+                and info.winrate > float(self.edge_config.get('minimum_winrate', 0.60))
+                and pair in pairs
+            ):
                 final.append(pair)
 
         if self._final_pairs != final:
@@ -246,8 +248,8 @@ class Edge:
         """
         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)):
+            if (info.expectancy > float(self.edge_config.get('minimum_expectancy', 0.2)) and
+                    info.winrate > float(self.edge_config.get('minimum_winrate', 0.60))):
                 final.append({
                     'Pair': pair,
                     'Winrate': info.winrate,

freqtrade/exchange/__init__.py

@@ -18,6 +18,7 @@ from freqtrade.exchange.exchange import (available_exchanges, ccxt_exchanges,
 from freqtrade.exchange.ftx import Ftx
 from freqtrade.exchange.gateio import Gateio
 from freqtrade.exchange.hitbtc import Hitbtc
+from freqtrade.exchange.huobi import Huobi
 from freqtrade.exchange.kraken import Kraken
 from freqtrade.exchange.kucoin import Kucoin
-from freqtrade.exchange.okex import Okex
+from freqtrade.exchange.okx import Okx

freqtrade/exchange/binance.py

@@ -3,12 +3,8 @@ import logging
 from typing import Dict, List, Tuple
 
 import arrow
-import ccxt
 
-from freqtrade.exceptions import (DDosProtection, InsufficientFundsError, InvalidOrderException,
-                                  OperationalException, TemporaryError)
 from freqtrade.exchange import Exchange
-from freqtrade.exchange.common import retrier
 
 
 logger = logging.getLogger(__name__)
@@ -18,6 +14,7 @@ class Binance(Exchange):
 
     _ft_has: Dict = {
         "stoploss_on_exchange": True,
+        "stoploss_order_types": {"limit": "stop_loss_limit"},
         "order_time_in_force": ['gtc', 'fok', 'ioc'],
         "time_in_force_parameter": "timeInForce",
         "ohlcv_candle_limit": 1000,
@@ -33,65 +30,6 @@ class Binance(Exchange):
         """
         return order['type'] == 'stop_loss_limit' and stop_loss > float(order['info']['stopPrice'])
 
-    @retrier(retries=0)
-    def stoploss(self, pair: str, amount: float, stop_price: float, order_types: Dict) -> Dict:
-        """
-        creates a stoploss limit order.
-        this stoploss-limit is binance-specific.
-        It may work with a limited number of other exchanges, but this has not been tested yet.
-        """
-        # Limit price threshold: As limit price should always be below stop-price
-        limit_price_pct = order_types.get('stoploss_on_exchange_limit_ratio', 0.99)
-        rate = stop_price * limit_price_pct
-
-        ordertype = "stop_loss_limit"
-
-        stop_price = self.price_to_precision(pair, stop_price)
-
-        # Ensure rate is less than stop price
-        if stop_price <= rate:
-            raise OperationalException(
-                'In stoploss limit order, stop price should be more than limit price')
-
-        if self._config['dry_run']:
-            dry_order = self.create_dry_run_order(
-                pair, ordertype, "sell", amount, stop_price)
-            return dry_order
-
-        try:
-            params = self._params.copy()
-            params.update({'stopPrice': stop_price})
-
-            amount = self.amount_to_precision(pair, amount)
-
-            rate = self.price_to_precision(pair, rate)
-
-            order = self._api.create_order(symbol=pair, type=ordertype, side='sell',
-                                           amount=amount, price=rate, params=params)
-            logger.info('stoploss limit order added for %s. '
-                        'stop price: %s. limit: %s', pair, stop_price, rate)
-            self._log_exchange_response('create_stoploss_order', order)
-            return order
-        except ccxt.InsufficientFunds as e:
-            raise InsufficientFundsError(
-                f'Insufficient funds to create {ordertype} sell order on market {pair}. '
-                f'Tried to sell amount {amount} at rate {rate}. '
-                f'Message: {e}') from e
-        except ccxt.InvalidOrder as e:
-            # Errors:
-            # `binance Order would trigger immediately.`
-            raise InvalidOrderException(
-                f'Could not create {ordertype} sell order on market {pair}. '
-                f'Tried to sell amount {amount} at rate {rate}. '
-                f'Message: {e}') from e
-        except ccxt.DDoSProtection as e:
-            raise DDosProtection(e) from e
-        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not place sell order due to {e.__class__.__name__}. Message: {e}') from e
-        except ccxt.BaseError as e:
-            raise OperationalException(e) from e
-
     async def _async_get_historic_ohlcv(self, pair: str, timeframe: str,
                                         since_ms: int, is_new_pair: bool = False,
                                         raise_: bool = False

freqtrade/exchange/common.py

@@ -28,12 +28,14 @@ API_FETCH_ORDER_RETRY_COUNT = 5
 BAD_EXCHANGES = {
     "bitmex": "Various reasons.",
     "phemex": "Does not provide history.",
+    "probit": "Requires additional, regular calls to `signIn()`.",
     "poloniex": "Does not provide fetch_order endpoint to fetch both open and closed orders.",
 }
 
 MAP_EXCHANGE_CHILDCLASS = {
     'binanceus': 'binance',
     'binanceje': 'binance',
+    'okex': 'okx',
 }
 
 

freqtrade/exchange/exchange.py

@@ -9,7 +9,7 @@ import logging
 from copy import deepcopy
 from datetime import datetime, timedelta, timezone
 from math import ceil
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Coroutine, Dict, List, Optional, Tuple
 
 import arrow
 import ccxt
@@ -600,7 +600,8 @@ class Exchange:
     # Dry-run methods
 
     def create_dry_run_order(self, pair: str, ordertype: str, side: str, amount: float,
-                             rate: float, params: Dict = {}) -> Dict[str, Any]:
+                             rate: float, params: Dict = {},
+                             stop_loss: bool = False) -> Dict[str, Any]:
         order_id = f'dry_run_{side}_{datetime.now().timestamp()}'
         _amount = self.amount_to_precision(pair, amount)
         dry_order: Dict[str, Any] = {
@@ -616,14 +617,17 @@ class Exchange:
             'remaining': _amount,
             'datetime': arrow.utcnow().strftime('%Y-%m-%dT%H:%M:%S.%fZ'),
             'timestamp': arrow.utcnow().int_timestamp * 1000,
-            'status': "closed" if ordertype == "market" else "open",
+            'status': "closed" if ordertype == "market" and not stop_loss else "open",
             'fee': None,
             'info': {}
         }
-        if dry_order["type"] in ["stop_loss_limit", "stop-loss-limit"]:
+        if stop_loss:
             dry_order["info"] = {"stopPrice": dry_order["price"]}
+            dry_order["stopPrice"] = dry_order["price"]
+            # Workaround to avoid filling stoploss orders immediately
+            dry_order["ft_order_type"] = "stoploss"
 
-        if dry_order["type"] == "market":
+        if dry_order["type"] == "market" and not dry_order.get("ft_order_type"):
             # Update market order pricing
             average = self.get_dry_market_fill_price(pair, side, amount, rate)
             dry_order.update({
@@ -714,7 +718,9 @@ class Exchange:
         """
         Check dry-run limit order fill and update fee (if it filled).
         """
-        if order['status'] != "closed" and order['type'] in ["limit"]:
+        if (order['status'] != "closed"
+                and order['type'] in ["limit"]
+                and not order.get('ft_order_type')):
             pair = order['symbol']
             if self._is_dry_limit_order_filled(pair, order['side'], order['price']):
                 order.update({
@@ -791,25 +797,96 @@ class Exchange:
         """
         raise OperationalException(f"stoploss is not implemented for {self.name}.")
 
+    def _get_stop_params(self, ordertype: str, stop_price: float) -> Dict:
+        params = self._params.copy()
+        # Verify if stopPrice works for your exchange!
+        params.update({'stopPrice': stop_price})
+        return params
+
+    @retrier(retries=0)
     def stoploss(self, pair: str, amount: float, stop_price: float, order_types: Dict) -> Dict:
         """
         creates a stoploss order.
+        requires `_ft_has['stoploss_order_types']` to be set as a dict mapping limit and market
+            to the corresponding exchange type.
+
         The precise ordertype is determined by the order_types dict or exchange default.
-        Since ccxt does not unify stoploss-limit orders yet, this needs to be implemented in each
-        exchange's subclass.
+
         The exception below should never raise, since we disallow
         starting the bot in validate_ordertypes()
-        Note: Changes to this interface need to be applied to all sub-classes too.
-        """
 
+        This may work with a limited number of other exchanges, but correct working
+            needs to be tested individually.
+        WARNING: setting `stoploss_on_exchange` to True will NOT auto-enable stoploss on exchange.
+            `stoploss_adjust` must still be implemented for this to work.
+        """
+        if not self._ft_has['stoploss_on_exchange']:
             raise OperationalException(f"stoploss is not implemented for {self.name}.")
 
+        user_order_type = order_types.get('stoploss', 'market')
+        if user_order_type in self._ft_has["stoploss_order_types"].keys():
+            ordertype = self._ft_has["stoploss_order_types"][user_order_type]
+        else:
+            # Otherwise pick only one available
+            ordertype = list(self._ft_has["stoploss_order_types"].values())[0]
+            user_order_type = list(self._ft_has["stoploss_order_types"].keys())[0]
+
+        stop_price_norm = self.price_to_precision(pair, stop_price)
+        rate = None
+        if user_order_type == 'limit':
+            # Limit price threshold: As limit price should always be below stop-price
+            limit_price_pct = order_types.get('stoploss_on_exchange_limit_ratio', 0.99)
+            rate = stop_price * limit_price_pct
+
+            # Ensure rate is less than stop price
+            if stop_price_norm <= rate:
+                raise OperationalException(
+                    'In stoploss limit order, stop price should be more than limit price')
+            rate = self.price_to_precision(pair, rate)
+
+        if self._config['dry_run']:
+            dry_order = self.create_dry_run_order(
+                pair, ordertype, "sell", amount, stop_price_norm, stop_loss=True)
+            return dry_order
+
+        try:
+            params = self._get_stop_params(ordertype=ordertype, stop_price=stop_price_norm)
+
+            amount = self.amount_to_precision(pair, amount)
+
+            order = self._api.create_order(symbol=pair, type=ordertype, side='sell',
+                                           amount=amount, price=rate, params=params)
+            logger.info(f"stoploss {user_order_type} order added for {pair}. "
+                        f"stop price: {stop_price}. limit: {rate}")
+            self._log_exchange_response('create_stoploss_order', order)
+            return order
+        except ccxt.InsufficientFunds as e:
+            raise InsufficientFundsError(
+                f'Insufficient funds to create {ordertype} sell order on market {pair}. '
+                f'Tried to sell amount {amount} at rate {rate}. '
+                f'Message: {e}') from e
+        except ccxt.InvalidOrder as e:
+            # Errors:
+            # `Order would trigger immediately.`
+            raise InvalidOrderException(
+                f'Could not create {ordertype} sell order on market {pair}. '
+                f'Tried to sell amount {amount} at rate {rate}. '
+                f'Message: {e}') from e
+        except ccxt.DDoSProtection as e:
+            raise DDosProtection(e) from e
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f"Could not place stoploss order due to {e.__class__.__name__}. "
+                f"Message: {e}") from e
+        except ccxt.BaseError as e:
+            raise OperationalException(e) from e
+
     @retrier(retries=API_FETCH_ORDER_RETRY_COUNT)
-    def fetch_order(self, order_id: str, pair: str) -> Dict:
+    def fetch_order(self, order_id: str, pair: str, params={}) -> Dict:
         if self._config['dry_run']:
             return self.fetch_dry_run_order(order_id)
         try:
-            order = self._api.fetch_order(order_id, pair)
+            order = self._api.fetch_order(order_id, pair, params=params)
             self._log_exchange_response('fetch_order', order)
             return order
         except ccxt.OrderNotFound as e:
@@ -852,7 +929,7 @@ class Exchange:
                 and order.get('filled') == 0.0)
 
     @retrier
-    def cancel_order(self, order_id: str, pair: str) -> Dict:
+    def cancel_order(self, order_id: str, pair: str, params={}) -> Dict:
         if self._config['dry_run']:
             try:
                 order = self.fetch_dry_run_order(order_id)
@@ -863,7 +940,7 @@ class Exchange:
                 return {}
 
         try:
-            order = self._api.cancel_order(order_id, pair)
+            order = self._api.cancel_order(order_id, pair, params=params)
             self._log_exchange_response('cancel_order', order)
             return order
         except ccxt.InvalidOrder as e:
@@ -1294,6 +1371,22 @@ class Exchange:
         data = sorted(data, key=lambda x: x[0])
         return pair, timeframe, data
 
+    def _build_coroutine(self, pair: str, timeframe: str, since_ms: Optional[int]) -> Coroutine:
+        if not since_ms and self.required_candle_call_count > 1:
+            # Multiple calls for one pair - to get more history
+            one_call = timeframe_to_msecs(timeframe) * self.ohlcv_candle_limit(timeframe)
+            move_to = one_call * self.required_candle_call_count
+            now = timeframe_to_next_date(timeframe)
+            since_ms = int((now - timedelta(seconds=move_to // 1000)).timestamp() * 1000)
+
+        if since_ms:
+            return self._async_get_historic_ohlcv(
+                pair, timeframe, since_ms=since_ms, raise_=True)
+        else:
+            # One call ... "regular" refresh
+            return self._async_get_candle_history(
+                pair, timeframe, since_ms=since_ms)
+
     def refresh_latest_ohlcv(self, pair_list: ListPairsWithTimeframes, *,
                              since_ms: Optional[int] = None, cache: bool = True
                              ) -> Dict[Tuple[str, str], DataFrame]:
@@ -1312,22 +1405,15 @@ class Exchange:
         cached_pairs = []
         # Gather coroutines to run
         for pair, timeframe in set(pair_list):
+            if timeframe not in self.timeframes:
+                logger.warning(
+                    f"Cannot download ({pair}, {timeframe}) combination as this timeframe is "
+                    f"not available on {self.name}. Available timeframes are "
+                    f"{', '.join(self.timeframes)}.")
+                continue
             if ((pair, timeframe) not in self._klines or not cache
                     or self._now_is_time_to_refresh(pair, timeframe)):
-                if not since_ms and self.required_candle_call_count > 1:
-                    # Multiple calls for one pair - to get more history
-                    one_call = timeframe_to_msecs(timeframe) * self.ohlcv_candle_limit(timeframe)
-                    move_to = one_call * self.required_candle_call_count
-                    now = timeframe_to_next_date(timeframe)
-                    since_ms = int((now - timedelta(seconds=move_to // 1000)).timestamp() * 1000)
-
-                if since_ms:
-                    input_coroutines.append(self._async_get_historic_ohlcv(
-                        pair, timeframe, since_ms=since_ms, raise_=True))
-                else:
-                    # One call ... "regular" refresh
-                    input_coroutines.append(self._async_get_candle_history(
-                        pair, timeframe, since_ms=since_ms))
+                input_coroutines.append(self._build_coroutine(pair, timeframe, since_ms))
             else:
                 logger.debug(
                     "Using cached candle (OHLCV) data for pair %s, timeframe %s ...",
@@ -1587,7 +1673,7 @@ def is_exchange_known_ccxt(exchange_name: str, ccxt_module: CcxtModuleType = Non
 
 
 def is_exchange_officially_supported(exchange_name: str) -> bool:
-    return exchange_name in ['bittrex', 'binance', 'kraken', 'ftx', 'gateio', 'okex']
+    return exchange_name in ['binance', 'bittrex', 'ftx', 'gateio', 'huobi', 'kraken', 'okx']
 
 
 def ccxt_exchanges(ccxt_module: CcxtModuleType = None) -> List[str]:

freqtrade/exchange/ftx.py

@@ -56,7 +56,7 @@ class Ftx(Exchange):
 
         if self._config['dry_run']:
             dry_order = self.create_dry_run_order(
-                pair, ordertype, "sell", amount, stop_price)
+                pair, ordertype, "sell", amount, stop_price, stop_loss=True)
             return dry_order
 
         try:
@@ -106,7 +106,9 @@ class Ftx(Exchange):
                 if order[0].get('status') == 'closed':
                     # Trigger order was triggered ...
                     real_order_id = order[0].get('info', {}).get('orderId')
-
+                    # OrderId may be None for stoploss-market orders
+                    # But contains "average" in these cases.
+                    if real_order_id:
                         order1 = self._api.fetch_order(real_order_id, pair)
                         self._log_exchange_response('fetch_stoploss_order1', order1)
                         # Fake type to stop - as this was really a stop order.
@@ -115,6 +117,7 @@ class Ftx(Exchange):
                         order1['type'] = 'stop'
                         order1['status_stop'] = 'triggered'
                         return order1
+
                 return order[0]
             else:
                 raise InvalidOrderException(f"Could not get stoploss order for id {order_id}")

freqtrade/exchange/gateio.py

@@ -22,13 +22,34 @@ class Gateio(Exchange):
     _ft_has: Dict = {
         "ohlcv_candle_limit": 1000,
         "ohlcv_volume_currency": "quote",
+        "stoploss_order_types": {"limit": "limit"},
+        "stoploss_on_exchange": True,
     }
 
-    _headers = {'X-Gate-Channel-Id': 'freqtrade'}
-
     def validate_ordertypes(self, order_types: Dict) -> None:
         super().validate_ordertypes(order_types)
 
         if any(v == 'market' for k, v in order_types.items()):
             raise OperationalException(
                 f'Exchange {self.name} does not support market orders.')
+
+    def fetch_stoploss_order(self, order_id: str, pair: str, params={}) -> Dict:
+        return self.fetch_order(
+            order_id=order_id,
+            pair=pair,
+            params={'stop': True}
+        )
+
+    def cancel_stoploss_order(self, order_id: str, pair: str, params={}) -> Dict:
+        return self.cancel_order(
+            order_id=order_id,
+            pair=pair,
+            params={'stop': True}
+        )
+
+    def stoploss_adjust(self, stop_loss: float, order: Dict) -> bool:
+        """
+        Verify stop_loss against stoploss-order value (limit or price)
+        Returns True if adjustment is necessary.
+        """
+        return stop_loss > float(order['stopPrice'])

freqtrade/exchange/huobi.py

@@ -0,0 +1,39 @@
+""" Huobi exchange subclass """
+import logging
+from typing import Dict
+
+from freqtrade.exchange import Exchange
+
+
+logger = logging.getLogger(__name__)
+
+
+class Huobi(Exchange):
+    """
+    Huobi exchange class. Contains adjustments needed for Freqtrade to work
+    with this exchange.
+    """
+
+    _ft_has: Dict = {
+        "stoploss_on_exchange": True,
+        "stoploss_order_types": {"limit": "stop-limit"},
+        "ohlcv_candle_limit": 1000,
+        "l2_limit_range": [5, 10, 20],
+        "l2_limit_range_required": False,
+    }
+
+    def stoploss_adjust(self, stop_loss: float, order: Dict) -> bool:
+        """
+        Verify stop_loss against stoploss-order value (limit or price)
+        Returns True if adjustment is necessary.
+        """
+        return order['type'] == 'stop' and stop_loss > float(order['stopPrice'])
+
+    def _get_stop_params(self, ordertype: str, stop_price: float) -> Dict:
+
+        params = self._params.copy()
+        params.update({
+            "stopPrice": stop_price,
+            "operator": "lte",
+        })
+        return params

freqtrade/exchange/kraken.py

@@ -86,6 +86,8 @@ class Kraken(Exchange):
         """
         Creates a stoploss market order.
         Stoploss market orders is the only stoploss type supported by kraken.
+        TODO: investigate if this can be combined with generic implementation
+              (careful, prices are reversed)
         """
         params = self._params.copy()
 
@@ -101,7 +103,7 @@ class Kraken(Exchange):
 
         if self._config['dry_run']:
             dry_order = self.create_dry_run_order(
-                pair, ordertype, "sell", amount, stop_price)
+                pair, ordertype, "sell", amount, stop_price, stop_loss=True)
             return dry_order
 
         try:

freqtrade/exchange/kucoin.py

@@ -19,8 +19,26 @@ class Kucoin(Exchange):
     """
 
     _ft_has: Dict = {
+        "stoploss_on_exchange": True,
+        "stoploss_order_types": {"limit": "limit", "market": "market"},
         "l2_limit_range": [20, 100],
         "l2_limit_range_required": False,
         "order_time_in_force": ['gtc', 'fok', 'ioc'],
         "time_in_force_parameter": "timeInForce",
     }
+
+    def stoploss_adjust(self, stop_loss: float, order: Dict) -> bool:
+        """
+        Verify stop_loss against stoploss-order value (limit or price)
+        Returns True if adjustment is necessary.
+        """
+        return order['info'].get('stop') is not None and stop_loss > float(order['stopPrice'])
+
+    def _get_stop_params(self, ordertype: str, stop_price: float) -> Dict:
+
+        params = self._params.copy()
+        params.update({
+            'stopPrice': stop_price,
+            'stop': 'loss'
+            })
+        return params

freqtrade/exchange/okx.py

@@ -7,8 +7,8 @@ from freqtrade.exchange import Exchange
 logger = logging.getLogger(__name__)
 
 
-class Okex(Exchange):
-    """Okex exchange class.
+class Okx(Exchange):
+    """Okx exchange class.
 
     Contains adjustments needed for Freqtrade to work with this exchange.
     """

freqtrade/freqtradebot.py

@@ -100,6 +100,8 @@ class FreqtradeBot(LoggingMixin):
         self._exit_lock = Lock()
         LoggingMixin.__init__(self, logger, timeframe_to_seconds(self.strategy.timeframe))
 
+        self.last_process = datetime(1970, 1, 1, tzinfo=timezone.utc)
+
     def notify_status(self, msg: str) -> None:
         """
         Public method for users of this class (worker, etc.) to send notifications
@@ -187,6 +189,7 @@ class FreqtradeBot(LoggingMixin):
             self.enter_positions()
 
         Trade.commit()
+        self.last_process = datetime.now(timezone.utc)
 
     def process_stopped(self) -> None:
         """
@@ -295,28 +298,6 @@ class FreqtradeBot(LoggingMixin):
                     self.update_trade_state(trade, order.order_id, send_msg=False)
 
     def handle_insufficient_funds(self, trade: Trade):
-        """
-        Determine if we ever opened a sell order for this trade.
-        If not, try update buy fees - otherwise "refind" the open order we obviously lost.
-        """
-        sell_order = trade.select_order('sell', None)
-        if sell_order:
-            self.refind_lost_order(trade)
-        else:
-            self.reupdate_enter_order_fees(trade)
-
-    def reupdate_enter_order_fees(self, trade: Trade):
-        """
-        Get buy order from database, and try to reupdate.
-        Handles trades where the initial fee-update did not work.
-        """
-        logger.info(f"Trying to reupdate buy fees for {trade}")
-        order = trade.select_order('buy', False)
-        if order:
-            logger.info(f"Updating buy-fee on trade {trade} for order {order.order_id}.")
-            self.update_trade_state(trade, order.order_id, send_msg=False)
-
-    def refind_lost_order(self, trade):
         """
         Try refinding a lost trade.
         Only used when InsufficientFunds appears on sell orders (stoploss or sell).
@@ -329,9 +310,6 @@ class FreqtradeBot(LoggingMixin):
             if not order.ft_is_open:
                 logger.debug(f"Order {order} is no longer open.")
                 continue
-            if order.ft_order_side == 'buy':
-                # Skip buy side - this is handled by reupdate_buy_order_fees
-                continue
             try:
                 fo = self.exchange.fetch_order_or_stoploss_order(order.order_id, order.ft_pair,
                                                                  order.ft_order_side == 'stoploss')
@@ -343,6 +321,9 @@ class FreqtradeBot(LoggingMixin):
                     if fo and fo['status'] == 'open':
                         # Assume this as the open order
                         trade.open_order_id = order.order_id
+                elif order.ft_order_side == 'buy':
+                    if fo and fo['status'] == 'open':
+                        trade.open_order_id = order.order_id
                 if fo:
                     logger.info(f"Found {order} for trade {trade}.")
                     self.update_trade_state(trade, order.order_id, fo,
@@ -561,7 +542,6 @@ class FreqtradeBot(LoggingMixin):
                 entry_tag=buy_tag):
             logger.info(f"User requested abortion of buying {pair}")
             return False
-        amount = self.exchange.amount_to_precision(pair, amount)
         order = self.exchange.create_order(pair=pair, ordertype=order_type, side="buy",
                                            amount=amount, rate=enter_limit_requested,
                                            time_in_force=time_in_force)
@@ -893,11 +873,15 @@ class FreqtradeBot(LoggingMixin):
             stop_price = trade.open_rate * (1 + stoploss)
 
             if self.create_stoploss_order(trade=trade, stop_price=stop_price):
+                # The above will return False if the placement failed and the trade was force-sold.
+                # in which case the trade will be closed - which we must check below.
                 trade.stoploss_last_update = datetime.utcnow()
                 return False
 
         # If stoploss order is canceled for some reason we add it
-        if stoploss_order and stoploss_order['status'] in ('canceled', 'cancelled'):
+        if (trade.is_open
+                and stoploss_order
+                and stoploss_order['status'] in ('canceled', 'cancelled')):
             if self.create_stoploss_order(trade=trade, stop_price=trade.stop_loss):
                 return False
             else:
@@ -907,7 +891,7 @@ class FreqtradeBot(LoggingMixin):
         # Finally we check if stoploss on exchange should be moved up because of trailing.
         # Triggered Orders are now real orders - so don't replace stoploss anymore
         if (
-            stoploss_order
+            trade.is_open and stoploss_order
             and stoploss_order.get('status_stop') != 'triggered'
             and (self.config.get('trailing_stop', False)
                  or self.config.get('use_custom_stoploss', False))
@@ -919,7 +903,7 @@ class FreqtradeBot(LoggingMixin):
 
         return False
 
-    def handle_trailing_stoploss_on_exchange(self, trade: Trade, order: dict) -> None:
+    def handle_trailing_stoploss_on_exchange(self, trade: Trade, order: Dict) -> None:
         """
         Check to see if stoploss on exchange should be updated
         in case of trailing stoploss on exchange
@@ -927,7 +911,9 @@ class FreqtradeBot(LoggingMixin):
         :param order: Current on exchange stoploss order
         :return: None
         """
-        if self.exchange.stoploss_adjust(trade.stop_loss, order):
+        stoploss_norm = self.exchange.price_to_precision(trade.pair, trade.stop_loss)
+
+        if self.exchange.stoploss_adjust(stoploss_norm, order):
             # we check if the update is necessary
             update_beat = self.strategy.order_types.get('stoploss_on_exchange_interval', 60)
             if (datetime.utcnow() - trade.stoploss_last_update).total_seconds() >= update_beat:
@@ -984,22 +970,24 @@ class FreqtradeBot(LoggingMixin):
 
             fully_cancelled = self.update_trade_state(trade, trade.open_order_id, order)
 
+            order_obj = trade.select_order_by_order_id(trade.open_order_id)
+
             if (order['side'] == 'buy' and (order['status'] == 'open' or fully_cancelled) and (
                     fully_cancelled
-                    or self.strategy.ft_check_timed_out(
-                        'buy', trade, order, datetime.now(timezone.utc))
-                        )):
+                    or (order_obj and self.strategy.ft_check_timed_out(
+                        'buy', trade, order_obj, datetime.now(timezone.utc))
+                        ))):
                 self.handle_cancel_enter(trade, order, constants.CANCEL_REASON['TIMEOUT'])
 
             elif (order['side'] == 'sell' and (order['status'] == 'open' or fully_cancelled) and (
                   fully_cancelled
-                  or self.strategy.ft_check_timed_out(
-                      'sell', trade, order, datetime.now(timezone.utc)))
-                  ):
-                self.handle_cancel_exit(trade, order, constants.CANCEL_REASON['TIMEOUT'])
+                  or (order_obj and self.strategy.ft_check_timed_out(
+                      'sell', trade, order_obj, datetime.now(timezone.utc))
+                      ))):
+                canceled = self.handle_cancel_exit(trade, order, constants.CANCEL_REASON['TIMEOUT'])
                 canceled_count = trade.get_exit_order_count()
                 max_timeouts = self.config.get('unfilledtimeout', {}).get('exit_timeout_count', 0)
-                if max_timeouts > 0 and canceled_count >= max_timeouts:
+                if canceled and max_timeouts > 0 and canceled_count >= max_timeouts:
                     logger.warning(f'Emergencyselling trade {trade}, as the sell order '
                                    f'timed out {max_timeouts} times.')
                     try:
@@ -1038,12 +1026,12 @@ class FreqtradeBot(LoggingMixin):
 
         # Cancelled orders may have the status of 'canceled' or 'closed'
         if order['status'] not in constants.NON_OPEN_EXCHANGE_STATES:
-            filled_val = order.get('filled', 0.0) or 0.0
+            filled_val: float = order.get('filled', 0.0) or 0.0
             filled_stake = filled_val * trade.open_rate
             minstake = self.exchange.get_min_pair_stake_amount(
                 trade.pair, trade.open_rate, self.strategy.stoploss)
 
-            if filled_val > 0 and filled_stake < minstake:
+            if filled_val > 0 and minstake and filled_stake < minstake:
                 logger.warning(
                     f"Order {trade.open_order_id} for {trade.pair} not cancelled, "
                     f"as the filled amount of {filled_val} would result in an unsellable trade.")
@@ -1096,11 +1084,12 @@ class FreqtradeBot(LoggingMixin):
                                   reason=reason)
         return was_trade_fully_canceled
 
-    def handle_cancel_exit(self, trade: Trade, order: Dict, reason: str) -> str:
+    def handle_cancel_exit(self, trade: Trade, order: Dict, reason: str) -> bool:
         """
         Sell cancel - cancel order and update trade
-        :return: Reason for cancel
+        :return: True if exit order was cancelled, false otherwise
         """
+        cancelled = False
         # if trade is not partially completed, just cancel the order
         if order['remaining'] == order['amount'] or order.get('filled') == 0.0:
             if not self.exchange.check_order_canceled_empty(order):
@@ -1111,7 +1100,7 @@ class FreqtradeBot(LoggingMixin):
                     trade.update_order(co)
                 except InvalidOrderException:
                     logger.exception(f"Could not cancel sell order {trade.open_order_id}")
-                    return 'error cancelling order'
+                    return False
                 logger.info('Sell order %s for %s.', reason, trade)
             else:
                 reason = constants.CANCEL_REASON['CANCELLED_ON_EXCHANGE']
@@ -1125,9 +1114,12 @@ class FreqtradeBot(LoggingMixin):
             trade.close_date = None
             trade.is_open = True
             trade.open_order_id = None
+            trade.sell_reason = None
+            cancelled = True
         else:
             # TODO: figure out how to handle partially complete sell orders
             reason = constants.CANCEL_REASON['PARTIALLY_FILLED_KEEP_OPEN']
+            cancelled = False
 
         self.wallets.update()
         self._notify_exit_cancel(
@@ -1135,7 +1127,7 @@ class FreqtradeBot(LoggingMixin):
             order_type=self.strategy.order_types['sell'],
             reason=reason
         )
-        return reason
+        return cancelled
 
     def _safe_exit_amount(self, pair: str, amount: float) -> float:
         """
@@ -1184,8 +1176,8 @@ class FreqtradeBot(LoggingMixin):
 
         # if stoploss is on exchange and we are on dry_run mode,
         # we consider the sell price stop price
-        if self.config['dry_run'] and sell_type == 'stoploss' \
-           and self.strategy.order_types['stoploss_on_exchange']:
+        if (self.config['dry_run'] and sell_type == 'stoploss'
+                and self.strategy.order_types['stoploss_on_exchange']):
             limit = trade.stop_loss
 
         # set custom_exit_price if available
@@ -1374,9 +1366,14 @@ class FreqtradeBot(LoggingMixin):
             # Handling of this will happen in check_handle_timedout.
             return True
 
-        order = self.handle_order_fee(trade, order)
+        order_obj = trade.select_order_by_order_id(order_id)
+        if not order_obj:
+            raise DependencyException(
+                f"Order_obj not found for {order_id}. This should not have happened.")
+        self.handle_order_fee(trade, order_obj, order)
 
-        trade.update(order)
+        trade.update_trade(order_obj)
+        # TODO: is the below necessary? it's already done in update_trade for filled buys
         trade.recalc_trade_from_orders()
         Trade.commit()
 
@@ -1428,19 +1425,17 @@ class FreqtradeBot(LoggingMixin):
             return real_amount
         return amount
 
-    def handle_order_fee(self, trade: Trade, order: Dict[str, Any]) -> Dict[str, Any]:
+    def handle_order_fee(self, trade: Trade, order_obj: Order, order: Dict[str, Any]) -> None:
         # Try update amount (binance-fix)
         try:
-            new_amount = self.get_real_amount(trade, order)
+            new_amount = self.get_real_amount(trade, order, order_obj)
             if not isclose(safe_value_fallback(order, 'filled', 'amount'), new_amount,
                            abs_tol=constants.MATH_CLOSE_PREC):
-                order['amount'] = new_amount
-                order.pop('filled', None)
+                order_obj.ft_fee_base = trade.amount - new_amount
         except DependencyException as exception:
             logger.warning("Could not update trade amount: %s", exception)
-        return order
 
-    def get_real_amount(self, trade: Trade, order: Dict) -> float:
+    def get_real_amount(self, trade: Trade, order: Dict, order_obj: Order) -> float:
         """
         Detect and update trade fee.
         Calls trade.update_fee() upon correct detection.
@@ -1458,7 +1453,7 @@ class FreqtradeBot(LoggingMixin):
         # use fee from order-dict if possible
         if self.exchange.order_has_fee(order):
             fee_cost, fee_currency, fee_rate = self.exchange.extract_cost_curr_rate(order)
-            logger.info(f"Fee for Trade {trade} [{order.get('side')}]: "
+            logger.info(f"Fee for Trade {trade} [{order_obj.ft_order_side}]: "
                         f"{fee_cost:.8g} {fee_currency} - rate: {fee_rate}")
             if fee_rate is None or fee_rate < 0.02:
                 # Reject all fees that report as > 2%.
@@ -1470,17 +1465,18 @@ class FreqtradeBot(LoggingMixin):
                     return self.apply_fee_conditional(trade, trade_base_currency,
                                                       amount=order_amount, fee_abs=fee_cost)
                 return order_amount
-        return self.fee_detection_from_trades(trade, order, order_amount, order.get('trades', []))
+        return self.fee_detection_from_trades(
+            trade, order, order_obj, order_amount, order.get('trades', []))
 
-    def fee_detection_from_trades(self, trade: Trade, order: Dict, order_amount: float,
-                                  trades: List) -> float:
+    def fee_detection_from_trades(self, trade: Trade, order: Dict, order_obj: Order,
+                                  order_amount: float, trades: List) -> float:
         """
         fee-detection fallback to Trades.
         Either uses provided trades list or the result of fetch_my_trades to get correct fee.
         """
         if not trades:
             trades = self.exchange.get_trades_for_order(
-                self.exchange.get_order_id_conditional(order), trade.pair, trade.open_date)
+                self.exchange.get_order_id_conditional(order), trade.pair, order_obj.order_date)
 
         if len(trades) == 0:
             logger.info("Applying fee on amount for %s failed: myTrade-Dict empty found", trade)

freqtrade/misc.py

@@ -29,18 +29,23 @@ def decimals_per_coin(coin: str):
     return DECIMALS_PER_COIN.get(coin, DECIMAL_PER_COIN_FALLBACK)
 
 
-def round_coin_value(value: float, coin: str, show_coin_name=True) -> str:
+def round_coin_value(
+        value: float, coin: str, show_coin_name=True, keep_trailing_zeros=False) -> str:
     """
     Get price value for this coin
     :param value: Value to be printed
     :param coin: Which coin are we printing the price / value for
     :param show_coin_name: Return string in format: "222.22 USDT" or "222.22"
+    :param keep_trailing_zeros: Keep trailing zeros "222.200" vs. "222.2"
     :return: Formatted / rounded value (with or without coin name)
     """
+    val = f"{value:.{decimals_per_coin(coin)}f}"
+    if not keep_trailing_zeros:
+        val = val.rstrip('0').rstrip('.')
     if show_coin_name:
-        return f"{value:.{decimals_per_coin(coin)}f} {coin}"
-    else:
-        return f"{value:.{decimals_per_coin(coin)}f}"
+        val = f"{val} {coin}"
+
+    return val
 
 
 def shorten_date(_date: str) -> str:

freqtrade/optimize/backtesting.py

@@ -63,6 +63,8 @@ class Backtesting:
         LoggingMixin.show_output = False
         self.config = config
         self.results: Dict[str, Any] = {}
+        self.trade_id_counter: int = 0
+        self.order_id_counter: int = 0
 
         config['dry_run'] = True
         self.run_ids: Dict[str, str] = {}
@@ -85,7 +87,7 @@ class Backtesting:
             validate_config_consistency(self.config)
 
         if "timeframe" not in self.config:
-            raise OperationalException("Timeframe (ticker interval) needs to be set in either "
+            raise OperationalException("Timeframe needs to be set in either "
                                        "configuration or as cli argument `--timeframe 5m`")
         self.timeframe = str(self.config.get('timeframe'))
         self.timeframe_min = timeframe_to_minutes(self.timeframe)
@@ -126,7 +128,8 @@ class Backtesting:
     def __del__(self):
         self.cleanup()
 
-    def cleanup(self):
+    @staticmethod
+    def cleanup():
         LoggingMixin.show_output = True
         PairLocks.use_db = True
         Trade.use_db = True
@@ -231,6 +234,8 @@ class Backtesting:
         PairLocks.reset_locks()
         Trade.reset_trades()
         self.rejected_trades = 0
+        self.timedout_entry_orders = 0
+        self.timedout_exit_orders = 0
         self.dataprovider.clear_cache()
         if enable_protections:
             self._load_protections(self.strategy)
@@ -275,6 +280,13 @@ class Backtesting:
             # Trim startup period from analyzed dataframe
             df_analyzed = processed[pair] = pair_data = trim_dataframe(
                 df_analyzed, self.timerange, startup_candles=self.required_startup)
+            # Update dataprovider cache
+            self.dataprovider._set_cached_df(pair, self.timeframe, df_analyzed)
+
+            # Create a copy of the dataframe before shifting, that way the buy signal/tag
+            # remains on the correct candle for callbacks.
+            df_analyzed = df_analyzed.copy()
+
             # To avoid using data from future, we use buy/sell signals shifted
             # from the previous candle
             df_analyzed.loc[:, 'buy'] = df_analyzed.loc[:, 'buy'].shift(1)
@@ -282,9 +294,6 @@ class Backtesting:
             df_analyzed.loc[:, 'buy_tag'] = df_analyzed.loc[:, 'buy_tag'].shift(1)
             df_analyzed.loc[:, 'exit_tag'] = df_analyzed.loc[:, 'exit_tag'].shift(1)
 
-            # Update dataprovider cache
-            self.dataprovider._set_cached_df(pair, self.timeframe, df_analyzed)
-
             df_analyzed = df_analyzed.drop(df_analyzed.head(1).index)
 
             # Convert from Pandas to list for performance reasons
@@ -349,7 +358,22 @@ class Backtesting:
                     # use Open rate if open_rate > calculated sell rate
                     return sell_row[OPEN_IDX]
 
-                return close_rate
+                if (
+                    trade_dur == 0
+                    # Red candle (for longs), TODO: green candle (for shorts)
+                    and sell_row[OPEN_IDX] > sell_row[CLOSE_IDX]  # Red candle
+                    and trade.open_rate < sell_row[OPEN_IDX]  # trade-open below open_rate
+                    and close_rate > sell_row[CLOSE_IDX]
+                ):
+                    # ROI on opening candles with custom pricing can only
+                    # trigger if the entry was at Open or lower.
+                    # details: https: // github.com/freqtrade/freqtrade/issues/6261
+                    # If open_rate is < open, only allow sells below the close on red candles.
+                    raise ValueError("Opening candle ROI on red candles.")
+                # Use the maximum between close_rate and low as we
+                # cannot sell outside of a candle.
+                # Applies when a new ROI setting comes in place and the whole candle is above that.
+                return min(max(close_rate, sell_row[LOW_IDX]), sell_row[HIGH_IDX])
 
             else:
                 # This should not be reached...
@@ -372,10 +396,15 @@ class Backtesting:
         if stake_amount is not None and stake_amount > 0.0:
             pos_trade = self._enter_trade(trade.pair, row, stake_amount, trade)
             if pos_trade is not None:
+                self.wallets.update()
                 return pos_trade
 
         return trade
 
+    def _get_order_filled(self, rate: float, row: Tuple) -> bool:
+        """ Rate is within candle, therefore filled"""
+        return row[LOW_IDX] <= rate <= row[HIGH_IDX]
+
     def _get_sell_trade_entry_for_candle(self, trade: LocalTrade,
                                          sell_row: Tuple) -> Optional[LocalTrade]:
 
@@ -398,21 +427,27 @@ class Backtesting:
             trade.close_date = sell_candle_time
 
             trade_dur = int((trade.close_date_utc - trade.open_date_utc).total_seconds() // 60)
+            try:
                 closerate = self._get_close_rate(sell_row, trade, sell, trade_dur)
+            except ValueError:
+                return None
             # call the custom exit price,with default value as previous closerate
             current_profit = trade.calc_profit_ratio(closerate)
+            order_type = self.strategy.order_types['sell']
             if sell.sell_type in (SellType.SELL_SIGNAL, SellType.CUSTOM_SELL):
                 # Custom exit pricing only for sell-signals
+                if order_type == 'limit':
                     closerate = strategy_safe_wrapper(self.strategy.custom_exit_price,
                                                       default_retval=closerate)(
                         pair=trade.pair, trade=trade,
-                    current_time=sell_row[DATE_IDX],
+                        current_time=sell_candle_time,
                         proposed_rate=closerate, current_profit=current_profit)
-            # Use the maximum between close_rate and low as we cannot sell outside of a candle.
-            closerate = min(max(closerate, sell_row[LOW_IDX]), sell_row[HIGH_IDX])
-
+                    # We can't place orders lower than current low.
+                    # freqtrade does not support this in live, and the order would fill immediately
+                    closerate = max(closerate, sell_row[LOW_IDX])
             # Confirm trade exit:
             time_in_force = self.strategy.order_time_in_force['sell']
+
             if not strategy_safe_wrapper(self.strategy.confirm_trade_exit, default_retval=True)(
                     pair=trade.pair, trade=trade, order_type='limit', amount=trade.amount,
                     rate=closerate,
@@ -432,7 +467,28 @@ class Backtesting:
             ):
                 trade.sell_reason = sell_row[EXIT_TAG_IDX]
 
-            trade.close(closerate, show_msg=False)
+            self.order_id_counter += 1
+            order = Order(
+                id=self.order_id_counter,
+                ft_trade_id=trade.id,
+                order_date=sell_candle_time,
+                order_update_date=sell_candle_time,
+                ft_is_open=True,
+                ft_pair=trade.pair,
+                order_id=str(self.order_id_counter),
+                symbol=trade.pair,
+                ft_order_side="sell",
+                side="sell",
+                order_type=order_type,
+                status="open",
+                price=closerate,
+                average=closerate,
+                amount=trade.amount,
+                filled=0,
+                remaining=trade.amount,
+                cost=trade.amount * closerate,
+            )
+            trade.orders.append(order)
             return trade
 
         return None
@@ -471,13 +527,16 @@ class Backtesting:
         current_time = row[DATE_IDX].to_pydatetime()
         entry_tag = row[BUY_TAG_IDX] if len(row) >= BUY_TAG_IDX + 1 else None
         # let's call the custom entry price, using the open price as default price
+        order_type = self.strategy.order_types['buy']
+        propose_rate = row[OPEN_IDX]
+        if order_type == 'limit':
             propose_rate = strategy_safe_wrapper(self.strategy.custom_entry_price,
                                                  default_retval=row[OPEN_IDX])(
                 pair=pair, current_time=current_time,
-            proposed_rate=row[OPEN_IDX], entry_tag=entry_tag)  # default value is the open rate
-
-        # Move rate to within the candle's low/high rate
-        propose_rate = min(max(propose_rate, row[LOW_IDX]), row[HIGH_IDX])
+                proposed_rate=propose_rate, entry_tag=entry_tag)  # default value is the open rate
+            # We can't place orders higher than current high (otherwise it'd be a stop limit buy)
+            # which freqtrade does not support in live.
+            propose_rate = min(propose_rate, row[HIGH_IDX])
 
         min_stake_amount = self.exchange.get_min_pair_stake_amount(pair, propose_rate, -0.05) or 0
         max_stake_amount = self.wallets.get_available_stake_amount()
@@ -485,9 +544,9 @@ class Backtesting:
         pos_adjust = trade is not None
         if not pos_adjust:
             try:
-                stake_amount = self.wallets.get_trade_stake_amount(pair, None)
+                stake_amount = self.wallets.get_trade_stake_amount(pair, None, update=False)
             except DependencyException:
-                return trade
+                return None
 
             stake_amount = strategy_safe_wrapper(self.strategy.custom_stake_amount,
                                                  default_retval=stake_amount)(
@@ -502,8 +561,7 @@ class Backtesting:
             # If not pos adjust, trade is None
             return trade
 
-        order_type = self.strategy.order_types['buy']
-        time_in_force = self.strategy.order_time_in_force['sell']
+        time_in_force = self.strategy.order_time_in_force['buy']
         # Confirm trade entry:
         if not pos_adjust:
             if not strategy_safe_wrapper(self.strategy.confirm_trade_entry, default_retval=True)(
@@ -513,15 +571,21 @@ class Backtesting:
                 return None
 
         if stake_amount and (not min_stake_amount or stake_amount > min_stake_amount):
+            self.order_id_counter += 1
             amount = round(stake_amount / propose_rate, 8)
             if trade is None:
                 # Enter trade
+                self.trade_id_counter += 1
                 trade = LocalTrade(
+                    id=self.trade_id_counter,
+                    open_order_id=self.order_id_counter,
                     pair=pair,
                     open_rate=propose_rate,
+                    open_rate_requested=propose_rate,
                     open_date=current_time,
                     stake_amount=stake_amount,
                     amount=amount,
+                    amount_requested=amount,
                     fee_open=self.fee,
                     fee_close=self.fee,
                     is_open=True,
@@ -529,27 +593,35 @@ class Backtesting:
                     exchange='backtesting',
                     orders=[]
                 )
+
             trade.adjust_stop_loss(trade.open_rate, self.strategy.stoploss, initial=True)
 
             order = Order(
-                ft_is_open=False,
+                id=self.order_id_counter,
+                ft_trade_id=trade.id,
+                ft_is_open=True,
                 ft_pair=trade.pair,
+                order_id=str(self.order_id_counter),
                 symbol=trade.pair,
                 ft_order_side="buy",
                 side="buy",
-                order_type="market",
-                status="closed",
+                order_type=order_type,
+                status="open",
                 order_date=current_time,
                 order_filled_date=current_time,
                 order_update_date=current_time,
                 price=propose_rate,
                 average=propose_rate,
                 amount=amount,
-                filled=amount,
-                cost=stake_amount + trade.fee_open
+                filled=0,
+                remaining=amount,
+                cost=stake_amount + trade.fee_open,
             )
+            if pos_adjust and self._get_order_filled(order.price, row):
+                order.close_bt_order(current_time)
+            else:
+                trade.open_order_id = str(self.order_id_counter)
             trade.orders.append(order)
-            if pos_adjust:
             trade.recalc_trade_from_orders()
 
         return trade
@@ -563,6 +635,9 @@ class Backtesting:
         for pair in open_trades.keys():
             if len(open_trades[pair]) > 0:
                 for trade in open_trades[pair]:
+                    if trade.open_order_id and trade.nr_of_successful_buys == 0:
+                        # Ignore trade if buy-order did not fill yet
+                        continue
                     sell_row = data[pair][-1]
 
                     trade.close_date = sell_row[DATE_IDX].to_pydatetime()
@@ -583,6 +658,51 @@ class Backtesting:
         self.rejected_trades += 1
         return False
 
+    def run_protections(self, enable_protections, pair: str, current_time: datetime):
+        if enable_protections:
+            self.protections.stop_per_pair(pair, current_time)
+            self.protections.global_stop(current_time)
+
+    def check_order_cancel(self, trade: LocalTrade, current_time) -> bool:
+        """
+        Check if an order has been canceled.
+        Returns True if the trade should be Deleted (initial order was canceled).
+        """
+        for order in [o for o in trade.orders if o.ft_is_open]:
+
+            timedout = self.strategy.ft_check_timed_out(order.side, trade, order, current_time)
+            if timedout:
+                if order.side == 'buy':
+                    self.timedout_entry_orders += 1
+                    if trade.nr_of_successful_buys == 0:
+                        # Remove trade due to buy timeout expiration.
+                        return True
+                    else:
+                        # Close additional buy order
+                        del trade.orders[trade.orders.index(order)]
+                if order.side == 'sell':
+                    self.timedout_exit_orders += 1
+                    # Close sell order and retry selling on next signal.
+                    del trade.orders[trade.orders.index(order)]
+
+        return False
+
+    def validate_row(
+            self, data: Dict, pair: str, row_index: int, current_time: datetime) -> Optional[Tuple]:
+        try:
+            # Row is treated as "current incomplete candle".
+            # Buy / sell signals are shifted by 1 to compensate for this.
+            row = data[pair][row_index]
+        except IndexError:
+            # missing Data for one pair at the end.
+            # Warnings for this are shown during data loading
+            return None
+
+        # Waits until the time-counter reaches the start of the data for this pair.
+        if row[DATE_IDX] > current_time:
+            return None
+        return row
+
     def backtest(self, processed: Dict,
                  start_date: datetime, end_date: datetime,
                  max_open_trades: int = 0, position_stacking: bool = False,
@@ -605,14 +725,15 @@ class Backtesting:
         """
         trades: List[LocalTrade] = []
         self.prepare_backtest(enable_protections)
-
+        # Ensure wallets are uptodate (important for --strategy-list)
+        self.wallets.update()
         # Use dict of lists with data for performance
         # (looping lists is a lot faster than pandas DataFrames)
         data: Dict = self._get_ohlcv_as_lists(processed)
 
         # Indexes per pair, so some pairs are allowed to have a missing start.
         indexes: Dict = defaultdict(int)
-        tmp = start_date + timedelta(minutes=self.timeframe_min)
+        current_time = start_date + timedelta(minutes=self.timeframe_min)
 
         open_trades: Dict[str, List[LocalTrade]] = defaultdict(list)
         open_trade_count = 0
@@ -621,35 +742,27 @@ class Backtesting:
             (end_date - start_date) / timedelta(minutes=self.timeframe_min)))
 
         # Loop timerange and get candle for each pair at that point in time
-        while tmp <= end_date:
+        while current_time <= end_date:
             open_trade_count_start = open_trade_count
             self.check_abort()
             for i, pair in enumerate(data):
                 row_index = indexes[pair]
-                try:
-                    # Row is treated as "current incomplete candle".
-                    # Buy / sell signals are shifted by 1 to compensate for this.
-                    row = data[pair][row_index]
-                except IndexError:
-                    # missing Data for one pair at the end.
-                    # Warnings for this are shown during data loading
-                    continue
-
-                # Waits until the time-counter reaches the start of the data for this pair.
-                if row[DATE_IDX] > tmp:
+                row = self.validate_row(data, pair, row_index, current_time)
+                if not row:
                     continue
 
                 row_index += 1
                 indexes[pair] = row_index
                 self.dataprovider._set_dataframe_max_index(row_index)
 
+                # 1. Process buys.
                 # without positionstacking, we can only have one open trade per pair.
                 # max_open_trades must be respected
                 # don't open on the last row
                 if (
                     (position_stacking or len(open_trades[pair]) == 0)
                     and self.trade_slot_available(max_open_trades, open_trade_count_start)
-                    and tmp != end_date
+                    and current_time != end_date
                     and row[BUY_IDX] == 1
                     and row[SELL_IDX] != 1
                     and not PairLocks.is_pair_locked(pair, row[DATE_IDX])
@@ -657,32 +770,51 @@ class Backtesting:
                     trade = self._enter_trade(pair, row)
                     if trade:
                         # TODO: hacky workaround to avoid opening > max_open_trades
-                        # This emulates previous behaviour - not sure if this is correct
+                        # This emulates previous behavior - not sure if this is correct
                         # Prevents buying if the trade-slot was freed in this candle
                         open_trade_count_start += 1
                         open_trade_count += 1
                         # logger.debug(f"{pair} - Emulate creation of new trade: {trade}.")
                         open_trades[pair].append(trade)
-                        LocalTrade.add_bt_trade(trade)
 
                 for trade in list(open_trades[pair]):
-                    # also check the buying candle for sell conditions.
-                    trade_entry = self._get_sell_trade_entry(trade, row)
-                    # Sell occurred
-                    if trade_entry:
+                    # 2. Process buy orders.
+                    order = trade.select_order('buy', is_open=True)
+                    if order and self._get_order_filled(order.price, row):
+                        order.close_bt_order(current_time)
+                        trade.open_order_id = None
+                        LocalTrade.add_bt_trade(trade)
+                        self.wallets.update()
+
+                    # 3. Create sell orders (if any)
+                    if not trade.open_order_id:
+                        self._get_sell_trade_entry(trade, row)  # Place sell order if necessary
+
+                    # 4. Process sell orders.
+                    order = trade.select_order('sell', is_open=True)
+                    if order and self._get_order_filled(order.price, row):
+                        trade.open_order_id = None
+                        trade.close_date = current_time
+                        trade.close(order.price, show_msg=False)
+
                         # logger.debug(f"{pair} - Backtesting sell {trade}")
                         open_trade_count -= 1
                         open_trades[pair].remove(trade)
-
                         LocalTrade.close_bt_trade(trade)
-                        trades.append(trade_entry)
-                        if enable_protections:
-                            self.protections.stop_per_pair(pair, row[DATE_IDX])
-                            self.protections.global_stop(tmp)
+                        trades.append(trade)
+                        self.wallets.update()
+                        self.run_protections(enable_protections, pair, current_time)
+
+                    # 5. Cancel expired buy/sell orders.
+                    if self.check_order_cancel(trade, current_time):
+                        # Close trade due to buy timeout expiration.
+                        open_trade_count -= 1
+                        open_trades[pair].remove(trade)
+                        self.wallets.update()
 
             # Move time one configured time_interval ahead.
             self.progress.increment()
-            tmp += timedelta(minutes=self.timeframe_min)
+            current_time += timedelta(minutes=self.timeframe_min)
 
         trades += self.handle_left_open(open_trades, data=data)
         self.wallets.update()
@@ -693,6 +825,8 @@ class Backtesting:
             'config': self.strategy.config,
             'locks': PairLocks.get_all_locks(),
             'rejected_signals': self.rejected_trades,
+            'timedout_entry_orders': self.timedout_entry_orders,
+            'timedout_exit_orders': self.timedout_exit_orders,
             'final_balance': self.wallets.get_total(self.strategy.config['stake_currency']),
         }
 

freqtrade/optimize/hyperopt_interface.py

@@ -29,15 +29,13 @@ class IHyperOpt(ABC):
     Class attributes you can use:
         timeframe -> int: value of the timeframe to use for the strategy
     """
-    ticker_interval: str  # DEPRECATED
     timeframe: str
     strategy: IStrategy
 
     def __init__(self, config: dict) -> None:
         self.config = config
 
-        # Assign ticker_interval to be used in hyperopt
-        IHyperOpt.ticker_interval = str(config['timeframe'])  # DEPRECATED
+        # Assign timeframe to be used in hyperopt
         IHyperOpt.timeframe = str(config['timeframe'])
 
     def generate_estimator(self, dimensions: List[Dimension], **kwargs) -> EstimatorType:
@@ -192,7 +190,7 @@ class IHyperOpt(ABC):
             Categorical([True, False], name='trailing_only_offset_is_reached'),
         ]
 
-    # This is needed for proper unpickling the class attribute ticker_interval
+    # This is needed for proper unpickling the class attribute timeframe
     # which is set to the actual value by the resolver.
     # Why do I still need such shamanic mantras in modern python?
     def __getstate__(self):
@@ -202,5 +200,4 @@ class IHyperOpt(ABC):
 
     def __setstate__(self, state):
         self.__dict__.update(state)
-        IHyperOpt.ticker_interval = state['timeframe']
         IHyperOpt.timeframe = state['timeframe']

freqtrade/optimize/hyperopt_loss_profit_drawdown.py

@@ -0,0 +1,30 @@
+"""
+ProfitDrawDownHyperOptLoss
+
+This module defines the alternative HyperOptLoss class based on Profit &
+Drawdown objective which can be used for Hyperoptimization.
+
+Possible to change `DRAWDOWN_MULT` to penalize drawdown objective for
+individual needs.
+"""
+from pandas import DataFrame
+
+from freqtrade.data.btanalysis import calculate_max_drawdown
+from freqtrade.optimize.hyperopt import IHyperOptLoss
+
+
+# higher numbers penalize drawdowns more severely
+DRAWDOWN_MULT = 0.075
+
+
+class ProfitDrawDownHyperOptLoss(IHyperOptLoss):
+    @staticmethod
+    def hyperopt_loss_function(results: DataFrame, trade_count: int, *args, **kwargs) -> float:
+        total_profit = results["profit_abs"].sum()
+
+        try:
+            max_drawdown_abs = calculate_max_drawdown(results, value_col="profit_abs")[5]
+        except ValueError:
+            max_drawdown_abs = 0
+
+        return -1 * (total_profit * (1 - max_drawdown_abs * DRAWDOWN_MULT))

freqtrade/optimize/hyperopt_tools.py

@@ -373,7 +373,7 @@ class HyperoptTools():
 
         trials[f"Max Drawdown{' (Acct)' if has_account_drawdown else ''}"] = trials.apply(
             lambda x: "{} {}".format(
-                round_coin_value(x['max_drawdown_abs'], stake_currency),
+                round_coin_value(x['max_drawdown_abs'], stake_currency, keep_trailing_zeros=True),
                 (f"({x['max_drawdown_account']:,.2%})"
                     if has_account_drawdown
                     else f"({x['max_drawdown']:,.2%})"
@@ -388,7 +388,7 @@ class HyperoptTools():
 
         trials['Profit'] = trials.apply(
             lambda x: '{} {}'.format(
-                round_coin_value(x['Total profit'], stake_currency),
+                round_coin_value(x['Total profit'], stake_currency, keep_trailing_zeros=True),
                 f"({x['Profit']:,.2%})".rjust(10, ' ')
             ).rjust(25+len(stake_currency))
             if x['Total profit'] != 0.0 else '--'.rjust(25+len(stake_currency)),

freqtrade/optimize/optimize_reports.py

@@ -436,6 +436,8 @@ def generate_strategy_stats(pairlist: List[str],
         'dry_run_wallet': starting_balance,
         'final_balance': content['final_balance'],
         'rejected_signals': content['rejected_signals'],
+        'timedout_entry_orders': content['timedout_entry_orders'],
+        'timedout_exit_orders': content['timedout_exit_orders'],
         'max_open_trades': max_open_trades,
         'max_open_trades_setting': (config['max_open_trades']
                                     if config['max_open_trades'] != float('inf') else -1),
@@ -726,6 +728,9 @@ def text_table_add_metrics(strat_results: Dict) -> str:
             ('Avg. Duration Winners', f"{strat_results['winner_holding_avg']}"),
             ('Avg. Duration Loser', f"{strat_results['loser_holding_avg']}"),
             ('Rejected Buy signals', strat_results.get('rejected_signals', 'N/A')),
+            ('Entry/Exit Timeouts',
+             f"{strat_results.get('timedout_entry_orders', 'N/A')} / "
+             f"{strat_results.get('timedout_exit_orders', 'N/A')}"),
             ('', ''),  # Empty line to improve readability
 
             ('Min balance', round_coin_value(strat_results['csum_min'],

freqtrade/persistence/migrations.py

@@ -28,7 +28,36 @@ def get_backup_name(tabs, backup_prefix: str):
     return table_back_name
 
 
-def migrate_trades_table(decl_base, inspector, engine, table_back_name: str, cols: List):
+def get_last_sequence_ids(engine, trade_back_name, order_back_name):
+    order_id: int = None
+    trade_id: int = None
+
+    if engine.name == 'postgresql':
+        with engine.begin() as connection:
+            trade_id = connection.execute(text("select nextval('trades_id_seq')")).fetchone()[0]
+            order_id = connection.execute(text("select nextval('orders_id_seq')")).fetchone()[0]
+        with engine.begin() as connection:
+            connection.execute(text(
+                f"ALTER SEQUENCE orders_id_seq rename to {order_back_name}_id_seq_bak"))
+            connection.execute(text(
+                f"ALTER SEQUENCE trades_id_seq rename to {trade_back_name}_id_seq_bak"))
+    return order_id, trade_id
+
+
+def set_sequence_ids(engine, order_id, trade_id):
+
+    if engine.name == 'postgresql':
+        with engine.begin() as connection:
+            if order_id:
+                connection.execute(text(f"ALTER SEQUENCE orders_id_seq RESTART WITH {order_id}"))
+            if trade_id:
+                connection.execute(text(f"ALTER SEQUENCE trades_id_seq RESTART WITH {trade_id}"))
+
+
+def migrate_trades_and_orders_table(
+        decl_base, inspector, engine,
+        trade_back_name: str, cols: List,
+        order_back_name: str, cols_order: List):
     fee_open = get_column_def(cols, 'fee_open', 'fee')
     fee_open_cost = get_column_def(cols, 'fee_open_cost', 'null')
     fee_open_currency = get_column_def(cols, 'fee_open_currency', 'null')
@@ -64,11 +93,20 @@ def migrate_trades_table(decl_base, inspector, engine, table_back_name: str, col
 
     # Schema migration necessary
     with engine.begin() as connection:
-        connection.execute(text(f"alter table trades rename to {table_back_name}"))
+        connection.execute(text(f"alter table trades rename to {trade_back_name}"))
+
     with engine.begin() as connection:
         # drop indexes on backup table in new session
-        for index in inspector.get_indexes(table_back_name):
+        for index in inspector.get_indexes(trade_back_name):
+            if engine.name == 'mysql':
+                connection.execute(text(f"drop index {index['name']} on {trade_back_name}"))
+            else:
                 connection.execute(text(f"drop index {index['name']}"))
+
+    order_id, trade_id = get_last_sequence_ids(engine, trade_back_name, order_back_name)
+
+    drop_orders_table(engine, order_back_name)
+
     # let SQLAlchemy create the schema as required
     decl_base.metadata.create_all(engine)
 
@@ -100,9 +138,12 @@ def migrate_trades_table(decl_base, inspector, engine, table_back_name: str, col
             {sell_order_status} sell_order_status,
             {strategy} strategy, {buy_tag} buy_tag, {timeframe} timeframe,
             {open_trade_value} open_trade_value, {close_profit_abs} close_profit_abs
-            from {table_back_name}
+            from {trade_back_name}
             """))
 
+    migrate_orders_table(engine, order_back_name, cols_order)
+    set_sequence_ids(engine, order_id, trade_id)
+
 
 def migrate_open_orders_to_trades(engine):
     with engine.begin() as connection:
@@ -121,31 +162,40 @@ def migrate_open_orders_to_trades(engine):
         """))
 
 
-def migrate_orders_table(decl_base, inspector, engine, table_back_name: str, cols: List):
-    # Schema migration necessary
+def drop_orders_table(engine, table_back_name: str):
+    # Drop and recreate orders table as backup
+    # This drops foreign keys, too.
 
     with engine.begin() as connection:
-        connection.execute(text(f"alter table orders rename to {table_back_name}"))
+        connection.execute(text(f"create table {table_back_name} as select * from orders"))
+        connection.execute(text("drop table orders"))
 
-    with engine.begin() as connection:
-        # drop indexes on backup table in new session
-        for index in inspector.get_indexes(table_back_name):
-            connection.execute(text(f"drop index {index['name']}"))
+
+def migrate_orders_table(engine, table_back_name: str, cols_order: List):
+
+    ft_fee_base = get_column_def(cols_order, 'ft_fee_base', 'null')
+    average = get_column_def(cols_order, 'average', 'null')
 
     # let SQLAlchemy create the schema as required
-    decl_base.metadata.create_all(engine)
     with engine.begin() as connection:
         connection.execute(text(f"""
             insert into orders ( id, ft_trade_id, ft_order_side, ft_pair, ft_is_open, order_id,
-            status, symbol, order_type, side, price, amount, filled, average, remaining, cost,
-            order_date, order_filled_date, order_update_date)
+            status, symbol, order_type, side, price, amount, filled, average, remaining,
+            cost, order_date, order_filled_date, order_update_date, ft_fee_base)
             select id, ft_trade_id, ft_order_side, ft_pair, ft_is_open, order_id,
-            status, symbol, order_type, side, price, amount, filled, null average, remaining, cost,
-            order_date, order_filled_date, order_update_date
+            status, symbol, order_type, side, price, amount, filled, {average} average, remaining,
+            cost, order_date, order_filled_date, order_update_date, {ft_fee_base} ft_fee_base
             from {table_back_name}
             """))
 
 
+def set_sqlite_to_wal(engine):
+    if engine.name == 'sqlite' and str(engine.url) != 'sqlite://':
+        # Set Mode to
+        with engine.begin() as connection:
+            connection.execute(text("PRAGMA journal_mode=wal"))
+
+
 def check_migrate(engine, decl_base, previous_tables) -> None:
     """
     Checks if migration is necessary and migrates if necessary
@@ -153,26 +203,22 @@ def check_migrate(engine, decl_base, previous_tables) -> None:
     inspector = inspect(engine)
 
     cols = inspector.get_columns('trades')
+    cols_orders = inspector.get_columns('orders')
     tabs = get_table_names_for_table(inspector, 'trades')
     table_back_name = get_backup_name(tabs, 'trades_bak')
+    order_tabs = get_table_names_for_table(inspector, 'orders')
+    order_table_bak_name = get_backup_name(order_tabs, 'orders_bak')
 
-    # Check for latest column
-    if not has_column(cols, 'buy_tag'):
-        logger.info(f'Running database migration for trades - backup: {table_back_name}')
-        migrate_trades_table(decl_base, inspector, engine, table_back_name, cols)
-        # Reread columns - the above recreated the table!
-        inspector = inspect(engine)
-        cols = inspector.get_columns('trades')
+    # Check if migration necessary
+    # Migrates both trades and orders table!
+    # if not has_column(cols, 'buy_tag'):
+    if 'orders' not in previous_tables or not has_column(cols_orders, 'ft_fee_base'):
+        logger.info(f"Running database migration for trades - "
+                    f"backup: {table_back_name}, {order_table_bak_name}")
+        migrate_trades_and_orders_table(
+            decl_base, inspector, engine, table_back_name, cols, order_table_bak_name, cols_orders)
 
     if 'orders' not in previous_tables and 'trades' in previous_tables:
         logger.info('Moving open orders to Orders table.')
         migrate_open_orders_to_trades(engine)
-    else:
-        cols_order = inspector.get_columns('orders')
-
-        if not has_column(cols_order, 'average'):
-            tabs = get_table_names_for_table(inspector, 'orders')
-            # Empty for now - as there is only one iteration of the orders table so far.
-            table_back_name = get_backup_name(tabs, 'orders_bak')
-
-            migrate_orders_table(decl_base, inspector, engine, table_back_name, cols)
+    set_sqlite_to_wal(engine)

freqtrade/persistence/models.py

@@ -16,7 +16,6 @@ from sqlalchemy.sql.schema import UniqueConstraint
 from freqtrade.constants import DATETIME_PRINT_FORMAT, NON_OPEN_EXCHANGE_STATES
 from freqtrade.enums import SellType
 from freqtrade.exceptions import DependencyException, OperationalException
-from freqtrade.misc import safe_value_fallback
 from freqtrade.persistence.migrations import check_migrate
 
 
@@ -39,6 +38,9 @@ def init_db(db_url: str, clean_open_orders: bool = False) -> None:
     """
     kwargs = {}
 
+    if db_url == 'sqlite:///':
+        raise OperationalException(
+            f'Bad db-url {db_url}. For in-memory database, please use `sqlite://`.')
     if db_url == 'sqlite://':
         kwargs.update({
             'poolclass': StaticPool,
@@ -113,14 +115,15 @@ class Order(_DECL_BASE):
 
     trade = relationship("Trade", back_populates="orders")
 
-    ft_order_side = Column(String(25), nullable=False)
-    ft_pair = Column(String(25), nullable=False)
+    # order_side can only be 'buy', 'sell' or 'stoploss'
+    ft_order_side: str = Column(String(25), nullable=False)
+    ft_pair: str = Column(String(25), nullable=False)
     ft_is_open = Column(Boolean, nullable=False, default=True, index=True)
 
-    order_id = Column(String(255), nullable=False, index=True)
+    order_id: str = Column(String(255), nullable=False, index=True)
     status = Column(String(255), nullable=True)
     symbol = Column(String(25), nullable=True)
-    order_type = Column(String(50), nullable=True)
+    order_type: str = Column(String(50), nullable=True)
     side = Column(String(25), nullable=True)
     price = Column(Float, nullable=True)
     average = Column(Float, nullable=True)
@@ -132,6 +135,29 @@ class Order(_DECL_BASE):
     order_filled_date = Column(DateTime, nullable=True)
     order_update_date = Column(DateTime, nullable=True)
 
+    ft_fee_base = Column(Float, nullable=True)
+
+    @property
+    def order_date_utc(self) -> datetime:
+        """ Order-date with UTC timezoneinfo"""
+        return self.order_date.replace(tzinfo=timezone.utc)
+
+    @property
+    def safe_price(self) -> float:
+        return self.average or self.price
+
+    @property
+    def safe_filled(self) -> float:
+        return self.filled or self.amount or 0.0
+
+    @property
+    def safe_fee_base(self) -> float:
+        return self.ft_fee_base or 0.0
+
+    @property
+    def safe_amount_after_fee(self) -> float:
+        return self.safe_filled - self.safe_fee_base
+
     def __repr__(self):
 
         return (f'Order(id={self.id}, order_id={self.order_id}, trade_id={self.ft_trade_id}, '
@@ -165,6 +191,37 @@ class Order(_DECL_BASE):
                 self.order_filled_date = datetime.now(timezone.utc)
         self.order_update_date = datetime.now(timezone.utc)
 
+    def to_json(self) -> Dict[str, Any]:
+        return {
+            'pair': self.ft_pair,
+            'order_id': self.order_id,
+            'status': self.status,
+            'amount': self.amount,
+            'average': round(self.average, 8) if self.average else 0,
+            'safe_price': self.safe_price,
+            'cost': self.cost if self.cost else 0,
+            'filled': self.filled,
+            'ft_order_side': self.ft_order_side,
+            'is_open': self.ft_is_open,
+            'order_date': self.order_date.strftime(DATETIME_PRINT_FORMAT)
+            if self.order_date else None,
+            'order_timestamp': int(self.order_date.replace(
+                tzinfo=timezone.utc).timestamp() * 1000) if self.order_date else None,
+            'order_filled_date': self.order_filled_date.strftime(DATETIME_PRINT_FORMAT)
+            if self.order_filled_date else None,
+            'order_filled_timestamp': int(self.order_filled_date.replace(
+                tzinfo=timezone.utc).timestamp() * 1000) if self.order_filled_date else None,
+            'order_type': self.order_type,
+            'price': self.price,
+            'remaining': self.remaining,
+        }
+
+    def close_bt_order(self, close_date: datetime):
+        self.order_filled_date = close_date
+        self.filled = self.amount
+        self.status = 'closed'
+        self.ft_is_open = False
+
     @staticmethod
     def update_orders(orders: List['Order'], order: Dict[str, Any]):
         """
@@ -247,7 +304,7 @@ class LocalTrade():
     # absolute value of the initial stop loss
     initial_stop_loss: float = 0.0
     # percentage value of the initial stop loss
-    initial_stop_loss_pct: float = 0.0
+    initial_stop_loss_pct: Optional[float] = None
     # stoploss order id which is on exchange
     stoploss_order_id: Optional[str] = None
     # last update time of the stoploss order on exchange
@@ -282,6 +339,9 @@ class LocalTrade():
         return self.close_date.replace(tzinfo=timezone.utc)
 
     def to_json(self) -> Dict[str, Any]:
+        filled_orders = self.select_filled_orders()
+        orders = [order.to_json() for order in filled_orders]
+
         return {
             'trade_id': self.id,
             'pair': self.pair,
@@ -345,6 +405,7 @@ class LocalTrade():
             'max_rate': self.max_rate,
 
             'open_order_id': self.open_order_id,
+            'orders': orders,
         }
 
     @staticmethod
@@ -385,7 +446,8 @@ class LocalTrade():
         new_loss = float(current_price * (1 - abs(stoploss)))
 
         # no stop loss assigned yet
-        if not self.stop_loss:
+        # if not self.stop_loss:
+        if self.initial_stop_loss_pct is None:
             logger.debug(f"{self.pair} - Assigning new stoploss...")
             self._set_new_stoploss(new_loss, stoploss)
             self.initial_stop_loss = new_loss
@@ -407,40 +469,39 @@ class LocalTrade():
             f"Trailing stoploss saved us: "
             f"{float(self.stop_loss) - float(self.initial_stop_loss):.8f}.")
 
-    def update(self, order: Dict) -> None:
+    def update_trade(self, order: Order) -> None:
         """
         Updates this entity with amount and actual open/close rates.
         :param order: order retrieved by exchange.fetch_order()
         :return: None
         """
-        order_type = order['type']
         # Ignore open and cancelled orders
-        if order['status'] == 'open' or safe_value_fallback(order, 'average', 'price') is None:
+        if order.status == 'open' or order.safe_price is None:
             return
 
-        logger.info('Updating trade (id=%s) ...', self.id)
+        logger.info(f'Updating trade (id={self.id}) ...')
 
-        if order_type in ('market', 'limit') and order['side'] == 'buy':
+        if order.ft_order_side == 'buy':
             # Update open rate and actual amount
-            self.open_rate = float(safe_value_fallback(order, 'average', 'price'))
-            self.amount = float(safe_value_fallback(order, 'filled', 'amount'))
+            self.open_rate = order.safe_price
+            self.amount = order.safe_amount_after_fee
             if self.is_open:
-                logger.info(f'{order_type.upper()}_BUY has been fulfilled for {self}.')
+                logger.info(f'{order.order_type.upper()}_BUY has been fulfilled for {self}.')
             self.open_order_id = None
             self.recalc_trade_from_orders()
-        elif order_type in ('market', 'limit') and order['side'] == 'sell':
+        elif order.ft_order_side == 'sell':
             if self.is_open:
-                logger.info(f'{order_type.upper()}_SELL has been fulfilled for {self}.')
-            self.close(safe_value_fallback(order, 'average', 'price'))
-        elif order_type in ('stop_loss_limit', 'stop-loss', 'stop-loss-limit', 'stop'):
+                logger.info(f'{order.order_type.upper()}_SELL has been fulfilled for {self}.')
+            self.close(order.safe_price)
+        elif order.ft_order_side == 'stoploss':
             self.stoploss_order_id = None
             self.close_rate_requested = self.stop_loss
             self.sell_reason = SellType.STOPLOSS_ON_EXCHANGE.value
             if self.is_open:
-                logger.info(f'{order_type.upper()} is hit for {self}.')
-            self.close(safe_value_fallback(order, 'average', 'price'))
+                logger.info(f'{order.order_type.upper()} is hit for {self}.')
+            self.close(order.safe_price)
         else:
-            raise ValueError(f'Unknown order type: {order_type}')
+            raise ValueError(f'Unknown order type: {order.order_type}')
         Trade.commit()
 
     def close(self, rate: float, *, show_msg: bool = True) -> None:
@@ -583,7 +644,7 @@ class LocalTrade():
                     (o.status not in NON_OPEN_EXCHANGE_STATES)):
                 continue
 
-            tmp_amount = o.amount
+            tmp_amount = o.safe_amount_after_fee
             tmp_price = o.average or o.price
             if o.filled is not None:
                 tmp_amount = o.filled
@@ -600,14 +661,27 @@ class LocalTrade():
             if self.stop_loss_pct is not None and self.open_rate is not None:
                 self.adjust_stop_loss(self.open_rate, self.stop_loss_pct)
 
-    def select_order(self, order_side: str, is_open: Optional[bool]) -> Optional[Order]:
+    def select_order_by_order_id(self, order_id: str) -> Optional[Order]:
+        """
+        Finds order object by Order id.
+        :param order_id: Exchange order id
+        """
+        for o in self.orders:
+            if o.order_id == order_id:
+                return o
+        return None
+
+    def select_order(
+            self, order_side: str = None, is_open: Optional[bool] = None) -> Optional[Order]:
         """
         Finds latest order for this orderside and status
-        :param order_side: Side of the order (either 'buy' or 'sell')
+        :param order_side: ft_order_side of the order (either 'buy', 'sell' or 'stoploss')
         :param is_open: Only search for open orders?
         :return: latest Order object if it exists, else None
         """
-        orders = [o for o in self.orders if o.side == order_side]
+        orders = self.orders
+        if order_side:
+            orders = [o for o in self.orders if o.ft_order_side == order_side]
         if is_open is not None:
             orders = [o for o in orders if o.ft_is_open == is_open]
         if len(orders) > 0:
@@ -615,14 +689,14 @@ class LocalTrade():
         else:
             return None
 
-    def select_filled_orders(self, order_side: str) -> List['Order']:
+    def select_filled_orders(self, order_side: Optional[str] = None) -> List['Order']:
         """
         Finds filled orders for this orderside.
-        :param order_side: Side of the order (either 'buy' or 'sell')
+        :param order_side: Side of the order (either 'buy', 'sell', or None)
         :return: array of Order objects
         """
-        return [o for o in self.orders if o.ft_order_side == order_side and
-                o.ft_is_open is False and
+        return [o for o in self.orders if ((o.ft_order_side == order_side) or (order_side is None))
+                and o.ft_is_open is False and
                 (o.filled or 0) > 0 and
                 o.status in NON_OPEN_EXCHANGE_STATES]
 
@@ -713,6 +787,7 @@ class LocalTrade():
                 logger.info(f"Stoploss for {trade} needs adjustment...")
                 # Force reset of stoploss
                 trade.stop_loss = None
+                trade.initial_stop_loss_pct = None
                 trade.adjust_stop_loss(trade.open_rate, desired_stoploss)
                 logger.info(f"New stoploss: {trade.stop_loss}.")
 
@@ -741,11 +816,11 @@ class Trade(_DECL_BASE, LocalTrade):
     fee_close = Column(Float, nullable=False, default=0.0)
     fee_close_cost = Column(Float, nullable=True)
     fee_close_currency = Column(String(25), nullable=True)
-    open_rate = Column(Float)
+    open_rate: float = Column(Float)
     open_rate_requested = Column(Float)
     # open_trade_value - calculated via _calc_open_trade_value
     open_trade_value = Column(Float)
-    close_rate = Column(Float)
+    close_rate: Optional[float] = Column(Float)
     close_rate_requested = Column(Float)
     close_profit = Column(Float)
     close_profit_abs = Column(Float)

freqtrade/plot/plotting.py

@@ -61,8 +61,8 @@ def init_plotscript(config, markets: List, startup_candles: int = 0):
                                             startup_candles, min_date)
 
     no_trades = False
-    filename = config.get('exportfilename')
-    if config.get('no_trades', False):
+    filename = config.get("exportfilename")
+    if config.get("no_trades", False):
         no_trades = True
     elif config['trade_source'] == 'file':
         if not filename.is_dir() and not filename.is_file():

freqtrade/plugins/pairlist/AgeFilter.py

@@ -98,7 +98,7 @@ class AgeFilter(IPairList):
         """
         Validate age for the ticker
         :param pair: Pair that's currently validated
-        :param ticker: ticker dict as returned from ccxt.fetch_tickers()
+        :param daily_candles: Downloaded daily candles
         :return: True if the pair can stay, false if it should be removed
         """
         # Check symbol in cache

freqtrade/plugins/pairlist/PerformanceFilter.py

@@ -60,6 +60,7 @@ class PerformanceFilter(IPairList):
 
         # Get pairlist from performance dataframe values
         list_df = pd.DataFrame({'pair': pairlist})
+        list_df['prior_idx'] = list_df.index
 
         # Set initial value for pairs with no trades to 0
         # Sort the list using:
@@ -67,7 +68,7 @@ class PerformanceFilter(IPairList):
         #  - then count (low to high, so as to favor same performance with fewer trades)
         #  - then pair name alphametically
         sorted_df = list_df.merge(performance, on='pair', how='left')\
-            .fillna(0).sort_values(by=['count', 'pair'], ascending=True)\
+            .fillna(0).sort_values(by=['count', 'prior_idx'], ascending=True)\
             .sort_values(by=['profit_ratio'], ascending=False)
         if self._min_profit is not None:
             removed = sorted_df[sorted_df['profit_ratio'] < self._min_profit]

freqtrade/plugins/pairlist/PrecisionFilter.py

@@ -51,7 +51,7 @@ class PrecisionFilter(IPairList):
         :param ticker: ticker dict as returned from ccxt.fetch_tickers()
         :return: True if the pair can stay, false if it should be removed
         """
-        stop_price = ticker['ask'] * self._stoploss
+        stop_price = ticker['last'] * self._stoploss
 
         # Adjust stop-prices to precision
         sp = self._exchange.price_to_precision(pair, stop_price)

freqtrade/plugins/pairlist/SpreadFilter.py

@@ -4,6 +4,7 @@ Spread pair list filter
 import logging
 from typing import Any, Dict
 
+from freqtrade.exceptions import OperationalException
 from freqtrade.plugins.pairlist.IPairList import IPairList
 
 
@@ -20,6 +21,12 @@ class SpreadFilter(IPairList):
         self._max_spread_ratio = pairlistconfig.get('max_spread_ratio', 0.005)
         self._enabled = self._max_spread_ratio != 0
 
+        if not self._exchange.exchange_has('fetchTickers'):
+            raise OperationalException(
+                'Exchange does not support fetchTickers, therefore SpreadFilter cannot be used.'
+                'Please edit your config and restart the bot.'
+            )
+
     @property
     def needstickers(self) -> bool:
         """

freqtrade/plugins/pairlist/VolatilityFilter.py

@@ -90,7 +90,7 @@ class VolatilityFilter(IPairList):
         """
         Validate trading range
         :param pair: Pair that's currently validated
-        :param ticker: ticker dict as returned from ccxt.fetch_tickers()
+        :param daily_candles: Downloaded daily candles
         :return: True if the pair can stay, false if it should be removed
         """
         # Check symbol in cache

freqtrade/plugins/pairlist/rangestabilityfilter.py

@@ -88,7 +88,7 @@ class RangeStabilityFilter(IPairList):
         """
         Validate trading range
         :param pair: Pair that's currently validated
-        :param ticker: ticker dict as returned from ccxt.fetch_tickers()
+        :param daily_candles: Downloaded daily candles
         :return: True if the pair can stay, false if it should be removed
         """
         # Check symbol in cache

freqtrade/resolvers/hyperopt_resolver.py

@@ -44,7 +44,6 @@ class HyperOptLossResolver(IResolver):
                                                         extra_dir=config.get('hyperopt_path'))
 
         # Assign timeframe to be used in hyperopt
-        hyperoptloss.__class__.ticker_interval = str(config['timeframe'])
         hyperoptloss.__class__.timeframe = str(config['timeframe'])
 
         return hyperoptloss

freqtrade/resolvers/iresolver.py

@@ -6,6 +6,7 @@ This module load custom objects
 import importlib.util
 import inspect
 import logging
+import sys
 from pathlib import Path
 from typing import Any, Dict, Iterator, List, Optional, Tuple, Type, Union
 
@@ -15,6 +16,22 @@ from freqtrade.exceptions import OperationalException
 logger = logging.getLogger(__name__)
 
 
+class PathModifier:
+    def __init__(self, path: Path):
+        self.path = path
+
+    def __enter__(self):
+        """Inject path to allow importing with relative imports."""
+        sys.path.insert(0, str(self.path))
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Undo insertion of local path."""
+        str_path = str(self.path)
+        if str_path in sys.path:
+            sys.path.remove(str_path)
+
+
 class IResolver:
     """
     This class contains all the logic to load custom classes
@@ -57,7 +74,9 @@ class IResolver:
 
         # Generate spec based on absolute path
         # Pass object_name as first argument to have logging print a reasonable name.
-        spec = importlib.util.spec_from_file_location(object_name or "", str(module_path))
+        with PathModifier(module_path.parent):
+            module_name = module_path.stem or ""
+            spec = importlib.util.spec_from_file_location(module_name, str(module_path))
             if not spec:
                 return iter([None])
 
@@ -75,8 +94,11 @@ class IResolver:
                 name, obj in inspect.getmembers(
                     module, inspect.isclass) if ((object_name is None or object_name == name)
                                                  and issubclass(obj, cls.object_type)
-                                             and obj is not cls.object_type)
+                                                 and obj is not cls.object_type
+                                                 and obj.__module__ == module_name
                                                  )
+            )
+            # The __module__ check ensures we only use strategies that are defined in this folder.
             return valid_objects_gen
 
     @classmethod

freqtrade/resolvers/strategy_resolver.py

@@ -45,14 +45,6 @@ class StrategyResolver(IResolver):
             strategy_name, config=config,
             extra_dir=config.get('strategy_path'))
 
-        if hasattr(strategy, 'ticker_interval') and not hasattr(strategy, 'timeframe'):
-            # Assign ticker_interval to timeframe to keep compatibility
-            if 'timeframe' not in config:
-                logger.warning(
-                    "DEPRECATED: Please migrate to using 'timeframe' instead of 'ticker_interval'."
-                )
-                strategy.timeframe = strategy.ticker_interval
-
         if strategy._ft_params_from_file:
             # Set parameters from Hyperopt results file
             params = strategy._ft_params_from_file
@@ -145,10 +137,6 @@ class StrategyResolver(IResolver):
         """
         Normalize attributes to have the correct type.
         """
-        # Assign deprecated variable - to not break users code relying on this.
-        if hasattr(strategy, 'timeframe'):
-            strategy.ticker_interval = strategy.timeframe
-
         # Sort and apply type conversions
         if hasattr(strategy, 'minimal_roi'):
             strategy.minimal_roi = dict(sorted(

freqtrade/rpc/api_server/api_backtest.py

@@ -8,7 +8,7 @@ from freqtrade.configuration.config_validation import validate_config_consistenc
 from freqtrade.enums import BacktestState
 from freqtrade.exceptions import DependencyException
 from freqtrade.rpc.api_server.api_schemas import BacktestRequest, BacktestResponse
-from freqtrade.rpc.api_server.deps import get_config
+from freqtrade.rpc.api_server.deps import get_config, is_webserver_mode
 from freqtrade.rpc.api_server.webserver import ApiServer
 from freqtrade.rpc.rpc import RPCException
 
@@ -20,8 +20,9 @@ router = APIRouter()
 
 
 @router.post('/backtest', response_model=BacktestResponse, tags=['webserver', 'backtest'])
+# flake8: noqa: C901
 async def api_start_backtest(bt_settings: BacktestRequest, background_tasks: BackgroundTasks,
-                             config=Depends(get_config)):
+                             config=Depends(get_config), ws_mode=Depends(is_webserver_mode)):
     """Start backtesting if not done so already"""
     if ApiServer._bgtask_running:
         raise RPCException('Bot Background task already running')
@@ -32,6 +33,10 @@ async def api_start_backtest(bt_settings: BacktestRequest, background_tasks: Bac
     for setting in settings.keys():
         if settings[setting] is not None:
             btconfig[setting] = settings[setting]
+    try:
+        btconfig['stake_amount'] = float(btconfig['stake_amount'])
+    except ValueError:
+        pass
 
     # Force dry-run for backtesting
     btconfig['dry_run'] = True
@@ -57,7 +62,6 @@ async def api_start_backtest(bt_settings: BacktestRequest, background_tasks: Bac
             ):
                 from freqtrade.optimize.backtesting import Backtesting
                 ApiServer._bt = Backtesting(btconfig)
-                if ApiServer._bt.timeframe_detail:
                 ApiServer._bt.load_bt_data_detail()
             else:
                 ApiServer._bt.config = btconfig
@@ -117,7 +121,7 @@ async def api_start_backtest(bt_settings: BacktestRequest, background_tasks: Bac
 
 
 @router.get('/backtest', response_model=BacktestResponse, tags=['webserver', 'backtest'])
-def api_get_backtest():
+def api_get_backtest(ws_mode=Depends(is_webserver_mode)):
     """
     Get backtesting result.
     Returns Result after backtesting has been ran.
@@ -153,7 +157,7 @@ def api_get_backtest():
 
 
 @router.delete('/backtest', response_model=BacktestResponse, tags=['webserver', 'backtest'])
-def api_delete_backtest():
+def api_delete_backtest(ws_mode=Depends(is_webserver_mode)):
     """Reset backtesting"""
     if ApiServer._bgtask_running:
         return {
@@ -179,7 +183,7 @@ def api_delete_backtest():
 
 
 @router.get('/backtest/abort', response_model=BacktestResponse, tags=['webserver', 'backtest'])
-def api_backtest_abort():
+def api_backtest_abort(ws_mode=Depends(is_webserver_mode)):
     if not ApiServer._bgtask_running:
         return {
             "status": "not_running",

freqtrade/rpc/api_server/api_schemas.py

@@ -109,7 +109,7 @@ class SellReason(BaseModel):
 
 class Stats(BaseModel):
     sell_reasons: Dict[str, SellReason]
-    durations: Dict[str, Union[str, float]]
+    durations: Dict[str, Optional[float]]
 
 
 class DailyRecord(BaseModel):
@@ -149,7 +149,7 @@ class ShowConfig(BaseModel):
     api_version: float
     dry_run: bool
     stake_currency: str
-    stake_amount: Union[float, str]
+    stake_amount: str
     available_capital: Optional[float]
     stake_currency_decimals: int
     max_open_trades: int
@@ -177,6 +177,22 @@ class ShowConfig(BaseModel):
     max_entry_position_adjustment: int
 
 
+class OrderSchema(BaseModel):
+    pair: str
+    order_id: str
+    status: str
+    remaining: float
+    amount: float
+    safe_price: float
+    cost: float
+    filled: float
+    ft_order_side: str
+    order_type: str
+    is_open: bool
+    order_timestamp: Optional[int]
+    order_filled_timestamp: Optional[int]
+
+
 class TradeSchema(BaseModel):
     trade_id: int
     pair: str
@@ -224,6 +240,7 @@ class TradeSchema(BaseModel):
     min_rate: Optional[float]
     max_rate: Optional[float]
     open_order_id: Optional[str]
+    orders: List[OrderSchema]
 
 
 class OpenTradeSchema(TradeSchema):
@@ -280,6 +297,7 @@ class ForceBuyPayload(BaseModel):
     price: Optional[float]
     ordertype: Optional[OrderTypeValues]
     stakeamount: Optional[float]
+    entry_tag: Optional[str]
 
 
 class ForceSellPayload(BaseModel):
@@ -365,7 +383,7 @@ class BacktestRequest(BaseModel):
     timeframe_detail: Optional[str]
     timerange: Optional[str]
     max_open_trades: Optional[int]
-    stake_amount: Optional[Union[float, str]]
+    stake_amount: Optional[str]
     enable_protections: bool
     dry_run_wallet: Optional[float]
 
@@ -384,3 +402,8 @@ class BacktestResponse(BaseModel):
 class SysInfo(BaseModel):
     cpu_pct: List[float]
     ram_pct: float
+
+
+class Health(BaseModel):
+    last_process: datetime
+    last_process_ts: int

freqtrade/rpc/api_server/api_v1.py

@@ -14,12 +14,12 @@ from freqtrade.rpc import RPC
 from freqtrade.rpc.api_server.api_schemas import (AvailablePairs, Balances, BlacklistPayload,
                                                   BlacklistResponse, Count, Daily,
                                                   DeleteLockRequest, DeleteTrade, ForceBuyPayload,
-                                                  ForceBuyResponse, ForceSellPayload, Locks, Logs,
-                                                  OpenTradeSchema, PairHistory, PerformanceEntry,
-                                                  Ping, PlotConfig, Profit, ResultMsg, ShowConfig,
-                                                  Stats, StatusMsg, StrategyListResponse,
-                                                  StrategyResponse, SysInfo, Version,
-                                                  WhitelistResponse)
+                                                  ForceBuyResponse, ForceSellPayload, Health, Locks,
+                                                  Logs, OpenTradeSchema, PairHistory,
+                                                  PerformanceEntry, Ping, PlotConfig, Profit,
+                                                  ResultMsg, ShowConfig, Stats, StatusMsg,
+                                                  StrategyListResponse, StrategyResponse, SysInfo,
+                                                  Version, WhitelistResponse)
 from freqtrade.rpc.api_server.deps import get_config, get_exchange, get_rpc, get_rpc_optional
 from freqtrade.rpc.rpc import RPCException
 
@@ -32,7 +32,8 @@ logger = logging.getLogger(__name__)
 # 1.11: forcebuy and forcesell accept ordertype
 # 1.12: add blacklist delete endpoint
 # 1.13: forcebuy supports stake_amount
-API_VERSION = 1.13
+# 1.14: Add entry/exit orders to trade response
+API_VERSION = 1.14
 
 # Public API, requires no auth.
 router_public = APIRouter()
@@ -136,8 +137,9 @@ def show_config(rpc: Optional[RPC] = Depends(get_rpc_optional), config=Depends(g
 def forcebuy(payload: ForceBuyPayload, rpc: RPC = Depends(get_rpc)):
     ordertype = payload.ordertype.value if payload.ordertype else None
     stake_amount = payload.stakeamount if payload.stakeamount else None
+    entry_tag = payload.entry_tag if payload.entry_tag else 'forceentry'
 
-    trade = rpc._rpc_forcebuy(payload.pair, payload.price, ordertype, stake_amount)
+    trade = rpc._rpc_forcebuy(payload.pair, payload.price, ordertype, stake_amount, entry_tag)
 
     if trade:
         return ForceBuyResponse.parse_obj(trade.to_json())
@@ -291,3 +293,8 @@ def list_available_pairs(timeframe: Optional[str] = None, stake_currency: Option
 @router.get('/sysinfo', response_model=SysInfo, tags=['info'])
 def sysinfo():
     return RPC._rpc_sysinfo()
+
+
+@router.get('/health', response_model=Health, tags=['info'])
+def health(rpc: RPC = Depends(get_rpc)):
+    return rpc._health()

freqtrade/rpc/api_server/deps.py

@@ -2,6 +2,7 @@ from typing import Any, Dict, Iterator, Optional
 
 from fastapi import Depends
 
+from freqtrade.enums import RunMode
 from freqtrade.persistence import Trade
 from freqtrade.rpc.rpc import RPC, RPCException
 
@@ -38,3 +39,9 @@ def get_exchange(config=Depends(get_config)):
         ApiServer._exchange = ExchangeResolver.load_exchange(
             config['exchange']['name'], config)
     return ApiServer._exchange
+
+
+def is_webserver_mode(config=Depends(get_config)):
+    if config['runmode'] != RunMode.WEBSERVER:
+        raise RPCException('Bot is not in the correct state')
+    return None

freqtrade/rpc/fiat_convert.py

@@ -17,6 +17,16 @@ from freqtrade.constants import SUPPORTED_FIAT
 logger = logging.getLogger(__name__)
 
 
+# Manually map symbol to ID for some common coins
+# with duplicate coingecko entries
+coingecko_mapping = {
+    'eth': 'ethereum',
+    'bnb': 'binancecoin',
+    'sol': 'solana',
+    'usdt': 'tether',
+}
+
+
 class CryptoToFiatConverter:
     """
     Main class to initiate Crypto to FIAT.
@@ -77,8 +87,9 @@ class CryptoToFiatConverter:
             else:
                 return None
         found = [x for x in self._coinlistings if x['symbol'] == crypto_symbol]
-        if crypto_symbol == 'eth':
-            found = [x for x in self._coinlistings if x['id'] == 'ethereum']
+
+        if crypto_symbol in coingecko_mapping.keys():
+            found = [x for x in self._coinlistings if x['id'] == coingecko_mapping[crypto_symbol]]
 
         if len(found) == 1:
             return found[0]['id']

freqtrade/rpc/rpc.py

@@ -10,8 +10,9 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 import arrow
 import psutil
 from dateutil.relativedelta import relativedelta
+from dateutil.tz import tzlocal
 from numpy import NAN, inf, int64, mean
-from pandas import DataFrame
+from pandas import DataFrame, NaT
 
 from freqtrade import __version__
 from freqtrade.configuration.timerange import TimeRange
@@ -111,7 +112,7 @@ class RPC:
             'dry_run': config['dry_run'],
             'stake_currency': config['stake_currency'],
             'stake_currency_decimals': decimals_per_coin(config['stake_currency']),
-            'stake_amount': config['stake_amount'],
+            'stake_amount': str(config['stake_amount']),
             'available_capital': config.get('available_capital'),
             'max_open_trades': (config['max_open_trades']
                                 if config['max_open_trades'] != float('inf') else -1),
@@ -263,7 +264,7 @@ class RPC:
                 profitcol += " (" + fiat_display_currency + ")"
 
             if self._config.get('position_adjustment_enable', False):
-                columns = ['ID', 'Pair', 'Since', profitcol, '# Buys']
+                columns = ['ID', 'Pair', 'Since', profitcol, '# Entries']
             else:
                 columns = ['ID', 'Pair', 'Since', profitcol]
             return trades_list, columns, fiat_profit_sum
@@ -439,9 +440,9 @@ class RPC:
                 trade_dur = (trade.close_date - trade.open_date).total_seconds()
                 dur[trade_win_loss(trade)].append(trade_dur)
 
-        wins_dur = sum(dur['wins']) / len(dur['wins']) if len(dur['wins']) > 0 else 'N/A'
-        draws_dur = sum(dur['draws']) / len(dur['draws']) if len(dur['draws']) > 0 else 'N/A'
-        losses_dur = sum(dur['losses']) / len(dur['losses']) if len(dur['losses']) > 0 else 'N/A'
+        wins_dur = sum(dur['wins']) / len(dur['wins']) if len(dur['wins']) > 0 else None
+        draws_dur = sum(dur['draws']) / len(dur['draws']) if len(dur['draws']) > 0 else None
+        losses_dur = sum(dur['losses']) / len(dur['losses']) if len(dur['losses']) > 0 else None
 
         durations = {'wins': wins_dur, 'draws': draws_dur, 'losses': losses_dur}
         return {'sell_reasons': sell_reasons, 'durations': durations}
@@ -581,7 +582,7 @@ class RPC:
             else:
                 try:
                     pair = self._freqtrade.exchange.get_valid_pair_combination(coin, stake_currency)
-                    rate = tickers.get(pair, {}).get('bid', None)
+                    rate = tickers.get(pair, {}).get('last', None)
                     if rate:
                         if pair.startswith(stake_currency) and not pair.endswith(stake_currency):
                             rate = 1.0 / rate
@@ -598,11 +599,6 @@ class RPC:
                 'est_stake': est_stake or 0,
                 'stake': stake_currency,
             })
-        if total == 0.0:
-            if self._freqtrade.config['dry_run']:
-                raise RPCException('Running in Dry Run, balances are not available.')
-            else:
-                raise RPCException('All balances are zero.')
 
         value = self._fiat_converter.convert_amount(
             total, stake_currency, fiat_display_currency) if self._fiat_converter else 0
@@ -716,7 +712,8 @@ class RPC:
             return {'result': f'Created sell order for trade {trade_id}.'}
 
     def _rpc_forcebuy(self, pair: str, price: Optional[float], order_type: Optional[str] = None,
-                      stake_amount: Optional[float] = None) -> Optional[Trade]:
+                      stake_amount: Optional[float] = None,
+                      buy_tag: Optional[str] = 'forceentry') -> Optional[Trade]:
         """
         Handler for forcebuy <asset> <price>
         Buys a pair trade at the given or current price
@@ -750,7 +747,7 @@ class RPC:
             order_type = self._freqtrade.strategy.order_types.get(
                 'forcebuy', self._freqtrade.strategy.order_types['buy'])
         if self._freqtrade.execute_entry(pair, stake_amount, price,
-                                         ordertype=order_type, trade=trade):
+                                         ordertype=order_type, trade=trade, buy_tag=buy_tag):
             Trade.commit()
             trade = Trade.get_trades([Trade.is_open.is_(True), Trade.pair == pair]).first()
             return trade
@@ -962,8 +959,16 @@ class RPC:
                 sell_mask = (dataframe['sell'] == 1)
                 sell_signals = int(sell_mask.sum())
                 dataframe.loc[sell_mask, '_sell_signal_close'] = dataframe.loc[sell_mask, 'close']
-            dataframe = dataframe.replace([inf, -inf], NAN)
-            dataframe = dataframe.replace({NAN: None})
+
+            # band-aid until this is fixed:
+            # https://github.com/pandas-dev/pandas/issues/45836
+            datetime_types = ['datetime', 'datetime64', 'datetime64[ns, UTC]']
+            date_columns = dataframe.select_dtypes(include=datetime_types)
+            for date_column in date_columns:
+                # replace NaT with `None`
+                dataframe[date_column] = dataframe[date_column].astype(object).replace({NaT: None})
+
+            dataframe = dataframe.replace({inf: None, -inf: None, NAN: None})
 
         res = {
             'pair': pair,
@@ -1038,3 +1043,11 @@ class RPC:
             "cpu_pct": psutil.cpu_percent(interval=1, percpu=True),
             "ram_pct": psutil.virtual_memory().percent
         }
+
+    def _health(self) -> Dict[str, Union[str, int]]:
+        last_p = self._freqtrade.last_process
+        return {
+            'last_process': str(last_p),
+            'last_process_loc': last_p.astimezone(tzlocal()).strftime(DATETIME_PRINT_FORMAT),
+            'last_process_ts': int(last_p.timestamp()),
+        }

freqtrade/rpc/telegram.py

@@ -113,7 +113,7 @@ class Telegram(RPCHandler):
                                  r'/stopbuy$', r'/reload_config$', r'/show_config$',
                                  r'/logs$', r'/whitelist$', r'/blacklist$', r'/bl_delete$',
                                  r'/weekly$', r'/weekly \d+$', r'/monthly$', r'/monthly \d+$',
-                                 r'/forcebuy$', r'/edge$', r'/help$', r'/version$']
+                                 r'/forcebuy$', r'/edge$', r'/health$', r'/help$', r'/version$']
         # Create keys for generation
         valid_keys_print = [k.replace('$', '') for k in valid_keys]
 
@@ -173,6 +173,7 @@ class Telegram(RPCHandler):
             CommandHandler(['blacklist_delete', 'bl_delete'], self._blacklist_delete),
             CommandHandler('logs', self._logs),
             CommandHandler('edge', self._edge),
+            CommandHandler('health', self._health),
             CommandHandler('help', self._help),
             CommandHandler('version', self._version),
         ]
@@ -369,6 +370,54 @@ class Telegram(RPCHandler):
         else:
             return "\N{CROSS MARK}"
 
+    def _prepare_entry_details(self, filled_orders: List, base_currency: str, is_open: bool):
+        """
+        Prepare details of trade with entry adjustment enabled
+        """
+        lines: List[str] = []
+        if len(filled_orders) > 0:
+            first_avg = filled_orders[0]["safe_price"]
+
+        for x, order in enumerate(filled_orders):
+            if order['ft_order_side'] != 'buy':
+                continue
+            cur_entry_datetime = arrow.get(order["order_filled_date"])
+            cur_entry_amount = order["amount"]
+            cur_entry_average = order["safe_price"]
+            lines.append("  ")
+            if x == 0:
+                lines.append(f"*Entry #{x+1}:*")
+                lines.append(
+                    f"*Entry Amount:* {cur_entry_amount} ({order['cost']:.8f} {base_currency})")
+                lines.append(f"*Average Entry Price:* {cur_entry_average}")
+            else:
+                sumA = 0
+                sumB = 0
+                for y in range(x):
+                    sumA += (filled_orders[y]["amount"] * filled_orders[y]["safe_price"])
+                    sumB += filled_orders[y]["amount"]
+                prev_avg_price = sumA / sumB
+                price_to_1st_entry = ((cur_entry_average - first_avg) / first_avg)
+                minus_on_entry = 0
+                if prev_avg_price:
+                    minus_on_entry = (cur_entry_average - prev_avg_price) / prev_avg_price
+
+                dur_entry = cur_entry_datetime - arrow.get(filled_orders[x-1]["order_filled_date"])
+                days = dur_entry.days
+                hours, remainder = divmod(dur_entry.seconds, 3600)
+                minutes, seconds = divmod(remainder, 60)
+                lines.append(f"*Entry #{x+1}:* at {minus_on_entry:.2%} avg profit")
+                if is_open:
+                    lines.append("({})".format(cur_entry_datetime
+                                               .humanize(granularity=["day", "hour", "minute"])))
+                lines.append(
+                    f"*Entry Amount:* {cur_entry_amount} ({order['cost']:.8f} {base_currency})")
+                lines.append(f"*Average Entry Price:* {cur_entry_average} "
+                             f"({price_to_1st_entry:.2%} from 1st entry rate)")
+                lines.append(f"*Order filled at:* {order['order_filled_date']}")
+                lines.append(f"({days}d {hours}h {minutes}m {seconds}s from previous entry)")
+        return lines
+
     @authorized_only
     def _status(self, update: Update, context: CallbackContext) -> None:
         """
@@ -392,21 +441,37 @@ class Telegram(RPCHandler):
                 trade_ids = [int(i) for i in context.args if i.isnumeric()]
 
             results = self._rpc._rpc_trade_status(trade_ids=trade_ids)
-
+            position_adjust = self._config.get('position_adjustment_enable', False)
+            max_entries = self._config.get('max_entry_position_adjustment', -1)
             messages = []
             for r in results:
                 r['open_date_hum'] = arrow.get(r['open_date']).humanize()
+                r['num_entries'] = len([o for o in r['orders'] if o['ft_order_side'] == 'buy'])
+                r['sell_reason'] = r.get('sell_reason', "")
                 lines = [
-                    "*Trade ID:* `{trade_id}` `(since {open_date_hum})`",
+                    "*Trade ID:* `{trade_id}`" +
+                    ("` (since {open_date_hum})`" if r['is_open'] else ""),
                     "*Current Pair:* {pair}",
                     "*Amount:* `{amount} ({stake_amount} {base_currency})`",
-                    "*Buy Tag:* `{buy_tag}`" if r['buy_tag'] else "",
+                    "*Entry Tag:* `{buy_tag}`" if r['buy_tag'] else "",
+                    "*Exit Reason:* `{sell_reason}`" if r['sell_reason'] else "",
+                ]
+
+                if position_adjust:
+                    max_buy_str = (f"/{max_entries + 1}" if (max_entries > 0) else "")
+                    lines.append("*Number of Entries:* `{num_entries}`" + max_buy_str)
+
+                lines.extend([
                     "*Open Rate:* `{open_rate:.8f}`",
-                    "*Close Rate:* `{close_rate}`" if r['close_rate'] else "",
-                    "*Current Rate:* `{current_rate:.8f}`",
+                    "*Close Rate:* `{close_rate:.8f}`" if r['close_rate'] else "",
+                    "*Open Date:* `{open_date}`",
+                    "*Close Date:* `{close_date}`" if r['close_date'] else "",
+                    "*Current Rate:* `{current_rate:.8f}`" if r['is_open'] else "",
                     ("*Current Profit:* " if r['is_open'] else "*Close Profit: *")
                     + "`{profit_ratio:.2%}`",
-                ]
+                ])
+
+                if r['is_open']:
                     if (r['stop_loss_abs'] != r['initial_stop_loss_abs']
                             and r['initial_stop_loss_ratio'] is not None):
                         # Adding initial stoploss only if it is different from stoploss
@@ -424,6 +489,10 @@ class Telegram(RPCHandler):
                         else:
                             lines.append("*Open Order:* `{open_order}`")
 
+                lines_detail = self._prepare_entry_details(
+                    r['orders'], r['base_currency'], r['is_open'])
+                lines.extend(lines_detail if lines_detail else "")
+
                 # Filter empty lines using list-comprehension
                 messages.append("\n".join([line for line in lines if line]).format(**r))
 
@@ -703,9 +772,9 @@ class Telegram(RPCHandler):
         duration_msg = tabulate(
             [
                 ['Wins', str(timedelta(seconds=durations['wins']))
-                 if durations['wins'] != 'N/A' else 'N/A'],
+                 if durations['wins'] is not None else 'N/A'],
                 ['Losses', str(timedelta(seconds=durations['losses']))
-                 if durations['losses'] != 'N/A' else 'N/A']
+                 if durations['losses'] is not None else 'N/A']
             ],
             headers=['', 'Avg. Duration']
         )
@@ -727,12 +796,13 @@ class Telegram(RPCHandler):
             output = ''
             if self._config['dry_run']:
                 output += "*Warning:* Simulated balances in Dry Mode.\n"
-
-            output += ("Starting capital: "
-                       f"`{result['starting_capital']}` {self._config['stake_currency']}"
-                       )
-            output += (f" `{result['starting_capital_fiat']}` "
-                       f"{self._config['fiat_display_currency']}.\n"
+            starting_cap = round_coin_value(
+                result['starting_capital'], self._config['stake_currency'])
+            output += f"Starting capital: `{starting_cap}`"
+            starting_cap_fiat = round_coin_value(
+                result['starting_capital_fiat'], self._config['fiat_display_currency']
+            ) if result['starting_capital_fiat'] > 0 else ''
+            output += (f" `, {starting_cap_fiat}`.\n"
                        ) if result['starting_capital_fiat'] > 0 else '.\n'
 
             total_dust_balance = 0
@@ -851,6 +921,7 @@ class Telegram(RPCHandler):
             self._send_msg(str(e))
 
     def _forcebuy_action(self, pair, price=None):
+        if pair != 'cancel':
             try:
                 self._rpc._rpc_forcebuy(pair, price)
             except RPCException as e:
@@ -884,10 +955,13 @@ class Telegram(RPCHandler):
             self._forcebuy_action(pair, price)
         else:
             whitelist = self._rpc._rpc_whitelist()['whitelist']
-            pairs = [InlineKeyboardButton(text=pair, callback_data=pair) for pair in whitelist]
+            pair_buttons = [
+                InlineKeyboardButton(text=pair, callback_data=pair) for pair in sorted(whitelist)]
+            buttons_aligned = self._layout_inline_keyboard(pair_buttons)
 
+            buttons_aligned.append([InlineKeyboardButton(text='Cancel', callback_data='cancel')])
             self._send_msg(msg="Which pair?",
-                           keyboard=self._layout_inline_keyboard(pairs))
+                           keyboard=buttons_aligned)
 
     @authorized_only
     def _trades(self, update: Update, context: CallbackContext) -> None:
@@ -1282,6 +1356,7 @@ class Telegram(RPCHandler):
             "*/logs [limit]:* `Show latest logs - defaults to 10` \n"
             "*/count:* `Show number of active trades compared to allowed number of trades`\n"
             "*/edge:* `Shows validated pairs by Edge if it is enabled` \n"
+            "*/health* `Show latest process timestamp - defaults to 1970-01-01 00:00:00` \n"
 
             "_Statistics_\n"
             "------------\n"
@@ -1309,6 +1384,19 @@ class Telegram(RPCHandler):
 
         self._send_msg(message, parse_mode=ParseMode.MARKDOWN)
 
+    @authorized_only
+    def _health(self, update: Update, context: CallbackContext) -> None:
+        """
+        Handler for /health
+        Shows the last process timestamp
+        """
+        try:
+            health = self._rpc._health()
+            message = f"Last process: `{health['last_process_loc']}`"
+            self._send_msg(message)
+        except RPCException as e:
+            self._send_msg(str(e))
+
     @authorized_only
     def _version(self, update: Update, context: CallbackContext) -> None:
         """

freqtrade/strategy/interface.py

@@ -18,6 +18,7 @@ from freqtrade.exceptions import OperationalException, StrategyError
 from freqtrade.exchange import timeframe_to_minutes, timeframe_to_seconds
 from freqtrade.exchange.exchange import timeframe_to_next_date
 from freqtrade.persistence import PairLocks, Trade
+from freqtrade.persistence.models import LocalTrade, Order
 from freqtrade.strategy.hyper import HyperStrategyMixin
 from freqtrade.strategy.informative_decorator import (InformativeData, PopulateIndicators,
                                                       _create_and_merge_informative_pair,
@@ -54,7 +55,7 @@ class IStrategy(ABC, HyperStrategyMixin):
     Attributes you can use:
         minimal_roi -> Dict: Minimal ROI designed for the strategy
         stoploss -> float: optimal stoploss designed for the strategy
-        timeframe -> str: value of the timeframe (ticker interval) to use with the strategy
+        timeframe -> str: value of the timeframe to use with the strategy
     """
     # Strategy interface version
     # Default to version 2
@@ -80,7 +81,6 @@ class IStrategy(ABC, HyperStrategyMixin):
     use_custom_stoploss: bool = False
 
     # associated timeframe
-    ticker_interval: str  # DEPRECATED
     timeframe: str
 
     # Optional order types
@@ -686,7 +686,7 @@ class IStrategy(ABC, HyperStrategyMixin):
         else:
             return False
 
-    def should_sell(self, trade: Trade, rate: float, date: datetime, buy: bool,
+    def should_sell(self, trade: Trade, rate: float, current_time: datetime, buy: bool,
                     sell: bool, low: float = None, high: float = None,
                     force_stoploss: float = 0) -> SellCheckTuple:
         """
@@ -703,7 +703,8 @@ class IStrategy(ABC, HyperStrategyMixin):
         trade.adjust_min_max_rates(high or current_rate, low or current_rate)
 
         stoplossflag = self.stop_loss_reached(current_rate=current_rate, trade=trade,
-                                              current_time=date, current_profit=current_profit,
+                                              current_time=current_time,
+                                              current_profit=current_profit,
                                               force_stoploss=force_stoploss, low=low, high=high)
 
         # Set current rate to high for backtesting sell
@@ -713,7 +714,7 @@ class IStrategy(ABC, HyperStrategyMixin):
         # if buy signal and ignore_roi is set, we don't need to evaluate min_roi.
         roi_reached = (not (buy and self.ignore_roi_if_buy_signal)
                        and self.min_roi_reached(trade=trade, current_profit=current_profit,
-                                                current_time=date))
+                                                current_time=current_time))
 
         sell_signal = SellType.NONE
         custom_reason = ''
@@ -729,8 +730,8 @@ class IStrategy(ABC, HyperStrategyMixin):
                 sell_signal = SellType.SELL_SIGNAL
             else:
                 custom_reason = strategy_safe_wrapper(self.custom_sell, default_retval=False)(
-                    pair=trade.pair, trade=trade, current_time=date, current_rate=current_rate,
-                    current_profit=current_profit)
+                    pair=trade.pair, trade=trade, current_time=current_time,
+                    current_rate=current_rate, current_profit=current_profit)
                 if custom_reason:
                     sell_signal = SellType.CUSTOM_SELL
                     if isinstance(custom_reason, str):
@@ -862,23 +863,22 @@ class IStrategy(ABC, HyperStrategyMixin):
         else:
             return current_profit > roi
 
-    def ft_check_timed_out(self, side: str, trade: Trade, order: Dict,
+    def ft_check_timed_out(self, side: str, trade: LocalTrade, order: Order,
                            current_time: datetime) -> bool:
         """
         FT Internal method.
         Check if timeout is active, and if the order is still open and timed out
         """
         timeout = self.config.get('unfilledtimeout', {}).get(side)
-        ordertime = arrow.get(order['datetime']).datetime
         if timeout is not None:
             timeout_unit = self.config.get('unfilledtimeout', {}).get('unit', 'minutes')
             timeout_kwargs = {timeout_unit: -timeout}
             timeout_threshold = current_time + timedelta(**timeout_kwargs)
-            timedout = (order['status'] == 'open' and order['side'] == side
-                        and ordertime < timeout_threshold)
+            timedout = (order.status == 'open' and order.side == side
+                        and order.order_date_utc < timeout_threshold)
             if timedout:
                 return True
-        time_method = self.check_sell_timeout if order['side'] == 'sell' else self.check_buy_timeout
+        time_method = self.check_sell_timeout if order.side == 'sell' else self.check_buy_timeout
 
         return strategy_safe_wrapper(time_method,
                                      default_retval=False)(

freqtrade/templates/subtemplates/exchange_huobi.j2

@@ -0,0 +1,12 @@
+"exchange": {
+    "name": "{{ exchange_name | lower }}",
+    "key": "{{ exchange_key }}",
+    "secret": "{{ exchange_secret }}",
+    "ccxt_config": {},
+    "ccxt_async_config": {},
+    "pair_whitelist": [
+    ],
+    "pair_blacklist": [
+        "HT/.*"
+    ]
+}

freqtrade/wallets.py

@@ -211,7 +211,7 @@ class Wallets:
 
         return stake_amount
 
-    def get_trade_stake_amount(self, pair: str, edge=None) -> float:
+    def get_trade_stake_amount(self, pair: str, edge=None, update: bool = True) -> float:
         """
         Calculate stake amount for the trade
         :return: float: Stake amount
@@ -219,6 +219,7 @@ class Wallets:
         """
         stake_amount: float
         # Ensure wallets are uptodate.
+        if update:
             self.update()
         val_tied_up = Trade.total_open_trades_stakes()
         available_amount = self.get_available_stake_amount()

requirements-dev.txt

@@ -6,9 +6,9 @@
 coveralls==3.3.1
 flake8==4.0.1
 flake8-tidy-imports==4.6.0
-mypy==0.931
-pytest==6.2.5
-pytest-asyncio==0.17.2
+mypy==0.941
+pytest==7.1.1
+pytest-asyncio==0.18.2
 pytest-cov==3.0.0
 pytest-mock==3.7.0
 pytest-random-order==1.0.4
@@ -17,13 +17,13 @@ isort==5.10.1
 time-machine==2.6.0
 
 # Convert jupyter notebooks to markdown documents
-nbconvert==6.4.1
+nbconvert==6.4.4
 
 # mypy types
-types-cachetools==4.2.9
+types-cachetools==5.0.0
 types-filelock==3.2.5
-types-requests==2.27.7
-types-tabulate==0.8.5
+types-requests==2.27.14
+types-tabulate==0.8.6
 
 # Extensions to datetime library
-types-python-dateutil==2.8.9
+types-python-dateutil==2.8.10

requirements-hyperopt.txt

@@ -2,9 +2,9 @@
 -r requirements.txt
 
 # Required for hyperopt
-scipy==1.7.3
+scipy==1.8.0
 scikit-learn==1.0.2
 scikit-optimize==0.9.0
-filelock==3.4.2
+filelock==3.6.0
 joblib==1.1.0
 progressbar2==4.0.0

requirements-plot.txt

@@ -1,5 +1,5 @@
 # Include all requirements to run the bot.
 -r requirements.txt
 
-plotly==5.5.0
+plotly==5.6.0
 

requirements.txt

@@ -1,17 +1,17 @@
-numpy==1.22.1
-pandas==1.4.0
+numpy==1.22.3
+pandas==1.4.1
 pandas-ta==0.3.14b
 
-ccxt==1.71.73
+ccxt==1.76.65
 # Pin cryptography for now due to rust build errors with piwheels
-cryptography==36.0.1
+cryptography==36.0.2
 aiohttp==3.8.1
-SQLAlchemy==1.4.31
-python-telegram-bot==13.10
+SQLAlchemy==1.4.32
+python-telegram-bot==13.11
 arrow==1.2.2
 cachetools==4.2.2
 requests==2.27.1
-urllib3==1.26.8
+urllib3==1.26.9
 jsonschema==4.4.0
 TA-Lib==0.4.24
 technical==1.3.0
@@ -25,14 +25,14 @@ blosc==1.10.6
 py_find_1st==1.1.5
 
 # Load ticker files 30% faster
-python-rapidjson==1.5
+python-rapidjson==1.6
 
 # Notify systemd
 sdnotify==0.3.2
 
 # API Server
-fastapi==0.73.0
-uvicorn==0.17.1
+fastapi==0.75.0
+uvicorn==0.17.6
 pyjwt==2.3.0
 aiofiles==0.8.0
 psutil==5.9.0
@@ -41,6 +41,6 @@ psutil==5.9.0
 colorama==0.4.4
 # Building config files interactively
 questionary==1.10.0
-prompt-toolkit==3.0.26
+prompt-toolkit==3.0.28
 # Extensions to datetime library
 python-dateutil==2.8.2

setup.py

@@ -42,7 +42,7 @@ setup(
         ],
     install_requires=[
         # from requirements.txt
-        'ccxt>=1.66.32',
+        'ccxt>=1.76.5',
         'SQLAlchemy',
         'python-telegram-bot>=13.4',
         'arrow>=0.17.0',

setup.sh

@@ -36,7 +36,7 @@ function check_installed_python() {
         fi
     done
 
-    echo "No usable python found. Please make sure to have python3.7 or newer installed."
+    echo "No usable python found. Please make sure to have python3.8 or newer installed."
     exit 1
 }
 
@@ -132,6 +132,9 @@ function install_macos() {
         echo_block "Installing Brew"
         /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
     fi
+
+    brew install gettext
+
     #Gets number after decimal in python version
     version=$(egrep -o 3.\[0-9\]+ <<< $PYTHON | sed 's/3.//g')
 

tests/conftest.py

@@ -19,13 +19,14 @@ from freqtrade.edge import PairInfo
 from freqtrade.enums import RunMode
 from freqtrade.exchange import Exchange
 from freqtrade.freqtradebot import FreqtradeBot
-from freqtrade.persistence import LocalTrade, Trade, init_db
+from freqtrade.persistence import LocalTrade, Order, Trade, init_db
 from freqtrade.resolvers import ExchangeResolver
 from freqtrade.worker import Worker
 from tests.conftest_trades import (mock_trade_1, mock_trade_2, mock_trade_3, mock_trade_4,
                                    mock_trade_5, mock_trade_6)
 from tests.conftest_trades_usdt import (mock_trade_usdt_1, mock_trade_usdt_2, mock_trade_usdt_3,
-                                        mock_trade_usdt_4, mock_trade_usdt_5, mock_trade_usdt_6)
+                                        mock_trade_usdt_4, mock_trade_usdt_5, mock_trade_usdt_6,
+                                        mock_trade_usdt_7)
 
 
 logging.getLogger('').setLevel(logging.INFO)
@@ -106,6 +107,8 @@ def patch_exchange(mocker, api_mock=None, id='binance', mock_markets=True) -> No
         mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
     else:
         mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock())
+        mocker.patch('freqtrade.exchange.Exchange.timeframes', PropertyMock(
+                return_value=['5m', '15m', '1h', '1d']))
 
 
 def get_patched_exchange(mocker, config, api_mock=None, id='binance',
@@ -200,6 +203,9 @@ def create_mock_trades(fee, use_db: bool = True):
     """
     Create some fake trades ...
     """
+    if use_db:
+        Trade.query.session.rollback()
+
     def add_trade(trade):
         if use_db:
             Trade.query.session.add(trade)
@@ -258,6 +264,8 @@ def create_mock_trades_usdt(fee, use_db: bool = True):
     trade = mock_trade_usdt_6(fee)
     add_trade(trade)
 
+    trade = mock_trade_usdt_7(fee)
+    add_trade(trade)
     if use_db:
         Trade.commit()
 
@@ -1011,8 +1019,8 @@ def limit_buy_order_open():
         'type': 'limit',
         'side': 'buy',
         'symbol': 'mocked',
+        'timestamp': arrow.utcnow().int_timestamp * 1000,
         'datetime': arrow.utcnow().isoformat(),
-        'timestamp': arrow.utcnow().int_timestamp,
         'price': 0.00001099,
         'amount': 90.99181073,
         'filled': 0.0,
@@ -1038,6 +1046,7 @@ def market_buy_order():
         'type': 'market',
         'side': 'buy',
         'symbol': 'mocked',
+        'timestamp': arrow.utcnow().int_timestamp * 1000,
         'datetime': arrow.utcnow().isoformat(),
         'price': 0.00004099,
         'amount': 91.99181073,
@@ -1054,6 +1063,7 @@ def market_sell_order():
         'type': 'market',
         'side': 'sell',
         'symbol': 'mocked',
+        'timestamp': arrow.utcnow().int_timestamp * 1000,
         'datetime': arrow.utcnow().isoformat(),
         'price': 0.00004173,
         'amount': 91.99181073,
@@ -1070,7 +1080,8 @@ def limit_buy_order_old():
         'type': 'limit',
         'side': 'buy',
         'symbol': 'mocked',
-        'datetime': str(arrow.utcnow().shift(minutes=-601).datetime),
+        'datetime': arrow.utcnow().shift(minutes=-601).isoformat(),
+        'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp * 1000,
         'price': 0.00001099,
         'amount': 90.99181073,
         'filled': 0.0,
@@ -1086,6 +1097,7 @@ def limit_sell_order_old():
         'type': 'limit',
         'side': 'sell',
         'symbol': 'ETH/BTC',
+        'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp * 1000,
         'datetime': arrow.utcnow().shift(minutes=-601).isoformat(),
         'price': 0.00001099,
         'amount': 90.99181073,
@@ -1102,6 +1114,7 @@ def limit_buy_order_old_partial():
         'type': 'limit',
         'side': 'buy',
         'symbol': 'ETH/BTC',
+        'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp * 1000,
         'datetime': arrow.utcnow().shift(minutes=-601).isoformat(),
         'price': 0.00001099,
         'amount': 90.99181073,
@@ -1131,7 +1144,7 @@ def limit_buy_order_canceled_empty(request):
             'info': {},
             'id': '1234512345',
             'clientOrderId': None,
-            'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp,
+            'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp * 1000,
             'datetime': arrow.utcnow().shift(minutes=-601).isoformat(),
             'lastTradeTimestamp': None,
             'symbol': 'LTC/USDT',
@@ -1152,7 +1165,7 @@ def limit_buy_order_canceled_empty(request):
             'info': {},
             'id': 'AZNPFF-4AC4N-7MKTAT',
             'clientOrderId': None,
-            'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp,
+            'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp * 1000,
             'datetime': arrow.utcnow().shift(minutes=-601).isoformat(),
             'lastTradeTimestamp': None,
             'status': 'canceled',
@@ -1173,7 +1186,7 @@ def limit_buy_order_canceled_empty(request):
             'info': {},
             'id': '1234512345',
             'clientOrderId': 'alb1234123',
-            'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp,
+            'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp * 1000,
             'datetime': arrow.utcnow().shift(minutes=-601).isoformat(),
             'lastTradeTimestamp': None,
             'symbol': 'LTC/USDT',
@@ -1194,7 +1207,7 @@ def limit_buy_order_canceled_empty(request):
             'info': {},
             'id': '1234512345',
             'clientOrderId': 'alb1234123',
-            'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp,
+            'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp * 1000,
             'datetime': arrow.utcnow().shift(minutes=-601).isoformat(),
             'lastTradeTimestamp': None,
             'symbol': 'LTC/USDT',
@@ -1218,9 +1231,9 @@ def limit_sell_order_open():
         'id': 'mocked_limit_sell',
         'type': 'limit',
         'side': 'sell',
-        'pair': 'mocked',
+        'symbol': 'mocked',
         'datetime': arrow.utcnow().isoformat(),
-        'timestamp': arrow.utcnow().int_timestamp,
+        'timestamp': arrow.utcnow().int_timestamp * 1000,
         'price': 0.00001173,
         'amount': 90.99181073,
         'filled': 0.0,
@@ -1386,7 +1399,7 @@ def tickers():
         'BLK/BTC': {
             'symbol': 'BLK/BTC',
             'timestamp': 1522014806072,
-            'datetime': '2018-03-25T21:53:26.720Z',
+            'datetime': '2018-03-25T21:53:26.072Z',
             'high': 0.007745,
             'low': 0.007512,
             'bid': 0.007729,
@@ -1882,7 +1895,8 @@ def buy_order_fee():
         'type': 'limit',
         'side': 'buy',
         'symbol': 'mocked',
-        'datetime': str(arrow.utcnow().shift(minutes=-601).datetime),
+        'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp * 1000,
+        'datetime': arrow.utcnow().shift(minutes=-601).isoformat(),
         'price': 0.245441,
         'amount': 8.0,
         'cost': 1.963528,
@@ -1982,7 +1996,7 @@ def import_fails() -> None:
 
 @pytest.fixture(scope="function")
 def open_trade():
-    return Trade(
+    trade = Trade(
         pair='ETH/BTC',
         open_rate=0.00001099,
         exchange='binance',
@@ -1994,6 +2008,26 @@ def open_trade():
         open_date=arrow.utcnow().shift(minutes=-601).datetime,
         is_open=True
     )
+    trade.orders = [
+        Order(
+            ft_order_side='buy',
+            ft_pair=trade.pair,
+            ft_is_open=False,
+            order_id='123456789',
+            status="closed",
+            symbol=trade.pair,
+            order_type="market",
+            side="buy",
+            price=trade.open_rate,
+            average=trade.open_rate,
+            filled=trade.amount,
+            remaining=0,
+            cost=trade.open_rate * trade.amount,
+            order_date=trade.open_date,
+            order_filled_date=trade.open_date,
+        )
+    ]
+    return trade
 
 
 @pytest.fixture(scope="function")
@@ -2160,7 +2194,7 @@ def limit_buy_order_usdt_open():
         'side': 'buy',
         'symbol': 'mocked',
         'datetime': arrow.utcnow().isoformat(),
-        'timestamp': arrow.utcnow().int_timestamp,
+        'timestamp': arrow.utcnow().int_timestamp * 1000,
         'price': 2.00,
         'amount': 30.0,
         'filled': 0.0,
@@ -2185,9 +2219,9 @@ def limit_sell_order_usdt_open():
         'id': 'mocked_limit_sell_usdt',
         'type': 'limit',
         'side': 'sell',
-        'pair': 'mocked',
+        'symbol': 'mocked',
         'datetime': arrow.utcnow().isoformat(),
-        'timestamp': arrow.utcnow().int_timestamp,
+        'timestamp': arrow.utcnow().int_timestamp * 1000,
         'price': 2.20,
         'amount': 30.0,
         'filled': 0.0,
@@ -2212,6 +2246,7 @@ def market_buy_order_usdt():
         'type': 'market',
         'side': 'buy',
         'symbol': 'mocked',
+        'timestamp': arrow.utcnow().int_timestamp * 1000,
         'datetime': arrow.utcnow().isoformat(),
         'price': 2.00,
         'amount': 30.0,
@@ -2268,6 +2303,7 @@ def market_sell_order_usdt():
         'type': 'market',
         'side': 'sell',
         'symbol': 'mocked',
+        'timestamp': arrow.utcnow().int_timestamp * 1000,
         'datetime': arrow.utcnow().isoformat(),
         'price': 2.20,
         'amount': 30.0,

tests/conftest_trades.py

@@ -14,6 +14,7 @@ def mock_order_1():
         'side': 'buy',
         'type': 'limit',
         'price': 0.123,
+        'average': 0.123,
         'amount': 123.0,
         'filled': 123.0,
         'remaining': 0.0,

tests/conftest_trades_usdt.py

@@ -303,3 +303,61 @@ def mock_trade_usdt_6(fee):
     o = Order.parse_from_ccxt_object(mock_order_usdt_6_sell(), 'LTC/USDT', 'sell')
     trade.orders.append(o)
     return trade
+
+
+def mock_order_usdt_7():
+    return {
+        'id': 'prod_buy_7',
+        'symbol': 'LTC/USDT',
+        'status': 'closed',
+        'side': 'buy',
+        'type': 'limit',
+        'price': 10.0,
+        'amount': 2.0,
+        'filled': 2.0,
+        'remaining': 0.0,
+    }
+
+
+def mock_order_usdt_7_sell():
+    return {
+        'id': 'prod_sell_7',
+        'symbol': 'LTC/USDT',
+        'status': 'closed',
+        'side': 'sell',
+        'type': 'limit',
+        'price': 8.0,
+        'amount': 2.0,
+        'filled': 2.0,
+        'remaining': 0.0,
+    }
+
+
+def mock_trade_usdt_7(fee):
+    """
+    Simulate prod entry with open sell order
+    """
+    trade = Trade(
+        pair='LTC/USDT',
+        stake_amount=20.0,
+        amount=2.0,
+        amount_requested=2.0,
+        open_date=datetime.now(tz=timezone.utc) - timedelta(minutes=20),
+        close_date=datetime.now(tz=timezone.utc) - timedelta(minutes=5),
+        fee_open=fee.return_value,
+        fee_close=fee.return_value,
+        is_open=False,
+        open_rate=10.0,
+        close_rate=8.0,
+        close_profit=-0.2,
+        close_profit_abs=-4.0,
+        exchange='binance',
+        strategy='SampleStrategy',
+        open_order_id="prod_sell_6",
+        timeframe=5,
+    )
+    o = Order.parse_from_ccxt_object(mock_order_usdt_7(), 'LTC/USDT', 'buy')
+    trade.orders.append(o)
+    o = Order.parse_from_ccxt_object(mock_order_usdt_7_sell(), 'LTC/USDT', 'sell')
+    trade.orders.append(o)
+    return trade

tests/exchange/test_ccxt_compat.py

@@ -53,7 +53,13 @@ EXCHANGES = {
         'hasQuoteVolume': True,
         'timeframe': '5m',
     },
-    'okex': {
+    'okx': {
+        'pair': 'BTC/USDT',
+        'stake_currency': 'USDT',
+        'hasQuoteVolume': True,
+        'timeframe': '5m',
+    },
+    'huobi': {
         'pair': 'BTC/USDT',
         'stake_currency': 'USDT',
         'hasQuoteVolume': True,
@@ -140,7 +146,10 @@ class TestCCXTExchange():
             else:
                 next_limit = exchange.get_next_limit_in_list(
                     val, l2_limit_range, l2_limit_range_required)
-                if next_limit is None or next_limit > 200:
+                if next_limit is None:
+                    assert len(l2['asks']) > 100
+                    assert len(l2['asks']) > 100
+                elif next_limit > 200:
                     # Large orderbook sizes can be a problem for some exchanges (bitrex ...)
                     assert len(l2['asks']) > 200
                     assert len(l2['asks']) > 200

tests/exchange/test_exchange.py

@@ -166,7 +166,7 @@ def test_exchange_resolver(default_conf, mocker, caplog):
     mocker.patch('freqtrade.exchange.Exchange.validate_timeframes')
     mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
 
-    exchange = ExchangeResolver.load_exchange('huobi', default_conf)
+    exchange = ExchangeResolver.load_exchange('zaif', default_conf)
     assert isinstance(exchange, Exchange)
     assert log_has_re(r"No .* specific subclass found. Using the generic class instead.", caplog)
     caplog.clear()
@@ -1692,6 +1692,13 @@ def test_refresh_latest_ohlcv(mocker, default_conf, caplog) -> None:
                                         cache=False)
     assert len(res) == 3
     assert exchange._api_async.fetch_ohlcv.call_count == 3
+    exchange._api_async.fetch_ohlcv.reset_mock()
+    caplog.clear()
+    # Call with invalid timeframe
+    res = exchange.refresh_latest_ohlcv([('IOTA/ETH', '3m')], cache=False)
+    assert not res
+    assert len(res) == 0
+    assert log_has_re(r'Cannot download \(IOTA\/ETH, 3m\).*', caplog)
 
 
 @pytest.mark.asyncio

tests/exchange/test_ftx.py

@@ -125,7 +125,7 @@ def test_stoploss_adjust_ftx(mocker, default_conf):
     assert not exchange.stoploss_adjust(1501, order)
 
 
-def test_fetch_stoploss_order(default_conf, mocker, limit_sell_order):
+def test_fetch_stoploss_order_ftx(default_conf, mocker, limit_sell_order):
     default_conf['dry_run'] = True
     order = MagicMock()
     order.myid = 123
@@ -147,9 +147,15 @@ def test_fetch_stoploss_order(default_conf, mocker, limit_sell_order):
     with pytest.raises(InvalidOrderException, match=r"Could not get stoploss order for id X"):
         exchange.fetch_stoploss_order('X', 'TKN/BTC')['status']
 
-    api_mock.fetch_orders = MagicMock(return_value=[{'id': 'X', 'status': 'closed'}])
+    # stoploss Limit order
+    api_mock.fetch_orders = MagicMock(return_value=[
+        {'id': 'X', 'status': 'closed',
+         'info': {
+             'orderId': 'mocked_limit_sell',
+         }}])
     api_mock.fetch_order = MagicMock(return_value=limit_sell_order)
 
+    # No orderId field - no call to fetch_order
     resp = exchange.fetch_stoploss_order('X', 'TKN/BTC')
     assert resp
     assert api_mock.fetch_order.call_count == 1
@@ -158,6 +164,17 @@ def test_fetch_stoploss_order(default_conf, mocker, limit_sell_order):
     assert resp['type'] == 'stop'
     assert resp['status_stop'] == 'triggered'
 
+    # Stoploss market order
+    # Contains no new Order, but "average" instead
+    order = {'id': 'X', 'status': 'closed', 'info': {'orderId': None}, 'average': 0.254}
+    api_mock.fetch_orders = MagicMock(return_value=[order])
+    api_mock.fetch_order.reset_mock()
+    resp = exchange.fetch_stoploss_order('X', 'TKN/BTC')
+    assert resp
+    # fetch_order not called (no regular order ID)
+    assert api_mock.fetch_order.call_count == 0
+    assert order == order
+
     with pytest.raises(InvalidOrderException):
         api_mock.fetch_orders = MagicMock(side_effect=ccxt.InvalidOrder("Order not found"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id='ftx')

tests/exchange/test_gateio.py

@@ -1,8 +1,11 @@
+from unittest.mock import MagicMock
+
 import pytest
 
 from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import Gateio
 from freqtrade.resolvers.exchange_resolver import ExchangeResolver
+from tests.conftest import get_patched_exchange
 
 
 def test_validate_order_types_gateio(default_conf, mocker):
@@ -26,3 +29,39 @@ def test_validate_order_types_gateio(default_conf, mocker):
     with pytest.raises(OperationalException,
                        match=r'Exchange .* does not support market orders.'):
         ExchangeResolver.load_exchange('gateio', default_conf, True)
+
+
+def test_fetch_stoploss_order_gateio(default_conf, mocker):
+    exchange = get_patched_exchange(mocker, default_conf, id='gateio')
+
+    fetch_order_mock = MagicMock()
+    exchange.fetch_order = fetch_order_mock
+
+    exchange.fetch_stoploss_order('1234', 'ETH/BTC')
+    assert fetch_order_mock.call_count == 1
+    assert fetch_order_mock.call_args_list[0][1]['order_id'] == '1234'
+    assert fetch_order_mock.call_args_list[0][1]['pair'] == 'ETH/BTC'
+    assert fetch_order_mock.call_args_list[0][1]['params'] == {'stop': True}
+
+
+def test_cancel_stoploss_order_gateio(default_conf, mocker):
+    exchange = get_patched_exchange(mocker, default_conf, id='gateio')
+
+    cancel_order_mock = MagicMock()
+    exchange.cancel_order = cancel_order_mock
+
+    exchange.cancel_stoploss_order('1234', 'ETH/BTC')
+    assert cancel_order_mock.call_count == 1
+    assert cancel_order_mock.call_args_list[0][1]['order_id'] == '1234'
+    assert cancel_order_mock.call_args_list[0][1]['pair'] == 'ETH/BTC'
+    assert cancel_order_mock.call_args_list[0][1]['params'] == {'stop': True}
+
+
+def test_stoploss_adjust_gateio(mocker, default_conf):
+    exchange = get_patched_exchange(mocker, default_conf, id='gateio')
+    order = {
+        'price': 1500,
+        'stopPrice': 1500,
+    }
+    assert exchange.stoploss_adjust(1501, order)
+    assert not exchange.stoploss_adjust(1499, order)

tests/exchange/test_huobi.py

@@ -0,0 +1,109 @@
+from random import randint
+from unittest.mock import MagicMock
+
+import ccxt
+import pytest
+
+from freqtrade.exceptions import DependencyException, InvalidOrderException, OperationalException
+from tests.conftest import get_patched_exchange
+from tests.exchange.test_exchange import ccxt_exceptionhandlers
+
+
+@pytest.mark.parametrize('limitratio,expected', [
+    (None, 220 * 0.99),
+    (0.99, 220 * 0.99),
+    (0.98, 220 * 0.98),
+])
+def test_stoploss_order_huobi(default_conf, mocker, limitratio, expected):
+    api_mock = MagicMock()
+    order_id = 'test_prod_buy_{}'.format(randint(0, 10 ** 6))
+    order_type = 'stop-limit'
+
+    api_mock.create_order = MagicMock(return_value={
+        'id': order_id,
+        'info': {
+            'foo': 'bar'
+        }
+    })
+    default_conf['dry_run'] = False
+    mocker.patch('freqtrade.exchange.Exchange.amount_to_precision', lambda s, x, y: y)
+    mocker.patch('freqtrade.exchange.Exchange.price_to_precision', lambda s, x, y: y)
+
+    exchange = get_patched_exchange(mocker, default_conf, api_mock, 'huobi')
+
+    with pytest.raises(OperationalException):
+        order = exchange.stoploss(pair='ETH/BTC', amount=1, stop_price=190,
+                                  order_types={'stoploss_on_exchange_limit_ratio': 1.05})
+
+    api_mock.create_order.reset_mock()
+    order_types = {} if limitratio is None else {'stoploss_on_exchange_limit_ratio': limitratio}
+    order = exchange.stoploss(pair='ETH/BTC', amount=1, stop_price=220, order_types=order_types)
+
+    assert 'id' in order
+    assert 'info' in order
+    assert order['id'] == order_id
+    assert api_mock.create_order.call_args_list[0][1]['symbol'] == 'ETH/BTC'
+    assert api_mock.create_order.call_args_list[0][1]['type'] == order_type
+    assert api_mock.create_order.call_args_list[0][1]['side'] == 'sell'
+    assert api_mock.create_order.call_args_list[0][1]['amount'] == 1
+    # Price should be 1% below stopprice
+    assert api_mock.create_order.call_args_list[0][1]['price'] == expected
+    assert api_mock.create_order.call_args_list[0][1]['params'] == {"stopPrice": 220,
+                                                                    "operator": "lte",
+                                                                    }
+
+    # test exception handling
+    with pytest.raises(DependencyException):
+        api_mock.create_order = MagicMock(side_effect=ccxt.InsufficientFunds("0 balance"))
+        exchange = get_patched_exchange(mocker, default_conf, api_mock, 'huobi')
+        exchange.stoploss(pair='ETH/BTC', amount=1, stop_price=220, order_types={})
+
+    with pytest.raises(InvalidOrderException):
+        api_mock.create_order = MagicMock(
+            side_effect=ccxt.InvalidOrder("binance Order would trigger immediately."))
+        exchange = get_patched_exchange(mocker, default_conf, api_mock, 'binance')
+        exchange.stoploss(pair='ETH/BTC', amount=1, stop_price=220, order_types={})
+
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock, "huobi",
+                           "stoploss", "create_order", retries=1,
+                           pair='ETH/BTC', amount=1, stop_price=220, order_types={})
+
+
+def test_stoploss_order_dry_run_huobi(default_conf, mocker):
+    api_mock = MagicMock()
+    order_type = 'stop-limit'
+    default_conf['dry_run'] = True
+    mocker.patch('freqtrade.exchange.Exchange.amount_to_precision', lambda s, x, y: y)
+    mocker.patch('freqtrade.exchange.Exchange.price_to_precision', lambda s, x, y: y)
+
+    exchange = get_patched_exchange(mocker, default_conf, api_mock, 'huobi')
+
+    with pytest.raises(OperationalException):
+        order = exchange.stoploss(pair='ETH/BTC', amount=1, stop_price=190,
+                                  order_types={'stoploss_on_exchange_limit_ratio': 1.05})
+
+    api_mock.create_order.reset_mock()
+
+    order = exchange.stoploss(pair='ETH/BTC', amount=1, stop_price=220, order_types={})
+
+    assert 'id' in order
+    assert 'info' in order
+    assert 'type' in order
+
+    assert order['type'] == order_type
+    assert order['price'] == 220
+    assert order['amount'] == 1
+
+
+def test_stoploss_adjust_huobi(mocker, default_conf):
+    exchange = get_patched_exchange(mocker, default_conf, id='huobi')
+    order = {
+        'type': 'stop',
+        'price': 1500,
+        'stopPrice': '1500',
+    }
+    assert exchange.stoploss_adjust(1501, order)
+    assert not exchange.stoploss_adjust(1499, order)
+    # Test with invalid order case
+    order['type'] = 'stop_loss'
+    assert not exchange.stoploss_adjust(1501, order)

tests/exchange/test_kucoin.py

@@ -0,0 +1,120 @@
+from random import randint
+from unittest.mock import MagicMock
+
+import ccxt
+import pytest
+
+from freqtrade.exceptions import DependencyException, InvalidOrderException, OperationalException
+from tests.conftest import get_patched_exchange
+from tests.exchange.test_exchange import ccxt_exceptionhandlers
+
+
+@pytest.mark.parametrize('order_type', ['market', 'limit'])
+@pytest.mark.parametrize('limitratio,expected', [
+    (None, 220 * 0.99),
+    (0.99, 220 * 0.99),
+    (0.98, 220 * 0.98),
+])
+def test_stoploss_order_kucoin(default_conf, mocker, limitratio, expected, order_type):
+    api_mock = MagicMock()
+    order_id = 'test_prod_buy_{}'.format(randint(0, 10 ** 6))
+
+    api_mock.create_order = MagicMock(return_value={
+        'id': order_id,
+        'info': {
+            'foo': 'bar'
+        }
+    })
+    default_conf['dry_run'] = False
+    mocker.patch('freqtrade.exchange.Exchange.amount_to_precision', lambda s, x, y: y)
+    mocker.patch('freqtrade.exchange.Exchange.price_to_precision', lambda s, x, y: y)
+
+    exchange = get_patched_exchange(mocker, default_conf, api_mock, 'kucoin')
+    if order_type == 'limit':
+        with pytest.raises(OperationalException):
+            order = exchange.stoploss(pair='ETH/BTC', amount=1, stop_price=190,
+                                      order_types={
+                                          'stoploss': order_type,
+                                          'stoploss_on_exchange_limit_ratio': 1.05})
+
+    api_mock.create_order.reset_mock()
+    order_types = {'stoploss': order_type}
+    if limitratio is not None:
+        order_types.update({'stoploss_on_exchange_limit_ratio': limitratio})
+    order = exchange.stoploss(pair='ETH/BTC', amount=1, stop_price=220, order_types=order_types)
+
+    assert 'id' in order
+    assert 'info' in order
+    assert order['id'] == order_id
+    assert api_mock.create_order.call_args_list[0][1]['symbol'] == 'ETH/BTC'
+    assert api_mock.create_order.call_args_list[0][1]['type'] == order_type
+    assert api_mock.create_order.call_args_list[0][1]['side'] == 'sell'
+    assert api_mock.create_order.call_args_list[0][1]['amount'] == 1
+    # Price should be 1% below stopprice
+    if order_type == 'limit':
+        assert api_mock.create_order.call_args_list[0][1]['price'] == expected
+    else:
+        assert api_mock.create_order.call_args_list[0][1]['price'] is None
+
+    assert api_mock.create_order.call_args_list[0][1]['params'] == {
+        'stopPrice': 220,
+        'stop': 'loss'
+    }
+
+    # test exception handling
+    with pytest.raises(DependencyException):
+        api_mock.create_order = MagicMock(side_effect=ccxt.InsufficientFunds("0 balance"))
+        exchange = get_patched_exchange(mocker, default_conf, api_mock, 'kucoin')
+        exchange.stoploss(pair='ETH/BTC', amount=1, stop_price=220, order_types={})
+
+    with pytest.raises(InvalidOrderException):
+        api_mock.create_order = MagicMock(
+            side_effect=ccxt.InvalidOrder("kucoin Order would trigger immediately."))
+        exchange = get_patched_exchange(mocker, default_conf, api_mock, 'kucoin')
+        exchange.stoploss(pair='ETH/BTC', amount=1, stop_price=220, order_types={})
+
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock, "kucoin",
+                           "stoploss", "create_order", retries=1,
+                           pair='ETH/BTC', amount=1, stop_price=220, order_types={})
+
+
+def test_stoploss_order_dry_run_kucoin(default_conf, mocker):
+    api_mock = MagicMock()
+    order_type = 'market'
+    default_conf['dry_run'] = True
+    mocker.patch('freqtrade.exchange.Exchange.amount_to_precision', lambda s, x, y: y)
+    mocker.patch('freqtrade.exchange.Exchange.price_to_precision', lambda s, x, y: y)
+
+    exchange = get_patched_exchange(mocker, default_conf, api_mock, 'kucoin')
+
+    with pytest.raises(OperationalException):
+        order = exchange.stoploss(pair='ETH/BTC', amount=1, stop_price=190,
+                                  order_types={'stoploss': 'limit',
+                                               'stoploss_on_exchange_limit_ratio': 1.05})
+
+    api_mock.create_order.reset_mock()
+
+    order = exchange.stoploss(pair='ETH/BTC', amount=1, stop_price=220, order_types={})
+
+    assert 'id' in order
+    assert 'info' in order
+    assert 'type' in order
+
+    assert order['type'] == order_type
+    assert order['price'] == 220
+    assert order['amount'] == 1
+
+
+def test_stoploss_adjust_kucoin(mocker, default_conf):
+    exchange = get_patched_exchange(mocker, default_conf, id='kucoin')
+    order = {
+        'type': 'limit',
+        'price': 1500,
+        'stopPrice': 1500,
+        'info': {'stopPrice': 1500, 'stop': "limit"},
+    }
+    assert exchange.stoploss_adjust(1501, order)
+    assert not exchange.stoploss_adjust(1499, order)
+    # Test with invalid order case
+    order['info']['stop'] = None
+    assert not exchange.stoploss_adjust(1501, order)

tests/optimize/__init__.py

@@ -36,6 +36,8 @@ class BTContainer(NamedTuple):
     trailing_stop_positive_offset: float = 0.0
     use_sell_signal: bool = False
     use_custom_stoploss: bool = False
+    custom_entry_price: Optional[float] = None
+    custom_exit_price: Optional[float] = None
 
 
 def _get_frame_time_from_offset(offset):

tests/optimize/test_backtest_detail.py

@@ -1,5 +1,6 @@
 # pragma pylint: disable=missing-docstring, W0212, line-too-long, C0103, C0330, unused-argument
 import logging
+from unittest.mock import MagicMock
 
 import pytest
 
@@ -534,6 +535,94 @@ tc33 = BTContainer(data=[
     )]
 )
 
+# Test 34: Custom-entry-price below all candles should timeout - so no trade happens.
+tc34 = BTContainer(data=[
+    # D   O     H     L     C    V    B  S
+    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
+    [1, 5000, 5500, 4951, 5000, 6172, 0, 0],    # timeout
+    [2, 4900, 5250, 4500, 5100, 6172, 0, 0],
+    [3, 5100, 5100, 4650, 4750, 6172, 0, 0],
+    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
+    stop_loss=-0.01, roi={"0": 0.10}, profit_perc=0.0,
+    custom_entry_price=4200, trades=[]
+)
+
+# Test 35: Custom-entry-price above all candles should have rate adjusted to "entry candle high"
+tc35 = BTContainer(data=[
+    # D   O     H     L     C    V    B  S
+    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
+    [1, 5000, 5500, 4951, 5000, 6172, 0, 0],    # Timeout
+    [2, 4900, 5250, 4500, 5100, 6172, 0, 0],
+    [3, 5100, 5100, 4650, 4750, 6172, 0, 0],
+    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
+    stop_loss=-0.01, roi={"0": 0.10}, profit_perc=-0.01,
+    custom_entry_price=7200, trades=[
+        BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=1)
+    ]
+)
+
+# Test 36: Custom-entry-price around candle low
+# Would cause immediate ROI exit, but since the trade was entered
+# below open, we treat this as cheating, and delay the sell by 1 candle.
+# details: https://github.com/freqtrade/freqtrade/issues/6261
+tc36 = BTContainer(data=[
+    # D   O     H     L     C    V    B  S   BT
+    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
+    [1, 5000, 5500, 4951, 4999, 6172, 0, 0],    # Enter and immediate ROI
+    [2, 4900, 5250, 4500, 5100, 6172, 0, 0],
+    [3, 5100, 5100, 4650, 4750, 6172, 0, 0],
+    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
+    stop_loss=-0.10, roi={"0": 0.01}, profit_perc=0.01,
+    custom_entry_price=4952,
+    trades=[BTrade(sell_reason=SellType.ROI, open_tick=1, close_tick=2)]
+)
+
+# Test 37: Custom-entry-price around candle low
+# Would cause immediate ROI exit below close
+# details: https://github.com/freqtrade/freqtrade/issues/6261
+tc37 = BTContainer(data=[
+    # D   O     H     L     C    V    B  S   BT
+    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
+    [1, 5400, 5500, 4951, 5100, 6172, 0, 0],    # Enter and immediate ROI
+    [2, 4900, 5250, 4500, 5100, 6172, 0, 0],
+    [3, 5100, 5100, 4650, 4750, 6172, 0, 0],
+    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
+    stop_loss=-0.10, roi={"0": 0.01}, profit_perc=0.01,
+    custom_entry_price=4952,
+    trades=[BTrade(sell_reason=SellType.ROI, open_tick=1, close_tick=1)]
+)
+
+# Test 38: Custom exit price below all candles
+# Price adjusted to candle Low.
+tc38 = BTContainer(data=[
+    # D   O     H     L     C    V    B  S   BT
+    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
+    [1, 5000, 5500, 4951, 5000, 6172, 0, 0],
+    [2, 4900, 5250, 4900, 5100, 6172, 0, 1],  # exit - but timeout
+    [3, 5100, 5100, 4950, 4950, 6172, 0, 0],
+    [4, 5000, 5100, 4950, 4950, 6172, 0, 0]],
+    stop_loss=-0.10, roi={"0": 0.10}, profit_perc=-0.01,
+    use_sell_signal=True,
+    custom_exit_price=4552,
+    trades=[BTrade(sell_reason=SellType.SELL_SIGNAL, open_tick=1, close_tick=3)]
+)
+
+# Test 39: Custom exit price above all candles
+# causes sell signal timeout
+tc39 = BTContainer(data=[
+    # D   O     H     L     C    V    B  S   BT
+    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
+    [1, 5000, 5500, 4951, 5000, 6172, 0, 0],
+    [2, 4900, 5250, 4900, 5100, 6172, 0, 1],  # exit - but timeout
+    [3, 5100, 5100, 4950, 4950, 6172, 0, 0],
+    [4, 5000, 5100, 4950, 4950, 6172, 0, 0]],
+    stop_loss=-0.10, roi={"0": 0.10}, profit_perc=0.0,
+    use_sell_signal=True,
+    custom_exit_price=6052,
+    trades=[BTrade(sell_reason=SellType.FORCE_SELL, open_tick=1, close_tick=4)]
+)
+
+
 TESTS = [
     tc0,
     tc1,
@@ -569,6 +658,12 @@ TESTS = [
     tc31,
     tc32,
     tc33,
+    tc34,
+    tc35,
+    tc36,
+    tc37,
+    tc38,
+    tc39,
 ]
 
 
@@ -597,6 +692,10 @@ def test_backtest_results(default_conf, fee, mocker, caplog, data) -> None:
     backtesting.required_startup = 0
     backtesting.strategy.advise_buy = lambda a, m: frame
     backtesting.strategy.advise_sell = lambda a, m: frame
+    if data.custom_entry_price:
+        backtesting.strategy.custom_entry_price = MagicMock(return_value=data.custom_entry_price)
+    if data.custom_exit_price:
+        backtesting.strategy.custom_exit_price = MagicMock(return_value=data.custom_exit_price)
     backtesting.strategy.use_custom_stoploss = data.use_custom_stoploss
     caplog.set_level(logging.DEBUG)
 

tests/optimize/test_backtesting.py

@@ -21,6 +21,7 @@ from freqtrade.data.dataprovider import DataProvider
 from freqtrade.data.history import get_timerange
 from freqtrade.enums import RunMode, SellType
 from freqtrade.exceptions import DependencyException, OperationalException
+from freqtrade.exchange.exchange import timeframe_to_next_date
 from freqtrade.misc import get_strategy_run_id
 from freqtrade.optimize.backtesting import Backtesting
 from freqtrade.persistence import LocalTrade
@@ -51,6 +52,13 @@ def trim_dictlist(dict_list, num):
     return new
 
 
+@pytest.fixture(autouse=True)
+def backtesting_cleanup() -> None:
+    yield None
+
+    Backtesting.cleanup()
+
+
 def load_data_test(what, testdatadir):
     timerange = TimeRange.parse_timerange('1510694220-1510700340')
     data = history.load_pair_history(pair='UNITTEST/BTC', datadir=testdatadir,
@@ -306,16 +314,15 @@ def test_backtesting_init_no_timeframe(mocker, default_conf, caplog) -> None:
     patch_exchange(mocker)
     del default_conf['timeframe']
     default_conf['strategy_list'] = ['StrategyTestV2',
-                                     'SampleStrategy']
+                                     'HyperoptableStrategy']
 
     mocker.patch('freqtrade.exchange.Exchange.get_fee', MagicMock(return_value=0.5))
-    with pytest.raises(OperationalException):
+    with pytest.raises(OperationalException,
+                       match=r"Timeframe needs to be set in either configuration"):
         Backtesting(default_conf)
-    log_has("Ticker-interval needs to be set in either configuration "
-            "or as cli argument `--ticker-interval 5m`", caplog)
 
 
-def test_data_with_fee(default_conf, mocker, testdatadir) -> None:
+def test_data_with_fee(default_conf, mocker) -> None:
     patch_exchange(mocker)
     default_conf['fee'] = 0.1234
 
@@ -520,6 +527,7 @@ def test_backtest__enter_trade(default_conf, fee, mocker) -> None:
     # Fake 2 trades, so there's not enough amount for the next trade left.
     LocalTrade.trades_open.append(trade)
     LocalTrade.trades_open.append(trade)
+    backtesting.wallets.update()
     trade = backtesting._enter_trade(pair, row=row)
     assert trade is None
     LocalTrade.trades_open.pop()
@@ -527,6 +535,7 @@ def test_backtest__enter_trade(default_conf, fee, mocker) -> None:
     assert trade is not None
 
     backtesting.strategy.custom_stake_amount = lambda **kwargs: 123.5
+    backtesting.wallets.update()
     trade = backtesting._enter_trade(pair, row=row)
     assert trade
     assert trade.stake_amount == 123.5
@@ -550,8 +559,6 @@ def test_backtest__enter_trade(default_conf, fee, mocker) -> None:
     trade = backtesting._enter_trade(pair, row=row)
     assert trade is None
 
-    backtesting.cleanup()
-
 
 def test_backtest__get_sell_trade_entry(default_conf, fee, mocker) -> None:
     default_conf['use_sell_signal'] = False
@@ -634,7 +641,8 @@ def test_backtest__get_sell_trade_entry(default_conf, fee, mocker) -> None:
     assert res.sell_reason == SellType.ROI.value
     # Sell at minute 3 (not available above!)
     assert res.close_date_utc == datetime(2020, 1, 1, 5, 3, tzinfo=timezone.utc)
-    assert round(res.close_rate, 3) == round(209.0225, 3)
+    sell_order = res.select_order('sell', True)
+    assert sell_order is not None
 
 
 def test_backtest_one(default_conf, fee, mocker, testdatadir) -> None:
@@ -650,6 +658,7 @@ def test_backtest_one(default_conf, fee, mocker, testdatadir) -> None:
                              timerange=timerange)
     processed = backtesting.strategy.advise_all_indicators(data)
     min_date, max_date = get_timerange(processed)
+
     result = backtesting.backtest(
         processed=deepcopy(processed),
         start_date=min_date,
@@ -741,6 +750,46 @@ def test_processed(default_conf, mocker, testdatadir) -> None:
         assert col in cols
 
 
+def test_backtest_dataprovider_analyzed_df(default_conf, fee, mocker, testdatadir) -> None:
+    default_conf['use_sell_signal'] = False
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    mocker.patch("freqtrade.exchange.Exchange.get_min_pair_stake_amount", return_value=0.00001)
+    patch_exchange(mocker)
+    backtesting = Backtesting(default_conf)
+    backtesting._set_strategy(backtesting.strategylist[0])
+    timerange = TimeRange('date', None, 1517227800, 0)
+    data = history.load_data(datadir=testdatadir, timeframe='5m', pairs=['UNITTEST/BTC'],
+                             timerange=timerange)
+    processed = backtesting.strategy.advise_all_indicators(data)
+    min_date, max_date = get_timerange(processed)
+
+    global count
+    count = 0
+
+    def tmp_confirm_entry(pair, current_time, **kwargs):
+        dp = backtesting.strategy.dp
+        df, _ = dp.get_analyzed_dataframe(pair, backtesting.strategy.timeframe)
+        current_candle = df.iloc[-1].squeeze()
+        assert current_candle['buy'] == 1
+
+        candle_date = timeframe_to_next_date(backtesting.strategy.timeframe, current_candle['date'])
+        assert candle_date == current_time
+        # These asserts don't properly raise as they are nested,
+        # therefore we increment count and assert for that.
+        global count
+        count = count + 1
+
+    backtesting.strategy.confirm_trade_entry = tmp_confirm_entry
+    backtesting.backtest(
+        processed=deepcopy(processed),
+        start_date=min_date,
+        end_date=max_date,
+        max_open_trades=10,
+        position_stacking=False,
+    )
+    assert count == 5
+
+
 def test_backtest_pricecontours_protections(default_conf, fee, mocker, testdatadir) -> None:
     # While this test IS a copy of test_backtest_pricecontours, it's needed to ensure
     # results do not carry-over to the next run, which is not given by using parametrize.
@@ -978,6 +1027,8 @@ def test_backtest_start_multi_strat(default_conf, mocker, caplog, testdatadir):
         'config': default_conf,
         'locks': [],
         'rejected_signals': 20,
+        'timedout_entry_orders': 0,
+        'timedout_exit_orders': 0,
         'final_balance': 1000,
     })
     mocker.patch('freqtrade.plugins.pairlistmanager.PairListManager.whitelist',
@@ -1086,6 +1137,8 @@ def test_backtest_start_multi_strat_nomock(default_conf, mocker, caplog, testdat
             'config': default_conf,
             'locks': [],
             'rejected_signals': 20,
+            'timedout_entry_orders': 0,
+            'timedout_exit_orders': 0,
             'final_balance': 1000,
         },
         {
@@ -1093,6 +1146,8 @@ def test_backtest_start_multi_strat_nomock(default_conf, mocker, caplog, testdat
             'config': default_conf,
             'locks': [],
             'rejected_signals': 20,
+            'timedout_entry_orders': 0,
+            'timedout_exit_orders': 0,
             'final_balance': 1000,
         }
     ])
@@ -1195,6 +1250,8 @@ def test_backtest_start_multi_strat_nomock_detail(default_conf, mocker,
             'config': default_conf,
             'locks': [],
             'rejected_signals': 20,
+            'timedout_entry_orders': 0,
+            'timedout_exit_orders': 0,
             'final_balance': 1000,
         },
         {
@@ -1202,6 +1259,8 @@ def test_backtest_start_multi_strat_nomock_detail(default_conf, mocker,
             'config': default_conf,
             'locks': [],
             'rejected_signals': 20,
+            'timedout_entry_orders': 0,
+            'timedout_exit_orders': 0,
             'final_balance': 1000,
         }
     ])
@@ -1263,6 +1322,8 @@ def test_backtest_start_multi_strat_caching(default_conf, mocker, caplog, testda
         'config': default_conf,
         'locks': [],
         'rejected_signals': 20,
+        'timedout_entry_orders': 0,
+        'timedout_exit_orders': 0,
         'final_balance': 1000,
     })
     mocker.patch('freqtrade.plugins.pairlistmanager.PairListManager.whitelist',

tests/optimize/test_edge_cli.py

@@ -6,8 +6,7 @@ from unittest.mock import MagicMock
 from freqtrade.commands.optimize_commands import setup_optimize_configuration, start_edge
 from freqtrade.enums import RunMode
 from freqtrade.optimize.edge_cli import EdgeCli
-from tests.conftest import (get_args, log_has, log_has_re, patch_exchange,
-                            patched_configuration_load_config_file)
+from tests.conftest import get_args, log_has, patch_exchange, patched_configuration_load_config_file
 
 
 def test_setup_optimize_configuration_without_arguments(mocker, default_conf, caplog) -> None:
@@ -30,7 +29,6 @@ def test_setup_optimize_configuration_without_arguments(mocker, default_conf, ca
     assert 'datadir' in config
     assert log_has('Using data directory: {} ...'.format(config['datadir']), caplog)
     assert 'timeframe' in config
-    assert not log_has_re('Parameter -i/--ticker-interval detected .*', caplog)
 
     assert 'timerange' not in config
     assert 'stoploss_range' not in config

tests/optimize/test_hyperopt.py

@@ -63,7 +63,6 @@ def test_setup_hyperopt_configuration_without_arguments(mocker, default_conf, ca
     assert 'datadir' in config
     assert log_has('Using data directory: {} ...'.format(config['datadir']), caplog)
     assert 'timeframe' in config
-    assert not log_has_re('Parameter -i/--ticker-interval detected .*', caplog)
 
     assert 'position_stacking' not in config
     assert not log_has('Parameter --enable-position-stacking detected ...', caplog)
@@ -364,6 +363,8 @@ def test_hyperopt_format_results(hyperopt):
         'locks': [],
         'final_balance': 0.02,
         'rejected_signals': 2,
+        'timedout_entry_orders': 0,
+        'timedout_exit_orders': 0,
         'backtest_start_time': 1619718665,
         'backtest_end_time': 1619718665,
     }
@@ -431,6 +432,8 @@ def test_generate_optimizer(mocker, hyperopt_conf) -> None:
         'config': hyperopt_conf,
         'locks': [],
         'rejected_signals': 20,
+        'timedout_entry_orders': 0,
+        'timedout_exit_orders': 0,
         'final_balance': 1000,
     }
 

tests/optimize/test_hyperoptloss.py

@@ -86,6 +86,7 @@ def test_loss_calculation_has_limited_profit(hyperopt_conf, hyperopt_results) ->
     "SharpeHyperOptLossDaily",
     "MaxDrawDownHyperOptLoss",
     "CalmarHyperOptLoss",
+    "ProfitDrawDownHyperOptLoss",
 
 ])
 def test_loss_functions_better_profits(default_conf, hyperopt_results, lossfunction) -> None:

tests/optimize/test_optimize_reports.py

@@ -82,6 +82,8 @@ def test_generate_backtest_stats(default_conf, testdatadir, tmpdir):
         'locks': [],
         'final_balance': 1000.02,
         'rejected_signals': 20,
+        'timedout_entry_orders': 0,
+        'timedout_exit_orders': 0,
         'backtest_start_time': Arrow.utcnow().int_timestamp,
         'backtest_end_time': Arrow.utcnow().int_timestamp,
         'run_id': '123',
@@ -131,6 +133,8 @@ def test_generate_backtest_stats(default_conf, testdatadir, tmpdir):
         'locks': [],
         'final_balance': 1000.02,
         'rejected_signals': 20,
+        'timedout_entry_orders': 0,
+        'timedout_exit_orders': 0,
         'backtest_start_time': Arrow.utcnow().int_timestamp,
         'backtest_end_time': Arrow.utcnow().int_timestamp,
         'run_id': '124',

tests/plugins/test_pairlist.py

@@ -15,7 +15,7 @@ from freqtrade.persistence import Trade
 from freqtrade.plugins.pairlist.pairlist_helpers import expand_pairlist
 from freqtrade.plugins.pairlistmanager import PairListManager
 from freqtrade.resolvers import PairListResolver
-from tests.conftest import (create_mock_trades, get_patched_exchange, get_patched_freqtradebot,
+from tests.conftest import (create_mock_trades_usdt, get_patched_exchange, get_patched_freqtradebot,
                             log_has, log_has_re, num_log_has)
 
 
@@ -715,29 +715,58 @@ def test_ShuffleFilter_init(mocker, whitelist_conf, caplog) -> None:
 
 
 @pytest.mark.usefixtures("init_persistence")
-def test_PerformanceFilter_lookback(mocker, whitelist_conf, fee, caplog) -> None:
-    whitelist_conf['exchange']['pair_whitelist'].append('XRP/BTC')
-    whitelist_conf['pairlists'] = [
+def test_PerformanceFilter_lookback(mocker, default_conf_usdt, fee, caplog) -> None:
+    default_conf_usdt['exchange']['pair_whitelist'].extend(['ADA/USDT', 'XRP/USDT', 'ETC/USDT'])
+    default_conf_usdt['pairlists'] = [
         {"method": "StaticPairList"},
         {"method": "PerformanceFilter", "minutes": 60, "min_profit": 0.01}
     ]
     mocker.patch('freqtrade.exchange.Exchange.exchange_has', MagicMock(return_value=True))
-    exchange = get_patched_exchange(mocker, whitelist_conf)
-    pm = PairListManager(exchange, whitelist_conf)
+    exchange = get_patched_exchange(mocker, default_conf_usdt)
+    pm = PairListManager(exchange, default_conf_usdt)
     pm.refresh_pairlist()
 
-    assert pm.whitelist == ['ETH/BTC', 'TKN/BTC', 'XRP/BTC']
+    assert pm.whitelist == ['ETH/USDT', 'XRP/USDT', 'NEO/USDT', 'TKN/USDT']
 
     with time_machine.travel("2021-09-01 05:00:00 +00:00") as t:
-        create_mock_trades(fee)
+        create_mock_trades_usdt(fee)
         pm.refresh_pairlist()
-        assert pm.whitelist == ['XRP/BTC']
+        assert pm.whitelist == ['XRP/USDT']
         assert log_has_re(r'Removing pair .* since .* is below .*', caplog)
 
         # Move to "outside" of lookback window, so original sorting is restored.
         t.move_to("2021-09-01 07:00:00 +00:00")
         pm.refresh_pairlist()
-        assert pm.whitelist == ['ETH/BTC', 'TKN/BTC', 'XRP/BTC']
+        assert pm.whitelist == ['ETH/USDT', 'XRP/USDT', 'NEO/USDT', 'TKN/USDT']
+
+
+@pytest.mark.usefixtures("init_persistence")
+def test_PerformanceFilter_keep_mid_order(mocker, default_conf_usdt, fee, caplog) -> None:
+    default_conf_usdt['exchange']['pair_whitelist'].extend(['ADA/USDT', 'ETC/USDT'])
+    default_conf_usdt['pairlists'] = [
+        {"method": "StaticPairList", "allow_inactive": True},
+        {"method": "PerformanceFilter", "minutes": 60, }
+    ]
+    mocker.patch('freqtrade.exchange.Exchange.exchange_has', return_value=True)
+    exchange = get_patched_exchange(mocker, default_conf_usdt)
+    pm = PairListManager(exchange, default_conf_usdt)
+    pm.refresh_pairlist()
+
+    assert pm.whitelist == ['ETH/USDT', 'LTC/USDT', 'XRP/USDT',
+                            'NEO/USDT', 'TKN/USDT', 'ADA/USDT', 'ETC/USDT']
+
+    with time_machine.travel("2021-09-01 05:00:00 +00:00") as t:
+        create_mock_trades_usdt(fee)
+        pm.refresh_pairlist()
+        assert pm.whitelist == ['XRP/USDT', 'ETC/USDT', 'ETH/USDT',
+                                'NEO/USDT', 'TKN/USDT', 'ADA/USDT', 'LTC/USDT']
+        # assert log_has_re(r'Removing pair .* since .* is below .*', caplog)
+
+        # Move to "outside" of lookback window, so original sorting is restored.
+        t.move_to("2021-09-01 07:00:00 +00:00")
+        pm.refresh_pairlist()
+        assert pm.whitelist == ['ETH/USDT', 'LTC/USDT', 'XRP/USDT',
+                                'NEO/USDT', 'TKN/USDT', 'ADA/USDT', 'ETC/USDT']
 
 
 def test_gen_pair_whitelist_not_supported(mocker, default_conf, tickers) -> None:
@@ -753,6 +782,19 @@ def test_gen_pair_whitelist_not_supported(mocker, default_conf, tickers) -> None
         get_patched_freqtradebot(mocker, default_conf)
 
 
+def test_pair_whitelist_not_supported_Spread(mocker, default_conf, tickers) -> None:
+    default_conf['pairlists'] = [{'method': 'StaticPairList'}, {'method': 'SpreadFilter'}]
+
+    mocker.patch.multiple('freqtrade.exchange.Exchange',
+                          get_tickers=tickers,
+                          exchange_has=MagicMock(return_value=False),
+                          )
+
+    with pytest.raises(OperationalException,
+                       match=r'Exchange does not support fetchTickers, .*'):
+        get_patched_freqtradebot(mocker, default_conf)
+
+
 @pytest.mark.parametrize("pairlist", AVAILABLE_PAIRLISTS)
 def test_pairlist_class(mocker, whitelist_conf, markets, pairlist):
     whitelist_conf['pairlists'][0]['method'] = pairlist
@@ -1168,13 +1210,13 @@ def test_pairlistmanager_no_pairlist(mocker, whitelist_conf):
       {'pair': 'TKN/BTC', 'profit_ratio': -0.0501, 'count': 2},
       {'pair': 'ETH/BTC', 'profit_ratio': -0.0501, 'count': 100}],
      ['TKN/BTC', 'ETH/BTC', 'LTC/BTC']),
-    # Tie in performance and count, broken by alphabetical sort
+    # Tie in performance and count, broken by prior sorting sort
     ([{"method": "StaticPairList"}, {"method": "PerformanceFilter"}],
      ['ETH/BTC', 'TKN/BTC', 'LTC/BTC'],
      [{'pair': 'LTC/BTC', 'profit_ratio': -0.0501, 'count': 1},
       {'pair': 'TKN/BTC', 'profit_ratio': -0.0501, 'count': 1},
       {'pair': 'ETH/BTC', 'profit_ratio': -0.0501, 'count': 1}],
-     ['ETH/BTC', 'LTC/BTC', 'TKN/BTC']),
+     ['ETH/BTC', 'TKN/BTC', 'LTC/BTC']),
 ])
 def test_performance_filter(mocker, whitelist_conf, pairlists, pair_allowlist, overall_performance,
                             allowlist_result, tickers, markets, ohlcv_history_list):

tests/rpc/test_rpc.py

@@ -11,6 +11,7 @@ from freqtrade.edge import PairInfo
 from freqtrade.enums import State
 from freqtrade.exceptions import ExchangeError, InvalidOrderException, TemporaryError
 from freqtrade.persistence import Trade
+from freqtrade.persistence.models import Order
 from freqtrade.persistence.pairlock_middleware import PairLocks
 from freqtrade.rpc import RPC, RPCException
 from freqtrade.rpc.fiat_convert import CryptoToFiatConverter
@@ -78,7 +79,7 @@ def test_rpc_trade_status(default_conf, ticker, fee, mocker) -> None:
         'close_rate': None,
         'current_rate': 1.099e-05,
         'amount': 91.07468123,
-        'amount_requested': 91.07468123,
+        'amount_requested': 91.07468124,
         'stake_amount': 0.001,
         'trade_duration': None,
         'trade_duration_s': None,
@@ -108,6 +109,13 @@ def test_rpc_trade_status(default_conf, ticker, fee, mocker) -> None:
         'stoploss_entry_dist_ratio': -0.10448878,
         'open_order': None,
         'exchange': 'binance',
+        'orders': [{
+            'amount': 91.07468123, 'average': 1.098e-05, 'safe_price': 1.098e-05,
+            'cost': 0.0009999999999054, 'filled': 91.07468123, 'ft_order_side': 'buy',
+            'order_date': ANY, 'order_timestamp': ANY, 'order_filled_date': ANY,
+            'order_filled_timestamp': ANY, 'order_type': 'limit', 'price': 1.098e-05,
+            'is_open': False, 'pair': 'ETH/BTC', 'order_id': ANY,
+            'remaining': ANY, 'status': ANY}],
     }
 
     mocker.patch('freqtrade.exchange.Exchange.get_rate',
@@ -145,7 +153,7 @@ def test_rpc_trade_status(default_conf, ticker, fee, mocker) -> None:
         'close_rate': None,
         'current_rate': ANY,
         'amount': 91.07468123,
-        'amount_requested': 91.07468123,
+        'amount_requested': 91.07468124,
         'trade_duration': ANY,
         'trade_duration_s': ANY,
         'stake_amount': 0.001,
@@ -175,6 +183,13 @@ def test_rpc_trade_status(default_conf, ticker, fee, mocker) -> None:
         'stoploss_entry_dist_ratio': -0.10448878,
         'open_order': None,
         'exchange': 'binance',
+        'orders': [{
+            'amount': 91.07468123, 'average': 1.098e-05, 'safe_price': 1.098e-05,
+            'cost': 0.0009999999999054, 'filled': 91.07468123, 'ft_order_side': 'buy',
+            'order_date': ANY, 'order_timestamp': ANY, 'order_filled_date': ANY,
+            'order_filled_timestamp': ANY, 'order_type': 'limit', 'price': 1.098e-05,
+            'is_open': False, 'pair': 'ETH/BTC', 'order_id': ANY,
+            'remaining': ANY, 'status': ANY}],
     }
 
 
@@ -223,7 +238,7 @@ def test_rpc_status_table(default_conf, ticker, fee, mocker) -> None:
     rpc._config['position_adjustment_enable'] = True
     rpc._config['max_entry_position_adjustment'] = 3
     result, headers, fiat_profit_sum = rpc._rpc_status_table(default_conf['stake_currency'], 'USD')
-    assert "# Buys" in headers
+    assert "# Entries" in headers
     assert len(result[0]) == 5
     # 4th column should be 1/4 - as 1 order filled (a total of 4 is possible)
     # 3 on top of the initial one.
@@ -261,8 +276,10 @@ def test_rpc_daily_profit(default_conf, update, ticker, fee,
     assert trade
 
     # Simulate buy & sell
-    trade.update(limit_buy_order)
-    trade.update(limit_sell_order)
+    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
+    trade.update_trade(oobj)
+    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
+    trade.update_trade(oobj)
     trade.close_date = datetime.utcnow()
     trade.is_open = False
 
@@ -399,28 +416,32 @@ def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
     freqtradebot.enter_positions()
     trade = Trade.query.first()
     # Simulate fulfilled LIMIT_BUY order for trade
-    trade.update(limit_buy_order)
+    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'sell')
+    trade.update_trade(oobj)
 
     # Update the ticker with a market going up
     mocker.patch.multiple(
         'freqtrade.exchange.Exchange',
         fetch_ticker=ticker_sell_up
     )
-    trade.update(limit_sell_order)
+    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
+    trade.update_trade(oobj)
     trade.close_date = datetime.utcnow()
     trade.is_open = False
 
     freqtradebot.enter_positions()
     trade = Trade.query.first()
     # Simulate fulfilled LIMIT_BUY order for trade
-    trade.update(limit_buy_order)
+    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
+    trade.update_trade(oobj)
 
     # Update the ticker with a market going up
     mocker.patch.multiple(
         'freqtrade.exchange.Exchange',
         fetch_ticker=ticker_sell_up
     )
-    trade.update(limit_sell_order)
+    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
+    trade.update_trade(oobj)
     trade.close_date = datetime.utcnow()
     trade.is_open = False
 
@@ -479,14 +500,16 @@ def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, fee,
     freqtradebot.enter_positions()
     trade = Trade.query.first()
     # Simulate fulfilled LIMIT_BUY order for trade
-    trade.update(limit_buy_order)
+    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
+    trade.update_trade(oobj)
     # Update the ticker with a market going up
     mocker.patch.multiple(
         'freqtrade.exchange.Exchange',
         fetch_ticker=ticker_sell_up,
         get_fee=fee
     )
-    trade.update(limit_sell_order)
+    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
+    trade.update_trade(oobj)
     trade.close_date = datetime.utcnow()
     trade.is_open = False
 
@@ -582,8 +605,8 @@ def test_rpc_balance_handle(default_conf, mocker, tickers):
     rpc._fiat_converter = CryptoToFiatConverter()
 
     result = rpc._rpc_balance(default_conf['stake_currency'], default_conf['fiat_display_currency'])
-    assert prec_satoshi(result['total'], 12.309096315)
-    assert prec_satoshi(result['value'], 184636.44472997)
+    assert prec_satoshi(result['total'], 12.30909624)
+    assert prec_satoshi(result['value'], 184636.443606915)
     assert tickers.call_count == 1
     assert tickers.call_args_list[0][1]['cached'] is True
     assert 'USD' == result['symbol']
@@ -601,17 +624,16 @@ def test_rpc_balance_handle(default_conf, mocker, tickers):
          'est_stake': 0.30794,
          'used': 4.0,
          'stake': 'BTC',
-
          },
         {'free': 5.0,
          'balance': 10.0,
          'currency': 'USDT',
-         'est_stake': 0.0011563153318162476,
+         'est_stake': 0.0011562404610161968,
          'used': 5.0,
          'stake': 'BTC',
          }
     ]
-    assert result['total'] == 12.309096315331816
+    assert result['total'] == 12.309096240461017
 
 
 def test_rpc_start(mocker, default_conf) -> None:
@@ -738,13 +760,13 @@ def test_rpc_forcesell(default_conf, ticker, fee, mocker) -> None:
     mocker.patch(
         'freqtrade.exchange.Exchange.fetch_order',
         side_effect=[{
-            'id': '1234',
+            'id': trade.orders[0].order_id,
             'status': 'open',
             'type': 'limit',
             'side': 'buy',
             'filled': filled_amount
         }, {
-            'id': '1234',
+            'id': trade.orders[0].order_id,
             'status': 'closed',
             'type': 'limit',
             'side': 'buy',
@@ -824,10 +846,12 @@ def test_performance_handle(default_conf, ticker, limit_buy_order, fee,
     assert trade
 
     # Simulate fulfilled LIMIT_BUY order for trade
-    trade.update(limit_buy_order)
+    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
+    trade.update_trade(oobj)
 
     # Simulate fulfilled LIMIT_SELL order for trade
-    trade.update(limit_sell_order)
+    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
+    trade.update_trade(oobj)
 
     trade.close_date = datetime.utcnow()
     trade.is_open = False
@@ -858,10 +882,12 @@ def test_buy_tag_performance_handle(default_conf, ticker, limit_buy_order, fee,
     assert trade
 
     # Simulate fulfilled LIMIT_BUY order for trade
-    trade.update(limit_buy_order)
+    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
+    trade.update_trade(oobj)
 
     # Simulate fulfilled LIMIT_SELL order for trade
-    trade.update(limit_sell_order)
+    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
+    trade.update_trade(oobj)
 
     trade.close_date = datetime.utcnow()
     trade.is_open = False
@@ -930,10 +956,12 @@ def test_sell_reason_performance_handle(default_conf, ticker, limit_buy_order, f
     assert trade
 
     # Simulate fulfilled LIMIT_BUY order for trade
-    trade.update(limit_buy_order)
+    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
+    trade.update_trade(oobj)
 
     # Simulate fulfilled LIMIT_SELL order for trade
-    trade.update(limit_sell_order)
+    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
+    trade.update_trade(oobj)
 
     trade.close_date = datetime.utcnow()
     trade.is_open = False
@@ -1002,10 +1030,12 @@ def test_mix_tag_performance_handle(default_conf, ticker, limit_buy_order, fee,
     assert trade
 
     # Simulate fulfilled LIMIT_BUY order for trade
-    trade.update(limit_buy_order)
+    oobj = Order.parse_from_ccxt_object(limit_buy_order, limit_buy_order['symbol'], 'buy')
+    trade.update_trade(oobj)
 
     # Simulate fulfilled LIMIT_SELL order for trade
-    trade.update(limit_sell_order)
+    oobj = Order.parse_from_ccxt_object(limit_sell_order, limit_sell_order['symbol'], 'sell')
+    trade.update_trade(oobj)
 
     trade.close_date = datetime.utcnow()
     trade.is_open = False
@@ -1117,6 +1147,7 @@ def test_rpcforcebuy(mocker, default_conf, ticker, fee, limit_buy_order_open) ->
     pair = 'LTC/BTC'
     trade = rpc._rpc_forcebuy(pair, 0.0001, order_type='limit', stake_amount=0.05)
     assert trade.stake_amount == 0.05
+    assert trade.buy_tag == 'forceentry'
 
     # Test not buying
     pair = 'XRP/BTC'
@@ -1276,3 +1307,13 @@ def test_rpc_edge_enabled(mocker, edge_conf) -> None:
     assert ret[0]['Winrate'] == 0.66
     assert ret[0]['Expectancy'] == 1.71
     assert ret[0]['Stoploss'] == -0.02
+
+
+def test_rpc_health(mocker, default_conf) -> None:
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
+
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+    rpc = RPC(freqtradebot)
+    result = rpc._health()
+    assert result['last_process'] == '1970-01-01 00:00:00+00:00'
+    assert result['last_process_ts'] == 0