2018-02-04 09:21:16 +00:00
|
|
|
"""
|
|
|
|
Freqtrade is the main module of this bot. It contains the class Freqtrade()
|
|
|
|
"""
|
|
|
|
import copy
|
2018-03-25 19:37:14 +00:00
|
|
|
import logging
|
2018-02-04 09:21:16 +00:00
|
|
|
import traceback
|
2018-03-02 15:22:00 +00:00
|
|
|
from datetime import datetime
|
2019-09-26 05:04:56 +00:00
|
|
|
from math import isclose
|
2020-01-22 19:50:09 +00:00
|
|
|
from threading import Lock
|
2020-05-16 08:28:36 +00:00
|
|
|
from typing import Any, Dict, List, Optional
|
2018-03-17 21:44:47 +00:00
|
|
|
|
2018-03-02 15:22:00 +00:00
|
|
|
import arrow
|
2020-02-22 10:12:33 +00:00
|
|
|
from cachetools import TTLCache
|
2018-07-31 10:47:32 +00:00
|
|
|
|
2020-10-16 05:39:12 +00:00
|
|
|
from freqtrade import __version__, constants
|
2019-10-25 17:59:04 +00:00
|
|
|
from freqtrade.configuration import validate_config_consistency
|
2018-12-12 19:16:03 +00:00
|
|
|
from freqtrade.data.converter import order_book_to_dataframe
|
2018-12-17 05:43:01 +00:00
|
|
|
from freqtrade.data.dataprovider import DataProvider
|
2018-09-21 15:41:31 +00:00
|
|
|
from freqtrade.edge import Edge
|
2020-08-14 08:59:55 +00:00
|
|
|
from freqtrade.exceptions import (DependencyException, ExchangeError, InsufficientFundsError,
|
2020-06-28 14:01:40 +00:00
|
|
|
InvalidOrderException, PricingError)
|
2019-08-12 18:39:34 +00:00
|
|
|
from freqtrade.exchange import timeframe_to_minutes, timeframe_to_next_date
|
2020-07-15 19:02:31 +00:00
|
|
|
from freqtrade.misc import safe_value_fallback, safe_value_fallback2
|
2019-12-30 14:02:17 +00:00
|
|
|
from freqtrade.pairlist.pairlistmanager import PairListManager
|
2020-10-16 05:39:12 +00:00
|
|
|
from freqtrade.persistence import Order, Trade, cleanup_db, init_db
|
2019-11-09 05:55:16 +00:00
|
|
|
from freqtrade.resolvers import ExchangeResolver, StrategyResolver
|
2018-07-12 17:59:17 +00:00
|
|
|
from freqtrade.rpc import RPCManager, RPCMessageType
|
2019-09-01 15:48:06 +00:00
|
|
|
from freqtrade.state import State
|
2019-10-25 17:59:04 +00:00
|
|
|
from freqtrade.strategy.interface import IStrategy, SellType
|
2020-02-06 19:30:17 +00:00
|
|
|
from freqtrade.strategy.strategy_wrapper import strategy_safe_wrapper
|
2019-12-15 08:48:35 +00:00
|
|
|
from freqtrade.wallets import Wallets
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2020-09-28 17:39:41 +00:00
|
|
|
|
2018-03-25 19:37:14 +00:00
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
|
|
|
2019-09-12 01:39:52 +00:00
|
|
|
class FreqtradeBot:
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
|
|
|
Freqtrade is the main class of the bot.
|
|
|
|
This is from here the bot start its logic.
|
|
|
|
"""
|
|
|
|
|
2019-01-22 19:01:12 +00:00
|
|
|
def __init__(self, config: Dict[str, Any]) -> None:
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
2018-12-26 13:37:25 +00:00
|
|
|
Init all variables and objects the bot needs to work
|
|
|
|
:param config: configuration dict, you can use Configuration.get_config()
|
|
|
|
to get the config dict.
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
|
|
|
|
2019-03-22 17:16:54 +00:00
|
|
|
logger.info('Starting freqtrade %s', __version__)
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2019-03-31 20:39:55 +00:00
|
|
|
# Init bot state
|
2018-04-06 07:57:08 +00:00
|
|
|
self.state = State.STOPPED
|
2018-02-04 09:21:16 +00:00
|
|
|
|
|
|
|
# Init objects
|
|
|
|
self.config = config
|
2019-03-10 17:05:33 +00:00
|
|
|
|
2020-05-05 04:32:03 +00:00
|
|
|
# Cache values for 1800 to avoid frequent polling of the exchange for prices
|
|
|
|
# Caching only applies to RPC methods, so prices for open trades are still
|
|
|
|
# refreshed once every iteration.
|
2020-10-12 17:28:14 +00:00
|
|
|
self._sell_rate_cache: TTLCache = TTLCache(maxsize=100, ttl=1800)
|
|
|
|
self._buy_rate_cache: TTLCache = TTLCache(maxsize=100, ttl=1800)
|
2019-10-25 13:00:16 +00:00
|
|
|
|
2019-12-23 09:23:48 +00:00
|
|
|
self.strategy: IStrategy = StrategyResolver.load_strategy(self.config)
|
2019-08-18 14:22:18 +00:00
|
|
|
|
|
|
|
# Check config consistency here since strategies can set certain options
|
2019-08-18 14:10:10 +00:00
|
|
|
validate_config_consistency(config)
|
2018-11-24 19:12:50 +00:00
|
|
|
|
2019-12-23 09:03:18 +00:00
|
|
|
self.exchange = ExchangeResolver.load_exchange(self.config['exchange']['name'], self.config)
|
2019-02-17 03:18:56 +00:00
|
|
|
|
2020-10-16 05:39:12 +00:00
|
|
|
init_db(self.config.get('db_url', None), clean_open_orders=self.config['dry_run'])
|
2019-12-15 08:38:18 +00:00
|
|
|
|
2019-12-15 08:48:35 +00:00
|
|
|
self.wallets = Wallets(self.config, self.exchange)
|
|
|
|
|
2020-05-11 15:32:28 +00:00
|
|
|
self.pairlists = PairListManager(self.exchange, self.config)
|
|
|
|
|
|
|
|
self.dataprovider = DataProvider(self.config, self.exchange, self.pairlists)
|
2018-12-26 13:32:17 +00:00
|
|
|
|
|
|
|
# Attach Dataprovider to Strategy baseclass
|
|
|
|
IStrategy.dp = self.dataprovider
|
|
|
|
# Attach Wallets to Strategy baseclass
|
|
|
|
IStrategy.wallets = self.wallets
|
|
|
|
|
2018-10-02 10:15:54 +00:00
|
|
|
# Initializing Edge only if enabled
|
2018-11-07 23:22:46 +00:00
|
|
|
self.edge = Edge(self.config, self.exchange, self.strategy) if \
|
2018-11-07 17:12:46 +00:00
|
|
|
self.config.get('edge', {}).get('enabled', False) else None
|
2018-10-02 10:15:54 +00:00
|
|
|
|
2020-05-16 08:49:24 +00:00
|
|
|
self.active_pair_whitelist = self._refresh_active_whitelist()
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2019-03-31 20:39:55 +00:00
|
|
|
# Set initial bot state from config
|
2018-02-04 09:21:16 +00:00
|
|
|
initial_state = self.config.get('initial_state')
|
2019-03-31 20:39:55 +00:00
|
|
|
self.state = State[initial_state.upper()] if initial_state else State.STOPPED
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2019-10-24 19:33:44 +00:00
|
|
|
# RPC runs in separate threads, can start handling external commands just after
|
|
|
|
# initialization, even before Freqtradebot has a chance to start its throttling,
|
|
|
|
# so anything in the Freqtradebot instance should be ready (initialized), including
|
|
|
|
# the initial state of the bot.
|
|
|
|
# Keep this at the end of this initialization method.
|
|
|
|
self.rpc: RPCManager = RPCManager(self)
|
2020-01-22 19:50:09 +00:00
|
|
|
# Protect sell-logic from forcesell and viceversa
|
|
|
|
self._sell_lock = Lock()
|
2019-10-24 19:33:44 +00:00
|
|
|
|
2020-01-27 00:34:53 +00:00
|
|
|
def notify_status(self, msg: str) -> None:
|
|
|
|
"""
|
|
|
|
Public method for users of this class (worker, etc.) to send notifications
|
|
|
|
via RPC about changes in the bot status.
|
|
|
|
"""
|
|
|
|
self.rpc.send_msg({
|
|
|
|
'type': RPCMessageType.STATUS_NOTIFICATION,
|
|
|
|
'status': msg
|
|
|
|
})
|
|
|
|
|
2018-06-08 23:19:42 +00:00
|
|
|
def cleanup(self) -> None:
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
2018-06-08 23:19:42 +00:00
|
|
|
Cleanup pending resources on an already stopped bot
|
2018-02-04 09:21:16 +00:00
|
|
|
:return: None
|
|
|
|
"""
|
2018-06-08 23:19:42 +00:00
|
|
|
logger.info('Cleaning up modules ...')
|
2019-03-10 17:05:33 +00:00
|
|
|
|
2020-04-24 22:16:52 +00:00
|
|
|
if self.config['cancel_open_orders_on_exit']:
|
|
|
|
self.cancel_all_open_orders()
|
|
|
|
|
2020-06-28 09:02:50 +00:00
|
|
|
self.check_for_open_trades()
|
|
|
|
|
2018-02-04 09:21:16 +00:00
|
|
|
self.rpc.cleanup()
|
2020-10-16 05:39:12 +00:00
|
|
|
cleanup_db()
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2019-05-19 18:06:26 +00:00
|
|
|
def startup(self) -> None:
|
|
|
|
"""
|
|
|
|
Called on startup and after reloading the bot - triggers notifications and
|
|
|
|
performs startup tasks
|
|
|
|
"""
|
|
|
|
self.rpc.startup_messages(self.config, self.pairlists)
|
2019-05-20 17:35:48 +00:00
|
|
|
if not self.edge:
|
|
|
|
# Adjust stoploss if it was changed
|
|
|
|
Trade.stoploss_reinitialization(self.strategy.stoploss)
|
2019-05-19 18:06:26 +00:00
|
|
|
|
2020-08-21 05:24:49 +00:00
|
|
|
# Only update open orders on startup
|
|
|
|
# This will update the database after the initial migration
|
2020-08-13 17:37:41 +00:00
|
|
|
self.update_open_orders()
|
|
|
|
|
2019-08-13 07:37:56 +00:00
|
|
|
def process(self) -> None:
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
|
|
|
Queries the persistence layer for open trades and handles them,
|
|
|
|
otherwise a new trade is created.
|
|
|
|
:return: True if one or more trades has been created or closed, False otherwise
|
|
|
|
"""
|
2019-03-22 21:20:20 +00:00
|
|
|
|
2020-06-09 22:39:23 +00:00
|
|
|
# Check whether markets have to be reloaded and reload them when it's needed
|
|
|
|
self.exchange.reload_markets()
|
2019-03-22 21:20:20 +00:00
|
|
|
|
2020-08-22 06:39:10 +00:00
|
|
|
self.update_closed_trades_without_assigned_fees()
|
|
|
|
|
2019-03-22 21:20:20 +00:00
|
|
|
# Query trades from persistence layer
|
|
|
|
trades = Trade.get_open_trades()
|
|
|
|
|
2020-05-16 08:49:24 +00:00
|
|
|
self.active_pair_whitelist = self._refresh_active_whitelist(trades)
|
2019-03-22 21:20:20 +00:00
|
|
|
|
|
|
|
# Refreshing candles
|
2020-05-18 10:54:21 +00:00
|
|
|
self.dataprovider.refresh(self.pairlists.create_pair_list(self.active_pair_whitelist),
|
2019-03-22 21:20:20 +00:00
|
|
|
self.strategy.informative_pairs())
|
|
|
|
|
2020-06-14 05:16:56 +00:00
|
|
|
strategy_safe_wrapper(self.strategy.bot_loop_start, supress_error=True)()
|
2020-06-14 05:00:55 +00:00
|
|
|
|
2020-06-13 16:06:52 +00:00
|
|
|
self.strategy.analyze(self.active_pair_whitelist)
|
|
|
|
|
2020-03-24 16:16:35 +00:00
|
|
|
with self._sell_lock:
|
|
|
|
# Check and handle any timed out open orders
|
|
|
|
self.check_handle_timedout()
|
|
|
|
|
2020-01-22 19:50:09 +00:00
|
|
|
# Protect from collisions with forcesell.
|
|
|
|
# Without this, freqtrade my try to recreate stoploss_on_exchange orders
|
|
|
|
# while selling is in process, since telegram messages arrive in an different thread.
|
|
|
|
with self._sell_lock:
|
|
|
|
# First process current opened trades (positions)
|
|
|
|
self.exit_positions(trades)
|
2019-03-22 21:20:20 +00:00
|
|
|
|
|
|
|
# Then looking for buy opportunities
|
2019-12-28 00:46:42 +00:00
|
|
|
if self.get_free_open_trades():
|
2019-12-30 19:50:56 +00:00
|
|
|
self.enter_positions()
|
2019-03-22 21:20:20 +00:00
|
|
|
|
2019-11-12 14:43:10 +00:00
|
|
|
Trade.session.flush()
|
2019-03-22 21:20:20 +00:00
|
|
|
|
2020-04-24 22:16:52 +00:00
|
|
|
def process_stopped(self) -> None:
|
|
|
|
"""
|
2020-05-16 11:17:48 +00:00
|
|
|
Close all orders that were left open
|
2020-04-24 22:16:52 +00:00
|
|
|
"""
|
|
|
|
if self.config['cancel_open_orders_on_exit']:
|
|
|
|
self.cancel_all_open_orders()
|
|
|
|
|
2020-06-27 16:35:46 +00:00
|
|
|
def check_for_open_trades(self):
|
2020-06-27 16:40:44 +00:00
|
|
|
"""
|
2020-06-27 18:24:50 +00:00
|
|
|
Notify the user when the bot is stopped
|
2020-06-27 16:40:44 +00:00
|
|
|
and there are still open trades active.
|
|
|
|
"""
|
2020-06-27 19:53:12 +00:00
|
|
|
open_trades = Trade.get_trades([Trade.is_open == 1]).all()
|
2020-06-27 16:35:46 +00:00
|
|
|
|
2020-06-27 19:46:53 +00:00
|
|
|
if len(open_trades) != 0:
|
2020-06-27 16:35:46 +00:00
|
|
|
msg = {
|
2020-06-27 19:46:53 +00:00
|
|
|
'type': RPCMessageType.WARNING_NOTIFICATION,
|
2020-06-28 09:02:50 +00:00
|
|
|
'status': f"{len(open_trades)} open trades active.\n\n"
|
|
|
|
f"Handle these trades manually on {self.exchange.name}, "
|
|
|
|
f"or '/start' the bot again and use '/stopbuy' "
|
|
|
|
f"to handle open trades gracefully. \n"
|
|
|
|
f"{'Trades are simulated.' if self.config['dry_run'] else ''}",
|
2020-06-27 16:35:46 +00:00
|
|
|
}
|
|
|
|
self.rpc.send_msg(msg)
|
|
|
|
|
2020-05-16 08:49:24 +00:00
|
|
|
def _refresh_active_whitelist(self, trades: List[Trade] = []) -> List[str]:
|
2019-02-20 13:12:17 +00:00
|
|
|
"""
|
2020-05-16 08:49:24 +00:00
|
|
|
Refresh active whitelist from pairlist or edge and extend it with
|
|
|
|
pairs that have open trades.
|
2019-02-20 13:12:17 +00:00
|
|
|
"""
|
2019-10-26 07:38:29 +00:00
|
|
|
# Refresh whitelist
|
|
|
|
self.pairlists.refresh_pairlist()
|
|
|
|
_whitelist = self.pairlists.whitelist
|
|
|
|
|
|
|
|
# Calculating Edge positioning
|
|
|
|
if self.edge:
|
|
|
|
self.edge.calculate()
|
|
|
|
_whitelist = self.edge.adjust(_whitelist)
|
|
|
|
|
|
|
|
if trades:
|
2020-03-08 10:35:31 +00:00
|
|
|
# Extend active-pair whitelist with pairs of open trades
|
|
|
|
# It ensures that candle (OHLCV) data are downloaded for open trades as well
|
2019-10-26 07:38:29 +00:00
|
|
|
_whitelist.extend([trade.pair for trade in trades if trade.pair not in _whitelist])
|
|
|
|
return _whitelist
|
2019-02-20 12:12:04 +00:00
|
|
|
|
2019-12-28 00:46:42 +00:00
|
|
|
def get_free_open_trades(self):
|
|
|
|
"""
|
|
|
|
Return the number of free open trades slots or 0 if
|
|
|
|
max number of open trades reached
|
|
|
|
"""
|
|
|
|
open_trades = len(Trade.get_open_trades())
|
|
|
|
return max(0, self.config['max_open_trades'] - open_trades)
|
|
|
|
|
2020-08-13 15:18:56 +00:00
|
|
|
def update_open_orders(self):
|
|
|
|
"""
|
2020-08-22 06:39:10 +00:00
|
|
|
Updates open orders based on order list kept in the database.
|
|
|
|
Mainly updates the state of orders - but may also close trades
|
2020-08-13 15:18:56 +00:00
|
|
|
"""
|
|
|
|
orders = Order.get_open_orders()
|
|
|
|
logger.info(f"Updating {len(orders)} open orders.")
|
|
|
|
for order in orders:
|
|
|
|
try:
|
2020-08-22 07:30:25 +00:00
|
|
|
fo = self.exchange.fetch_order_or_stoploss_order(order.order_id, order.ft_pair,
|
|
|
|
order.ft_order_side == 'stoploss')
|
2020-08-13 17:37:41 +00:00
|
|
|
|
2020-08-21 05:17:52 +00:00
|
|
|
self.update_trade_state(order.trade, order.order_id, fo)
|
2020-08-13 17:37:41 +00:00
|
|
|
|
2020-09-06 17:32:00 +00:00
|
|
|
except ExchangeError as e:
|
|
|
|
logger.warning(f"Error updating Order {order.order_id} due to {e}")
|
2020-08-13 15:18:56 +00:00
|
|
|
|
2020-08-22 06:39:10 +00:00
|
|
|
def update_closed_trades_without_assigned_fees(self):
|
|
|
|
"""
|
|
|
|
Update closed trades without close fees assigned.
|
2020-08-22 07:30:25 +00:00
|
|
|
Only acts when Orders are in the database, otherwise the last orderid is unknown.
|
2020-08-22 06:39:10 +00:00
|
|
|
"""
|
|
|
|
trades: List[Trade] = Trade.get_sold_trades_without_assigned_fees()
|
|
|
|
for trade in trades:
|
|
|
|
|
|
|
|
if not trade.is_open and not trade.fee_updated('sell'):
|
|
|
|
# Get sell fee
|
2020-09-11 05:12:10 +00:00
|
|
|
order = trade.select_order('sell', False)
|
2020-08-22 06:39:10 +00:00
|
|
|
if order:
|
|
|
|
logger.info(f"Updating sell-fee on trade {trade} for order {order.order_id}.")
|
2020-08-22 07:30:25 +00:00
|
|
|
self.update_trade_state(trade, order.order_id,
|
2020-08-22 13:48:42 +00:00
|
|
|
stoploss_order=order.ft_order_side == 'stoploss')
|
|
|
|
|
|
|
|
trades: List[Trade] = Trade.get_open_trades_without_assigned_fees()
|
|
|
|
for trade in trades:
|
|
|
|
if trade.is_open and not trade.fee_updated('buy'):
|
2020-09-11 05:12:10 +00:00
|
|
|
order = trade.select_order('buy', False)
|
2020-08-22 13:48:42 +00:00
|
|
|
if order:
|
|
|
|
logger.info(f"Updating buy-fee on trade {trade} for order {order.order_id}.")
|
|
|
|
self.update_trade_state(trade, order.order_id)
|
2020-08-22 06:39:10 +00:00
|
|
|
|
2020-08-22 13:48:00 +00:00
|
|
|
def handle_insufficient_funds(self, trade: Trade):
|
|
|
|
"""
|
2020-08-22 13:48:42 +00:00
|
|
|
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.
|
2020-08-22 13:48:00 +00:00
|
|
|
"""
|
|
|
|
sell_order = trade.select_order('sell', None)
|
|
|
|
if sell_order:
|
|
|
|
self.refind_lost_order(trade)
|
|
|
|
else:
|
|
|
|
self.reupdate_buy_order_fees(trade)
|
|
|
|
|
|
|
|
def reupdate_buy_order_fees(self, trade: Trade):
|
|
|
|
"""
|
2020-08-22 13:48:42 +00:00
|
|
|
Get buy order from database, and try to reupdate.
|
|
|
|
Handles trades where the initial fee-update did not work.
|
2020-08-22 13:48:00 +00:00
|
|
|
"""
|
|
|
|
logger.info(f"Trying to reupdate buy fees for {trade}")
|
2020-09-11 05:12:10 +00:00
|
|
|
order = trade.select_order('buy', False)
|
2020-08-22 13:48:00 +00:00
|
|
|
if order:
|
|
|
|
logger.info(f"Updating buy-fee on trade {trade} for order {order.order_id}.")
|
|
|
|
self.update_trade_state(trade, order.order_id)
|
|
|
|
|
2020-08-14 08:59:55 +00:00
|
|
|
def refind_lost_order(self, trade):
|
|
|
|
"""
|
|
|
|
Try refinding a lost trade.
|
|
|
|
Only used when InsufficientFunds appears on sell orders (stoploss or sell).
|
|
|
|
Tries to walk the stored orders and sell them off eventually.
|
|
|
|
"""
|
|
|
|
logger.info(f"Trying to refind lost order for {trade}")
|
|
|
|
for order in trade.orders:
|
|
|
|
logger.info(f"Trying to refind {order}")
|
|
|
|
fo = None
|
2020-08-24 04:50:43 +00:00
|
|
|
if not order.ft_is_open:
|
2020-09-19 07:37:11 +00:00
|
|
|
logger.debug(f"Order {order} is no longer open.")
|
2020-08-24 04:50:43 +00:00
|
|
|
continue
|
2020-08-23 14:04:32 +00:00
|
|
|
if order.ft_order_side == 'buy':
|
|
|
|
# Skip buy side - this is handled by reupdate_buy_order_fees
|
|
|
|
continue
|
2020-08-14 08:59:55 +00:00
|
|
|
try:
|
2020-08-22 07:30:25 +00:00
|
|
|
fo = self.exchange.fetch_order_or_stoploss_order(order.order_id, order.ft_pair,
|
|
|
|
order.ft_order_side == 'stoploss')
|
2020-08-14 08:59:55 +00:00
|
|
|
if order.ft_order_side == 'stoploss':
|
|
|
|
if fo and fo['status'] == 'open':
|
|
|
|
# Assume this as the open stoploss order
|
|
|
|
trade.stoploss_order_id = order.order_id
|
|
|
|
elif order.ft_order_side == 'sell':
|
|
|
|
if fo and fo['status'] == 'open':
|
|
|
|
# Assume this as the open order
|
|
|
|
trade.open_order_id = order.order_id
|
|
|
|
if fo:
|
2020-08-23 14:04:32 +00:00
|
|
|
logger.info(f"Found {order} for trade {trade}.jj")
|
2020-08-22 07:30:25 +00:00
|
|
|
self.update_trade_state(trade, order.order_id, fo,
|
2020-08-22 13:48:42 +00:00
|
|
|
stoploss_order=order.ft_order_side == 'stoploss')
|
2020-08-14 08:59:55 +00:00
|
|
|
|
|
|
|
except ExchangeError:
|
2020-09-09 05:50:52 +00:00
|
|
|
logger.warning(f"Error updating {order.order_id}.")
|
2020-08-14 08:59:55 +00:00
|
|
|
|
2020-01-01 23:53:25 +00:00
|
|
|
#
|
2020-01-02 08:50:54 +00:00
|
|
|
# BUY / enter positions / open trades logic and methods
|
2020-01-01 23:53:25 +00:00
|
|
|
#
|
|
|
|
|
|
|
|
def enter_positions(self) -> int:
|
|
|
|
"""
|
|
|
|
Tries to execute buy orders for new trades (positions)
|
|
|
|
"""
|
|
|
|
trades_created = 0
|
|
|
|
|
|
|
|
whitelist = copy.deepcopy(self.active_pair_whitelist)
|
|
|
|
if not whitelist:
|
|
|
|
logger.info("Active pair whitelist is empty.")
|
|
|
|
else:
|
|
|
|
# Remove pairs for currently opened trades from the whitelist
|
|
|
|
for trade in Trade.get_open_trades():
|
|
|
|
if trade.pair in whitelist:
|
|
|
|
whitelist.remove(trade.pair)
|
|
|
|
logger.debug('Ignoring %s in pair whitelist', trade.pair)
|
|
|
|
|
|
|
|
if not whitelist:
|
|
|
|
logger.info("No currency pair in active pair whitelist, "
|
|
|
|
"but checking to sell open trades.")
|
|
|
|
else:
|
|
|
|
# Create entity and execute trade for each pair from whitelist
|
|
|
|
for pair in whitelist:
|
|
|
|
try:
|
|
|
|
trades_created += self.create_trade(pair)
|
|
|
|
except DependencyException as exception:
|
|
|
|
logger.warning('Unable to create trade for %s: %s', pair, exception)
|
|
|
|
|
|
|
|
if not trades_created:
|
|
|
|
logger.debug("Found no buy signals for whitelisted currencies. "
|
|
|
|
"Trying again...")
|
|
|
|
|
|
|
|
return trades_created
|
|
|
|
|
2020-02-22 10:12:33 +00:00
|
|
|
def get_buy_rate(self, pair: str, refresh: bool) -> float:
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
|
|
|
Calculates bid target between current ask price and last price
|
2020-02-22 10:12:33 +00:00
|
|
|
:param pair: Pair to get rate for
|
|
|
|
:param refresh: allow cached data
|
2018-02-04 09:21:16 +00:00
|
|
|
:return: float: Price
|
|
|
|
"""
|
2020-02-22 10:12:33 +00:00
|
|
|
if not refresh:
|
2020-02-22 10:16:20 +00:00
|
|
|
rate = self._buy_rate_cache.get(pair)
|
2020-02-22 10:12:33 +00:00
|
|
|
# Check if cache has been invalidated
|
|
|
|
if rate:
|
2020-08-23 17:14:28 +00:00
|
|
|
logger.debug(f"Using cached buy rate for {pair}.")
|
2020-02-22 10:12:33 +00:00
|
|
|
return rate
|
|
|
|
|
2020-02-23 13:08:16 +00:00
|
|
|
bid_strategy = self.config.get('bid_strategy', {})
|
|
|
|
if 'use_order_book' in bid_strategy and bid_strategy.get('use_order_book', False):
|
2020-02-23 13:13:43 +00:00
|
|
|
logger.info(
|
|
|
|
f"Getting price from order book {bid_strategy['price_side'].capitalize()} side."
|
2020-03-05 19:44:29 +00:00
|
|
|
)
|
2020-02-23 13:08:16 +00:00
|
|
|
order_book_top = bid_strategy.get('order_book_top', 1)
|
2020-05-26 18:27:35 +00:00
|
|
|
order_book = self.exchange.fetch_l2_order_book(pair, order_book_top)
|
2018-08-14 10:12:44 +00:00
|
|
|
logger.debug('order_book %s', order_book)
|
2018-08-05 04:41:06 +00:00
|
|
|
# top 1 = index 0
|
2020-05-26 18:14:05 +00:00
|
|
|
try:
|
|
|
|
rate_from_l2 = order_book[f"{bid_strategy['price_side']}s"][order_book_top - 1][0]
|
|
|
|
except (IndexError, KeyError) as e:
|
|
|
|
logger.warning(
|
|
|
|
"Buy Price from orderbook could not be determined."
|
|
|
|
f"Orderbook: {order_book}"
|
|
|
|
)
|
2020-05-26 18:35:11 +00:00
|
|
|
raise PricingError from e
|
2020-05-26 18:14:05 +00:00
|
|
|
logger.info(f'...top {order_book_top} order book buy rate {rate_from_l2:.8f}')
|
|
|
|
used_rate = rate_from_l2
|
2018-08-05 04:41:06 +00:00
|
|
|
else:
|
2020-02-23 13:13:43 +00:00
|
|
|
logger.info(f"Using Last {bid_strategy['price_side'].capitalize()} / Last Price")
|
2020-02-22 10:12:33 +00:00
|
|
|
ticker = self.exchange.fetch_ticker(pair)
|
2020-03-02 19:05:54 +00:00
|
|
|
ticker_rate = ticker[bid_strategy['price_side']]
|
|
|
|
if ticker['last'] and ticker_rate > ticker['last']:
|
2019-02-12 23:55:55 +00:00
|
|
|
balance = self.config['bid_strategy']['ask_last_balance']
|
2020-03-02 19:05:54 +00:00
|
|
|
ticker_rate = ticker_rate + balance * (ticker['last'] - ticker_rate)
|
2018-08-05 04:41:06 +00:00
|
|
|
used_rate = ticker_rate
|
|
|
|
|
2020-02-22 10:12:33 +00:00
|
|
|
self._buy_rate_cache[pair] = used_rate
|
|
|
|
|
2018-08-05 04:41:06 +00:00
|
|
|
return used_rate
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2020-02-02 04:00:40 +00:00
|
|
|
def get_trade_stake_amount(self, pair: str) -> float:
|
2018-07-18 06:36:39 +00:00
|
|
|
"""
|
2019-12-27 23:25:43 +00:00
|
|
|
Calculate stake amount for the trade
|
|
|
|
:return: float: Stake amount
|
2020-01-05 11:50:44 +00:00
|
|
|
:raise: DependencyException if the available stake amount is too low
|
2018-07-18 06:36:39 +00:00
|
|
|
"""
|
2020-01-05 11:50:44 +00:00
|
|
|
stake_amount: float
|
2020-01-09 19:09:21 +00:00
|
|
|
# Ensure wallets are uptodate.
|
|
|
|
self.wallets.update()
|
|
|
|
|
2018-11-06 18:45:41 +00:00
|
|
|
if self.edge:
|
2019-12-27 23:53:41 +00:00
|
|
|
stake_amount = self.edge.stake_amount(
|
2018-11-28 14:36:32 +00:00
|
|
|
pair,
|
|
|
|
self.wallets.get_free(self.config['stake_currency']),
|
2018-12-04 16:05:35 +00:00
|
|
|
self.wallets.get_total(self.config['stake_currency']),
|
2018-12-03 18:55:37 +00:00
|
|
|
Trade.total_open_trades_stakes()
|
2018-11-26 20:06:32 +00:00
|
|
|
)
|
2018-09-21 15:41:31 +00:00
|
|
|
else:
|
|
|
|
stake_amount = self.config['stake_amount']
|
2019-12-27 23:53:41 +00:00
|
|
|
if stake_amount == constants.UNLIMITED_STAKE_AMOUNT:
|
|
|
|
stake_amount = self._calculate_unlimited_stake_amount()
|
2018-05-23 10:15:03 +00:00
|
|
|
|
2019-12-27 23:25:43 +00:00
|
|
|
return self._check_available_stake_amount(stake_amount)
|
|
|
|
|
2020-01-03 09:14:23 +00:00
|
|
|
def _get_available_stake_amount(self) -> float:
|
|
|
|
"""
|
|
|
|
Return the total currently available balance in stake currency,
|
|
|
|
respecting tradable_balance_ratio.
|
|
|
|
Calculated as
|
|
|
|
<open_trade stakes> + free amount ) * tradable_balance_ratio - <open_trade stakes>
|
|
|
|
"""
|
|
|
|
val_tied_up = Trade.total_open_trades_stakes()
|
|
|
|
|
|
|
|
# Ensure <tradable_balance_ratio>% is used from the overall balance
|
|
|
|
# Otherwise we'd risk lowering stakes with each open trade.
|
|
|
|
# (tied up + current free) * ratio) - tied up
|
|
|
|
available_amount = ((val_tied_up + self.wallets.get_free(self.config['stake_currency'])) *
|
|
|
|
self.config['tradable_balance_ratio']) - val_tied_up
|
|
|
|
return available_amount
|
|
|
|
|
2020-01-05 11:50:44 +00:00
|
|
|
def _calculate_unlimited_stake_amount(self) -> float:
|
2019-12-27 23:36:32 +00:00
|
|
|
"""
|
|
|
|
Calculate stake amount for "unlimited" stake amount
|
2020-01-05 11:50:44 +00:00
|
|
|
:return: 0 if max number of trades reached, else stake_amount to use.
|
2019-12-27 23:36:32 +00:00
|
|
|
"""
|
2019-12-28 00:46:42 +00:00
|
|
|
free_open_trades = self.get_free_open_trades()
|
|
|
|
if not free_open_trades:
|
2020-01-05 11:50:44 +00:00
|
|
|
return 0
|
2020-01-02 12:20:57 +00:00
|
|
|
|
2020-01-03 09:14:23 +00:00
|
|
|
available_amount = self._get_available_stake_amount()
|
2020-01-02 12:20:57 +00:00
|
|
|
|
2019-12-28 00:46:42 +00:00
|
|
|
return available_amount / free_open_trades
|
2019-12-27 23:36:32 +00:00
|
|
|
|
2020-01-05 11:50:44 +00:00
|
|
|
def _check_available_stake_amount(self, stake_amount: float) -> float:
|
2019-12-27 23:25:43 +00:00
|
|
|
"""
|
|
|
|
Check if stake amount can be fulfilled with the available balance
|
|
|
|
for the stake currency
|
|
|
|
:return: float: Stake amount
|
|
|
|
"""
|
2020-01-03 09:41:10 +00:00
|
|
|
available_amount = self._get_available_stake_amount()
|
2019-12-27 23:25:43 +00:00
|
|
|
|
2020-01-05 12:25:11 +00:00
|
|
|
if self.config['amend_last_stake_amount']:
|
2020-01-10 05:36:28 +00:00
|
|
|
# Remaining amount needs to be at least stake_amount * last_stake_amount_min_ratio
|
|
|
|
# Otherwise the remaining amount is too low to trade.
|
|
|
|
if available_amount > (stake_amount * self.config['last_stake_amount_min_ratio']):
|
|
|
|
stake_amount = min(stake_amount, available_amount)
|
|
|
|
else:
|
|
|
|
stake_amount = 0
|
2020-01-05 12:25:11 +00:00
|
|
|
|
2020-01-05 11:50:44 +00:00
|
|
|
if available_amount < stake_amount:
|
2018-05-23 10:15:03 +00:00
|
|
|
raise DependencyException(
|
2019-12-15 09:26:56 +00:00
|
|
|
f"Available balance ({available_amount} {self.config['stake_currency']}) is "
|
|
|
|
f"lower than stake amount ({stake_amount} {self.config['stake_currency']})"
|
2018-05-23 10:15:03 +00:00
|
|
|
)
|
|
|
|
|
2018-11-06 18:45:41 +00:00
|
|
|
return stake_amount
|
2018-05-23 10:15:03 +00:00
|
|
|
|
2018-06-16 23:23:12 +00:00
|
|
|
def _get_min_pair_stake_amount(self, pair: str, price: float) -> Optional[float]:
|
2019-03-05 18:45:10 +00:00
|
|
|
try:
|
|
|
|
market = self.exchange.markets[pair]
|
|
|
|
except KeyError:
|
|
|
|
raise ValueError(f"Can't get market information for symbol {pair}")
|
2018-06-16 23:23:12 +00:00
|
|
|
|
|
|
|
if 'limits' not in market:
|
|
|
|
return None
|
|
|
|
|
|
|
|
min_stake_amounts = []
|
2018-06-28 17:48:05 +00:00
|
|
|
limits = market['limits']
|
|
|
|
if ('cost' in limits and 'min' in limits['cost']
|
|
|
|
and limits['cost']['min'] is not None):
|
|
|
|
min_stake_amounts.append(limits['cost']['min'])
|
|
|
|
|
|
|
|
if ('amount' in limits and 'min' in limits['amount']
|
|
|
|
and limits['amount']['min'] is not None):
|
|
|
|
min_stake_amounts.append(limits['amount']['min'] * price)
|
2018-06-16 23:23:12 +00:00
|
|
|
|
|
|
|
if not min_stake_amounts:
|
|
|
|
return None
|
|
|
|
|
2019-02-16 16:50:55 +00:00
|
|
|
# reserve some percent defined in config (5% default) + stoploss
|
2019-02-19 08:45:19 +00:00
|
|
|
amount_reserve_percent = 1.0 - self.config.get('amount_reserve_percent',
|
|
|
|
constants.DEFAULT_AMOUNT_RESERVE_PERCENT)
|
2018-07-09 16:27:36 +00:00
|
|
|
if self.strategy.stoploss is not None:
|
|
|
|
amount_reserve_percent += self.strategy.stoploss
|
2018-06-16 23:23:12 +00:00
|
|
|
# it should not be more than 50%
|
|
|
|
amount_reserve_percent = max(amount_reserve_percent, 0.5)
|
2019-11-27 11:53:01 +00:00
|
|
|
|
|
|
|
# The value returned should satisfy both limits: for amount (base currency) and
|
|
|
|
# for cost (quote, stake currency), so max() is used here.
|
|
|
|
# See also #2575 at github.
|
2019-11-26 08:57:58 +00:00
|
|
|
return max(min_stake_amounts) / amount_reserve_percent
|
2018-06-16 23:23:12 +00:00
|
|
|
|
2019-12-29 01:17:49 +00:00
|
|
|
def create_trade(self, pair: str) -> bool:
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
2019-12-30 17:54:32 +00:00
|
|
|
Check the implemented trading strategy for buy signals.
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2019-12-30 17:54:32 +00:00
|
|
|
If the pair triggers the buy signal a new trade record gets created
|
|
|
|
and the buy-order opening the trade gets issued towards the exchange.
|
2019-04-03 17:51:46 +00:00
|
|
|
|
2019-12-29 01:17:49 +00:00
|
|
|
:return: True if a trade has been created.
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
2019-12-29 01:17:49 +00:00
|
|
|
logger.debug(f"create_trade for pair {pair}")
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2020-08-24 09:09:09 +00:00
|
|
|
analyzed_df, _ = self.dataprovider.get_analyzed_dataframe(pair, self.strategy.timeframe)
|
|
|
|
if self.strategy.is_pair_locked(
|
|
|
|
pair, analyzed_df.iloc[-1]['date'] if len(analyzed_df) > 0 else None):
|
2019-12-29 01:17:49 +00:00
|
|
|
logger.info(f"Pair {pair} is currently locked.")
|
2019-04-01 11:08:03 +00:00
|
|
|
return False
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2020-03-20 04:48:53 +00:00
|
|
|
# get_free_open_trades is checked before create_trade is called
|
|
|
|
# but it is still used here to prevent opening too many trades within one iteration
|
2020-03-05 20:57:01 +00:00
|
|
|
if not self.get_free_open_trades():
|
|
|
|
logger.debug(f"Can't open a new trade for {pair}: max number of trades is reached.")
|
|
|
|
return False
|
|
|
|
|
2018-07-31 18:25:10 +00:00
|
|
|
# running get_signal on historical data fetched
|
2020-06-18 06:01:09 +00:00
|
|
|
(buy, sell) = self.strategy.get_signal(pair, self.strategy.timeframe, analyzed_df)
|
2018-09-26 14:36:41 +00:00
|
|
|
|
2019-12-29 01:17:49 +00:00
|
|
|
if buy and not sell:
|
|
|
|
stake_amount = self.get_trade_stake_amount(pair)
|
|
|
|
if not stake_amount:
|
2020-02-08 20:02:52 +00:00
|
|
|
logger.debug(f"Stake amount is 0, ignoring possible trade for {pair}.")
|
2019-12-29 01:17:49 +00:00
|
|
|
return False
|
2018-09-26 14:36:41 +00:00
|
|
|
|
2019-12-29 01:17:49 +00:00
|
|
|
logger.info(f"Buy signal found: about create a new trade with stake_amount: "
|
|
|
|
f"{stake_amount} ...")
|
2018-07-31 18:25:10 +00:00
|
|
|
|
2019-12-30 13:00:34 +00:00
|
|
|
bid_check_dom = self.config.get('bid_strategy', {}).get('check_depth_of_market', {})
|
|
|
|
if ((bid_check_dom.get('enabled', False)) and
|
|
|
|
(bid_check_dom.get('bids_to_ask_delta', 0) > 0)):
|
|
|
|
if self._check_depth_of_market_buy(pair, bid_check_dom):
|
2020-02-11 14:49:57 +00:00
|
|
|
logger.info(f'Executing Buy for {pair}.')
|
2019-12-29 01:17:49 +00:00
|
|
|
return self.execute_buy(pair, stake_amount)
|
|
|
|
else:
|
|
|
|
return False
|
2019-08-13 08:01:29 +00:00
|
|
|
|
2020-02-11 15:14:49 +00:00
|
|
|
logger.info(f'Executing Buy for {pair}')
|
2019-12-29 01:17:49 +00:00
|
|
|
return self.execute_buy(pair, stake_amount)
|
|
|
|
else:
|
|
|
|
return False
|
2018-07-10 13:10:56 +00:00
|
|
|
|
2018-08-07 10:29:37 +00:00
|
|
|
def _check_depth_of_market_buy(self, pair: str, conf: Dict) -> bool:
|
2018-08-05 04:41:06 +00:00
|
|
|
"""
|
|
|
|
Checks depth of market before executing a buy
|
|
|
|
"""
|
2018-08-07 10:29:37 +00:00
|
|
|
conf_bids_to_ask_delta = conf.get('bids_to_ask_delta', 0)
|
2020-02-04 00:57:24 +00:00
|
|
|
logger.info(f"Checking depth of market for {pair} ...")
|
2020-05-26 18:27:35 +00:00
|
|
|
order_book = self.exchange.fetch_l2_order_book(pair, 1000)
|
2018-08-05 13:08:07 +00:00
|
|
|
order_book_data_frame = order_book_to_dataframe(order_book['bids'], order_book['asks'])
|
2018-08-05 04:41:06 +00:00
|
|
|
order_book_bids = order_book_data_frame['b_size'].sum()
|
|
|
|
order_book_asks = order_book_data_frame['a_size'].sum()
|
|
|
|
bids_ask_delta = order_book_bids / order_book_asks
|
2020-01-28 16:09:44 +00:00
|
|
|
logger.info(
|
2020-02-04 00:57:24 +00:00
|
|
|
f"Bids: {order_book_bids}, Asks: {order_book_asks}, Delta: {bids_ask_delta}, "
|
|
|
|
f"Bid Price: {order_book['bids'][0][0]}, Ask Price: {order_book['asks'][0][0]}, "
|
|
|
|
f"Immediate Bid Quantity: {order_book['bids'][0][1]}, "
|
|
|
|
f"Immediate Ask Quantity: {order_book['asks'][0][1]}."
|
2020-01-28 16:09:44 +00:00
|
|
|
)
|
2018-08-05 04:41:06 +00:00
|
|
|
if bids_ask_delta >= conf_bids_to_ask_delta:
|
2020-02-04 00:57:24 +00:00
|
|
|
logger.info(f"Bids to asks delta for {pair} DOES satisfy condition.")
|
2018-08-05 04:41:06 +00:00
|
|
|
return True
|
2020-01-25 03:17:41 +00:00
|
|
|
else:
|
2020-02-04 00:57:24 +00:00
|
|
|
logger.info(f"Bids to asks delta for {pair} does not satisfy condition.")
|
2020-01-25 03:17:41 +00:00
|
|
|
return False
|
2018-07-10 13:10:56 +00:00
|
|
|
|
2018-10-09 05:06:11 +00:00
|
|
|
def execute_buy(self, pair: str, stake_amount: float, price: Optional[float] = None) -> bool:
|
2018-07-10 13:10:56 +00:00
|
|
|
"""
|
|
|
|
Executes a limit buy for the given pair
|
|
|
|
:param pair: pair for which we want to create a LIMIT_BUY
|
2020-02-08 20:31:36 +00:00
|
|
|
:return: True if a buy order is created, false if it fails.
|
2018-07-10 13:10:56 +00:00
|
|
|
"""
|
2018-12-09 14:59:05 +00:00
|
|
|
time_in_force = self.strategy.order_time_in_force['buy']
|
2018-09-26 14:36:41 +00:00
|
|
|
|
2018-10-09 05:06:11 +00:00
|
|
|
if price:
|
2018-12-10 17:52:24 +00:00
|
|
|
buy_limit_requested = price
|
2018-10-09 05:06:11 +00:00
|
|
|
else:
|
2020-01-02 00:16:18 +00:00
|
|
|
# Calculate price
|
2020-02-08 20:02:52 +00:00
|
|
|
buy_limit_requested = self.get_buy_rate(pair, True)
|
2018-09-26 14:36:41 +00:00
|
|
|
|
2019-12-27 22:34:31 +00:00
|
|
|
min_stake_amount = self._get_min_pair_stake_amount(pair, buy_limit_requested)
|
2018-06-16 23:23:12 +00:00
|
|
|
if min_stake_amount is not None and min_stake_amount > stake_amount:
|
|
|
|
logger.warning(
|
2019-12-27 22:34:31 +00:00
|
|
|
f"Can't open a new trade for {pair}: stake amount "
|
2019-08-25 18:38:51 +00:00
|
|
|
f"is too small ({stake_amount} < {min_stake_amount})"
|
2018-06-16 23:23:12 +00:00
|
|
|
)
|
|
|
|
return False
|
|
|
|
|
2018-12-10 17:52:24 +00:00
|
|
|
amount = stake_amount / buy_limit_requested
|
2019-06-17 04:55:54 +00:00
|
|
|
order_type = self.strategy.order_types['buy']
|
2020-06-14 08:08:19 +00:00
|
|
|
if not strategy_safe_wrapper(self.strategy.confirm_trade_entry, default_retval=True)(
|
|
|
|
pair=pair, order_type=order_type, amount=amount, rate=buy_limit_requested,
|
|
|
|
time_in_force=time_in_force):
|
|
|
|
logger.info(f"User requested abortion of buying {pair}")
|
|
|
|
return False
|
2020-07-15 18:28:07 +00:00
|
|
|
amount = self.exchange.amount_to_precision(pair, amount)
|
2019-06-17 04:55:54 +00:00
|
|
|
order = self.exchange.buy(pair=pair, ordertype=order_type,
|
2018-12-10 17:52:24 +00:00
|
|
|
amount=amount, rate=buy_limit_requested,
|
2018-12-09 14:59:05 +00:00
|
|
|
time_in_force=time_in_force)
|
2020-08-13 14:14:28 +00:00
|
|
|
order_obj = Order.parse_from_ccxt_object(order, pair, 'buy')
|
2018-11-27 18:05:59 +00:00
|
|
|
order_id = order['id']
|
2018-12-09 14:59:05 +00:00
|
|
|
order_status = order.get('status', None)
|
2018-11-27 18:05:59 +00:00
|
|
|
|
2018-12-10 17:52:24 +00:00
|
|
|
# we assume the order is executed at the price requested
|
|
|
|
buy_limit_filled_price = buy_limit_requested
|
2020-07-15 18:20:14 +00:00
|
|
|
amount_requested = amount
|
2018-12-10 17:52:24 +00:00
|
|
|
|
2018-12-09 14:59:05 +00:00
|
|
|
if order_status == 'expired' or order_status == 'rejected':
|
2018-11-29 12:22:41 +00:00
|
|
|
order_tif = self.strategy.order_time_in_force['buy']
|
2018-12-09 14:59:05 +00:00
|
|
|
|
2018-12-12 12:33:03 +00:00
|
|
|
# return false if the order is not filled
|
2018-12-09 14:59:05 +00:00
|
|
|
if float(order['filled']) == 0:
|
|
|
|
logger.warning('Buy %s order with time in force %s for %s is %s by %s.'
|
|
|
|
' zero amount is fulfilled.',
|
2019-12-27 22:34:31 +00:00
|
|
|
order_tif, order_type, pair, order_status, self.exchange.name)
|
2018-12-09 14:59:05 +00:00
|
|
|
return False
|
2018-12-10 17:52:24 +00:00
|
|
|
else:
|
|
|
|
# the order is partially fulfilled
|
|
|
|
# in case of IOC orders we can check immediately
|
|
|
|
# if the order is fulfilled fully or partially
|
2018-12-09 14:59:05 +00:00
|
|
|
logger.warning('Buy %s order with time in force %s for %s is %s by %s.'
|
|
|
|
' %s amount fulfilled out of %s (%s remaining which is canceled).',
|
2019-12-27 22:34:31 +00:00
|
|
|
order_tif, order_type, pair, order_status, self.exchange.name,
|
2018-12-09 14:59:05 +00:00
|
|
|
order['filled'], order['amount'], order['remaining']
|
|
|
|
)
|
2018-12-12 12:05:55 +00:00
|
|
|
stake_amount = order['cost']
|
2020-08-12 13:32:56 +00:00
|
|
|
amount = safe_value_fallback(order, 'filled', 'amount')
|
2020-07-20 17:39:12 +00:00
|
|
|
buy_limit_filled_price = safe_value_fallback(order, 'average', 'price')
|
2018-12-10 17:52:24 +00:00
|
|
|
|
|
|
|
# in case of FOK the order may be filled immediately and fully
|
2018-12-12 12:05:55 +00:00
|
|
|
elif order_status == 'closed':
|
|
|
|
stake_amount = order['cost']
|
2020-07-15 19:02:31 +00:00
|
|
|
amount = safe_value_fallback(order, 'filled', 'amount')
|
2020-07-20 17:39:12 +00:00
|
|
|
buy_limit_filled_price = safe_value_fallback(order, 'average', 'price')
|
2018-11-27 18:05:59 +00:00
|
|
|
|
2018-02-04 09:21:16 +00:00
|
|
|
# Fee is applied twice because we make a LIMIT_BUY and LIMIT_SELL
|
2018-06-17 10:41:33 +00:00
|
|
|
fee = self.exchange.get_fee(symbol=pair, taker_or_maker='maker')
|
2018-02-04 09:21:16 +00:00
|
|
|
trade = Trade(
|
|
|
|
pair=pair,
|
|
|
|
stake_amount=stake_amount,
|
|
|
|
amount=amount,
|
2020-07-15 18:20:14 +00:00
|
|
|
amount_requested=amount_requested,
|
2018-04-21 17:47:08 +00:00
|
|
|
fee_open=fee,
|
|
|
|
fee_close=fee,
|
2018-12-10 17:52:24 +00:00
|
|
|
open_rate=buy_limit_filled_price,
|
|
|
|
open_rate_requested=buy_limit_requested,
|
2018-02-04 09:21:16 +00:00
|
|
|
open_date=datetime.utcnow(),
|
2018-06-18 20:20:50 +00:00
|
|
|
exchange=self.exchange.id,
|
2018-07-12 18:38:57 +00:00
|
|
|
open_order_id=order_id,
|
2018-07-19 17:41:42 +00:00
|
|
|
strategy=self.strategy.get_strategy_name(),
|
2020-06-02 08:02:24 +00:00
|
|
|
timeframe=timeframe_to_minutes(self.config['timeframe'])
|
2018-02-04 09:21:16 +00:00
|
|
|
)
|
2020-08-13 07:34:53 +00:00
|
|
|
trade.orders.append(order_obj)
|
2018-11-22 16:02:02 +00:00
|
|
|
|
2019-03-31 17:41:17 +00:00
|
|
|
# Update fees if order is closed
|
2019-03-31 13:40:16 +00:00
|
|
|
if order_status == 'closed':
|
2020-08-21 05:17:52 +00:00
|
|
|
self.update_trade_state(trade, order_id, order)
|
2019-03-31 13:40:16 +00:00
|
|
|
|
2018-02-04 09:21:16 +00:00
|
|
|
Trade.session.add(trade)
|
|
|
|
Trade.session.flush()
|
2018-11-17 20:22:54 +00:00
|
|
|
|
|
|
|
# Updating wallets
|
|
|
|
self.wallets.update()
|
|
|
|
|
2020-02-14 03:23:03 +00:00
|
|
|
self._notify_buy(trade, order_type)
|
|
|
|
|
2018-02-04 09:21:16 +00:00
|
|
|
return True
|
|
|
|
|
2020-02-02 04:00:40 +00:00
|
|
|
def _notify_buy(self, trade: Trade, order_type: str) -> None:
|
2020-01-02 10:51:25 +00:00
|
|
|
"""
|
|
|
|
Sends rpc notification when a buy occured.
|
|
|
|
"""
|
|
|
|
msg = {
|
2020-07-20 17:50:29 +00:00
|
|
|
'trade_id': trade.id,
|
2020-01-02 10:51:25 +00:00
|
|
|
'type': RPCMessageType.BUY_NOTIFICATION,
|
|
|
|
'exchange': self.exchange.name.capitalize(),
|
|
|
|
'pair': trade.pair,
|
|
|
|
'limit': trade.open_rate,
|
|
|
|
'order_type': order_type,
|
|
|
|
'stake_amount': trade.stake_amount,
|
2020-01-02 11:38:25 +00:00
|
|
|
'stake_currency': self.config['stake_currency'],
|
|
|
|
'fiat_currency': self.config.get('fiat_display_currency', None),
|
2020-02-08 20:02:52 +00:00
|
|
|
'amount': trade.amount,
|
|
|
|
'open_date': trade.open_date or datetime.utcnow(),
|
|
|
|
'current_rate': trade.open_rate_requested,
|
|
|
|
}
|
|
|
|
|
|
|
|
# Send the message
|
|
|
|
self.rpc.send_msg(msg)
|
|
|
|
|
2020-08-26 20:17:43 +00:00
|
|
|
def _notify_buy_cancel(self, trade: Trade, order_type: str, reason: str) -> None:
|
2020-02-08 20:02:52 +00:00
|
|
|
"""
|
|
|
|
Sends rpc notification when a buy cancel occured.
|
|
|
|
"""
|
2020-02-22 10:16:20 +00:00
|
|
|
current_rate = self.get_buy_rate(trade.pair, False)
|
2020-02-08 20:02:52 +00:00
|
|
|
|
|
|
|
msg = {
|
2020-07-20 17:50:29 +00:00
|
|
|
'trade_id': trade.id,
|
2020-02-08 20:02:52 +00:00
|
|
|
'type': RPCMessageType.BUY_CANCEL_NOTIFICATION,
|
|
|
|
'exchange': self.exchange.name.capitalize(),
|
|
|
|
'pair': trade.pair,
|
2020-02-11 14:45:35 +00:00
|
|
|
'limit': trade.open_rate,
|
2020-02-08 20:02:52 +00:00
|
|
|
'order_type': order_type,
|
|
|
|
'stake_amount': trade.stake_amount,
|
|
|
|
'stake_currency': self.config['stake_currency'],
|
|
|
|
'fiat_currency': self.config.get('fiat_display_currency', None),
|
|
|
|
'amount': trade.amount,
|
|
|
|
'open_date': trade.open_date,
|
|
|
|
'current_rate': current_rate,
|
2020-08-26 20:17:43 +00:00
|
|
|
'reason': reason,
|
2020-01-02 10:51:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
# Send the message
|
|
|
|
self.rpc.send_msg(msg)
|
|
|
|
|
2020-01-01 23:53:25 +00:00
|
|
|
#
|
2020-01-02 08:50:54 +00:00
|
|
|
# SELL / exit positions / close trades logic and methods
|
2020-01-01 23:53:25 +00:00
|
|
|
#
|
2019-12-30 18:09:35 +00:00
|
|
|
|
2019-12-30 19:08:36 +00:00
|
|
|
def exit_positions(self, trades: List[Any]) -> int:
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
2019-12-30 19:08:36 +00:00
|
|
|
Tries to execute sell orders for open trades (positions)
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
2019-12-30 18:09:35 +00:00
|
|
|
trades_closed = 0
|
2019-10-02 00:27:17 +00:00
|
|
|
for trade in trades:
|
|
|
|
try:
|
|
|
|
|
2019-10-02 15:38:00 +00:00
|
|
|
if (self.strategy.order_types.get('stoploss_on_exchange') and
|
|
|
|
self.handle_stoploss_on_exchange(trade)):
|
2019-12-30 18:09:35 +00:00
|
|
|
trades_closed += 1
|
2019-10-02 15:38:00 +00:00
|
|
|
continue
|
|
|
|
# Check if we can sell our current pair
|
2020-05-01 15:46:01 +00:00
|
|
|
if trade.open_order_id is None and trade.is_open and self.handle_trade(trade):
|
2019-12-30 18:09:35 +00:00
|
|
|
trades_closed += 1
|
2019-10-02 00:27:17 +00:00
|
|
|
|
|
|
|
except DependencyException as exception:
|
2020-08-02 08:12:15 +00:00
|
|
|
logger.warning('Unable to sell trade %s: %s', trade.pair, exception)
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2019-10-02 15:38:00 +00:00
|
|
|
# Updating wallets if any trade occured
|
2019-12-30 18:09:35 +00:00
|
|
|
if trades_closed:
|
2019-10-02 15:38:00 +00:00
|
|
|
self.wallets.update()
|
|
|
|
|
2019-12-30 18:09:35 +00:00
|
|
|
return trades_closed
|
|
|
|
|
2020-02-23 14:39:12 +00:00
|
|
|
def _order_book_gen(self, pair: str, side: str, order_book_max: int = 1,
|
|
|
|
order_book_min: int = 1):
|
|
|
|
"""
|
|
|
|
Helper generator to query orderbook in loop (used for early sell-order placing)
|
|
|
|
"""
|
2020-05-26 18:27:35 +00:00
|
|
|
order_book = self.exchange.fetch_l2_order_book(pair, order_book_max)
|
2020-02-23 14:39:12 +00:00
|
|
|
for i in range(order_book_min, order_book_max + 1):
|
|
|
|
yield order_book[side][i - 1][0]
|
|
|
|
|
2019-03-16 12:24:10 +00:00
|
|
|
def get_sell_rate(self, pair: str, refresh: bool) -> float:
|
|
|
|
"""
|
2020-03-08 10:35:31 +00:00
|
|
|
Get sell rate - either using ticker bid or first bid based on orderbook
|
2019-03-16 12:24:10 +00:00
|
|
|
The orderbook portion is only used for rpc messaging, which would otherwise fail
|
2019-12-18 15:34:30 +00:00
|
|
|
for BitMex (has no bid/ask in fetch_ticker)
|
2019-03-16 12:24:10 +00:00
|
|
|
or remain static in any other case since it's not updating.
|
2020-02-22 10:12:33 +00:00
|
|
|
:param pair: Pair to get rate for
|
|
|
|
:param refresh: allow cached data
|
2019-03-16 12:24:10 +00:00
|
|
|
:return: Bid rate
|
|
|
|
"""
|
2020-02-22 10:12:33 +00:00
|
|
|
if not refresh:
|
|
|
|
rate = self._sell_rate_cache.get(pair)
|
|
|
|
# Check if cache has been invalidated
|
|
|
|
if rate:
|
2020-08-23 17:14:28 +00:00
|
|
|
logger.debug(f"Using cached sell rate for {pair}.")
|
2020-02-22 10:12:33 +00:00
|
|
|
return rate
|
|
|
|
|
2020-03-05 19:44:29 +00:00
|
|
|
ask_strategy = self.config.get('ask_strategy', {})
|
|
|
|
if ask_strategy.get('use_order_book', False):
|
2020-02-26 18:49:54 +00:00
|
|
|
# This code is only used for notifications, selling uses the generator directly
|
2020-03-05 19:44:29 +00:00
|
|
|
logger.info(
|
|
|
|
f"Getting price from order book {ask_strategy['price_side'].capitalize()} side."
|
|
|
|
)
|
2020-05-26 18:14:05 +00:00
|
|
|
try:
|
|
|
|
rate = next(self._order_book_gen(pair, f"{ask_strategy['price_side']}s"))
|
|
|
|
except (IndexError, KeyError) as e:
|
2020-05-27 05:11:59 +00:00
|
|
|
logger.warning("Sell Price at location from orderbook could not be determined.")
|
2020-05-26 18:35:11 +00:00
|
|
|
raise PricingError from e
|
2019-03-16 12:24:10 +00:00
|
|
|
else:
|
2020-03-05 19:44:29 +00:00
|
|
|
rate = self.exchange.fetch_ticker(pair)[ask_strategy['price_side']]
|
2020-06-01 17:45:37 +00:00
|
|
|
if rate is None:
|
|
|
|
raise PricingError(f"Sell-Rate for {pair} was empty.")
|
2020-02-22 10:12:33 +00:00
|
|
|
self._sell_rate_cache[pair] = rate
|
2019-03-16 12:24:10 +00:00
|
|
|
return rate
|
|
|
|
|
2018-03-15 22:48:22 +00:00
|
|
|
def handle_trade(self, trade: Trade) -> bool:
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
|
|
|
Sells the current pair if the threshold is reached and updates the trade record.
|
|
|
|
:return: True if trade has been sold, False otherwise
|
|
|
|
"""
|
|
|
|
if not trade.is_open:
|
2019-10-02 15:38:00 +00:00
|
|
|
raise DependencyException(f'Attempt to handle closed trade: {trade}')
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2018-03-25 19:37:14 +00:00
|
|
|
logger.debug('Handling %s ...', trade)
|
2018-02-04 09:21:16 +00:00
|
|
|
|
|
|
|
(buy, sell) = (False, False)
|
2019-10-05 10:29:59 +00:00
|
|
|
|
|
|
|
config_ask_strategy = self.config.get('ask_strategy', {})
|
|
|
|
|
|
|
|
if (config_ask_strategy.get('use_sell_signal', True) or
|
2020-03-05 21:14:05 +00:00
|
|
|
config_ask_strategy.get('ignore_roi_if_buy_signal', False)):
|
2020-06-18 06:01:09 +00:00
|
|
|
analyzed_df, _ = self.dataprovider.get_analyzed_dataframe(trade.pair,
|
|
|
|
self.strategy.timeframe)
|
|
|
|
|
|
|
|
(buy, sell) = self.strategy.get_signal(trade.pair, self.strategy.timeframe, analyzed_df)
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2018-08-29 09:38:43 +00:00
|
|
|
if config_ask_strategy.get('use_order_book', False):
|
|
|
|
order_book_min = config_ask_strategy.get('order_book_min', 1)
|
|
|
|
order_book_max = config_ask_strategy.get('order_book_max', 1)
|
2020-06-05 18:24:21 +00:00
|
|
|
logger.debug(f'Using order book between {order_book_min} and {order_book_max} '
|
|
|
|
f'for selling {trade.pair}...')
|
2018-08-05 04:41:06 +00:00
|
|
|
|
2020-02-23 14:39:12 +00:00
|
|
|
order_book = self._order_book_gen(trade.pair, f"{config_ask_strategy['price_side']}s",
|
|
|
|
order_book_min=order_book_min,
|
|
|
|
order_book_max=order_book_max)
|
2018-08-05 04:41:06 +00:00
|
|
|
for i in range(order_book_min, order_book_max + 1):
|
2020-05-26 18:14:05 +00:00
|
|
|
try:
|
|
|
|
sell_rate = next(order_book)
|
|
|
|
except (IndexError, KeyError) as e:
|
|
|
|
logger.warning(
|
|
|
|
f"Sell Price at location {i} from orderbook could not be determined."
|
|
|
|
)
|
2020-05-26 18:35:11 +00:00
|
|
|
raise PricingError from e
|
2020-03-03 18:36:03 +00:00
|
|
|
logger.debug(f" order book {config_ask_strategy['price_side']} top {i}: "
|
|
|
|
f"{sell_rate:0.8f}")
|
2020-05-30 08:59:26 +00:00
|
|
|
# Assign sell-rate to cache - otherwise sell-rate is never updated in the cache,
|
|
|
|
# resulting in outdated RPC messages
|
|
|
|
self._sell_rate_cache[trade.pair] = sell_rate
|
2018-08-05 04:41:06 +00:00
|
|
|
|
2019-06-27 19:29:17 +00:00
|
|
|
if self._check_and_execute_sell(trade, sell_rate, buy, sell):
|
2018-08-05 04:41:06 +00:00
|
|
|
return True
|
2019-01-16 19:03:34 +00:00
|
|
|
|
2018-08-05 04:41:06 +00:00
|
|
|
else:
|
2018-11-30 13:14:31 +00:00
|
|
|
logger.debug('checking sell')
|
2019-03-16 12:24:10 +00:00
|
|
|
sell_rate = self.get_sell_rate(trade.pair, True)
|
2019-06-27 19:29:17 +00:00
|
|
|
if self._check_and_execute_sell(trade, sell_rate, buy, sell):
|
2018-08-05 04:41:06 +00:00
|
|
|
return True
|
|
|
|
|
2018-12-01 09:01:11 +00:00
|
|
|
logger.debug('Found no sell signal for %s.', trade)
|
2018-08-05 04:41:06 +00:00
|
|
|
return False
|
|
|
|
|
2020-08-12 09:21:00 +00:00
|
|
|
def create_stoploss_order(self, trade: Trade, stop_price: float) -> bool:
|
2019-08-31 14:11:04 +00:00
|
|
|
"""
|
|
|
|
Abstracts creating stoploss orders from the logic.
|
|
|
|
Handles errors and updates the trade database object.
|
2019-09-01 08:25:05 +00:00
|
|
|
Force-sells the pair (using EmergencySell reason) in case of Problems creating the order.
|
2019-08-31 14:11:04 +00:00
|
|
|
:return: True if the order succeeded, and False in case of problems.
|
|
|
|
"""
|
|
|
|
try:
|
2020-01-19 12:30:56 +00:00
|
|
|
stoploss_order = self.exchange.stoploss(pair=trade.pair, amount=trade.amount,
|
|
|
|
stop_price=stop_price,
|
|
|
|
order_types=self.strategy.order_types)
|
2020-08-13 07:34:53 +00:00
|
|
|
|
2020-08-13 14:14:28 +00:00
|
|
|
order_obj = Order.parse_from_ccxt_object(stoploss_order, trade.pair, 'stoploss')
|
2020-08-13 07:34:53 +00:00
|
|
|
trade.orders.append(order_obj)
|
2019-08-31 14:11:04 +00:00
|
|
|
trade.stoploss_order_id = str(stoploss_order['id'])
|
|
|
|
return True
|
2020-08-14 08:59:55 +00:00
|
|
|
except InsufficientFundsError as e:
|
|
|
|
logger.warning(f"Unable to place stoploss order {e}.")
|
2020-08-22 13:48:00 +00:00
|
|
|
# Try to figure out what went wrong
|
2020-09-14 15:34:13 +00:00
|
|
|
self.handle_insufficient_funds(trade)
|
2020-08-14 08:59:55 +00:00
|
|
|
|
2019-09-01 08:17:36 +00:00
|
|
|
except InvalidOrderException as e:
|
2019-09-01 07:08:35 +00:00
|
|
|
trade.stoploss_order_id = None
|
2019-09-01 08:17:36 +00:00
|
|
|
logger.error(f'Unable to place a stoploss order on exchange. {e}')
|
2019-09-01 07:08:35 +00:00
|
|
|
logger.warning('Selling the trade forcefully')
|
|
|
|
self.execute_sell(trade, trade.stop_loss, sell_reason=SellType.EMERGENCY_SELL)
|
|
|
|
|
2020-06-28 14:01:40 +00:00
|
|
|
except ExchangeError:
|
2019-08-31 14:11:04 +00:00
|
|
|
trade.stoploss_order_id = None
|
|
|
|
logger.exception('Unable to place a stoploss order on exchange.')
|
2019-09-01 07:21:45 +00:00
|
|
|
return False
|
2019-08-31 14:11:04 +00:00
|
|
|
|
2018-11-24 16:08:12 +00:00
|
|
|
def handle_stoploss_on_exchange(self, trade: Trade) -> bool:
|
2018-11-24 16:10:51 +00:00
|
|
|
"""
|
|
|
|
Check if trade is fulfilled in which case the stoploss
|
2019-01-08 12:44:51 +00:00
|
|
|
on exchange should be added immediately if stoploss on exchange
|
2018-11-24 16:10:51 +00:00
|
|
|
is enabled.
|
|
|
|
"""
|
|
|
|
|
2019-04-04 15:13:54 +00:00
|
|
|
logger.debug('Handling stoploss on exchange %s ...', trade)
|
|
|
|
|
2019-04-05 18:20:16 +00:00
|
|
|
stoploss_order = None
|
|
|
|
|
2019-03-31 13:41:10 +00:00
|
|
|
try:
|
2019-04-04 15:13:54 +00:00
|
|
|
# First we check if there is already a stoploss on exchange
|
2020-06-28 14:30:24 +00:00
|
|
|
stoploss_order = self.exchange.fetch_stoploss_order(
|
|
|
|
trade.stoploss_order_id, trade.pair) if trade.stoploss_order_id else None
|
2019-04-05 18:20:16 +00:00
|
|
|
except InvalidOrderException as exception:
|
2019-04-04 15:13:54 +00:00
|
|
|
logger.warning('Unable to fetch stoploss order: %s', exception)
|
|
|
|
|
2020-08-13 13:39:29 +00:00
|
|
|
if stoploss_order:
|
|
|
|
trade.update_order(stoploss_order)
|
|
|
|
|
2020-01-23 18:40:31 +00:00
|
|
|
# We check if stoploss order is fulfilled
|
2020-03-25 16:01:11 +00:00
|
|
|
if stoploss_order and stoploss_order['status'] in ('closed', 'triggered'):
|
2020-01-23 18:40:31 +00:00
|
|
|
trade.sell_reason = SellType.STOPLOSS_ON_EXCHANGE.value
|
2020-08-22 07:30:25 +00:00
|
|
|
self.update_trade_state(trade, trade.stoploss_order_id, stoploss_order,
|
|
|
|
stoploss_order=True)
|
2020-01-23 18:40:31 +00:00
|
|
|
# Lock pair for one candle to prevent immediate rebuys
|
2020-10-17 09:28:34 +00:00
|
|
|
self.strategy.lock_pair(trade.pair, timeframe_to_next_date(self.config['timeframe']),
|
2020-10-20 17:39:38 +00:00
|
|
|
reason='Auto lock')
|
2020-01-23 18:40:31 +00:00
|
|
|
self._notify_sell(trade, "stoploss")
|
|
|
|
return True
|
|
|
|
|
2020-01-23 19:36:48 +00:00
|
|
|
if trade.open_order_id or not trade.is_open:
|
2020-01-23 19:24:23 +00:00
|
|
|
# Trade has an open Buy or Sell order, Stoploss-handling can't happen in this case
|
|
|
|
# as the Amount on the exchange is tied up in another trade.
|
2020-01-23 19:36:48 +00:00
|
|
|
# The trade can be closed already (sell-order fill confirmation came in this iteration)
|
2020-01-23 19:24:23 +00:00
|
|
|
return False
|
|
|
|
|
2019-04-05 18:20:16 +00:00
|
|
|
# If buy order is fulfilled but there is no stoploss, we add a stoploss on exchange
|
2020-06-13 22:42:45 +00:00
|
|
|
if not stoploss_order:
|
2019-08-31 14:15:39 +00:00
|
|
|
stoploss = self.edge.stoploss(pair=trade.pair) if self.edge else self.strategy.stoploss
|
2019-04-04 15:13:54 +00:00
|
|
|
stop_price = trade.open_rate * (1 + stoploss)
|
2019-03-31 13:41:10 +00:00
|
|
|
|
2020-08-12 09:21:00 +00:00
|
|
|
if self.create_stoploss_order(trade=trade, stop_price=stop_price):
|
2020-09-01 05:10:48 +00:00
|
|
|
trade.stoploss_last_update = datetime.utcnow()
|
2019-04-04 15:13:54 +00:00
|
|
|
return False
|
2019-03-31 13:41:10 +00:00
|
|
|
|
2019-04-04 15:13:54 +00:00
|
|
|
# If stoploss order is canceled for some reason we add it
|
2020-03-25 16:01:11 +00:00
|
|
|
if stoploss_order and stoploss_order['status'] in ('canceled', 'cancelled'):
|
2020-08-12 09:21:00 +00:00
|
|
|
if self.create_stoploss_order(trade=trade, stop_price=trade.stop_loss):
|
2019-04-04 15:13:54 +00:00
|
|
|
return False
|
2019-08-31 14:11:04 +00:00
|
|
|
else:
|
2019-08-24 16:06:14 +00:00
|
|
|
trade.stoploss_order_id = None
|
2019-08-31 14:11:04 +00:00
|
|
|
logger.warning('Stoploss order was cancelled, but unable to recreate one.')
|
2019-04-04 15:13:54 +00:00
|
|
|
|
|
|
|
# Finally we check if stoploss on exchange should be moved up because of trailing.
|
|
|
|
if stoploss_order and self.config.get('trailing_stop', False):
|
|
|
|
# if trailing stoploss is enabled we check if stoploss value has changed
|
|
|
|
# in which case we cancel stoploss order and put another one with new
|
|
|
|
# value immediately
|
|
|
|
self.handle_trailing_stoploss_on_exchange(trade, stoploss_order)
|
|
|
|
|
|
|
|
return False
|
2018-11-23 19:47:17 +00:00
|
|
|
|
2020-02-02 04:00:40 +00:00
|
|
|
def handle_trailing_stoploss_on_exchange(self, trade: Trade, order: dict) -> None:
|
2019-01-16 14:00:35 +00:00
|
|
|
"""
|
|
|
|
Check to see if stoploss on exchange should be updated
|
|
|
|
in case of trailing stoploss on exchange
|
|
|
|
:param Trade: Corresponding Trade
|
|
|
|
:param order: Current on exchange stoploss order
|
|
|
|
:return: None
|
|
|
|
"""
|
2020-01-19 18:54:30 +00:00
|
|
|
if self.exchange.stoploss_adjust(trade.stop_loss, order):
|
2019-01-16 11:16:32 +00:00
|
|
|
# we check if the update is neccesary
|
2019-01-18 11:02:29 +00:00
|
|
|
update_beat = self.strategy.order_types.get('stoploss_on_exchange_interval', 60)
|
2019-10-18 17:36:04 +00:00
|
|
|
if (datetime.utcnow() - trade.stoploss_last_update).total_seconds() >= update_beat:
|
2019-01-16 11:16:32 +00:00
|
|
|
# cancelling the current stoploss on exchange first
|
2020-08-24 04:56:56 +00:00
|
|
|
logger.info(f"Cancelling current stoploss on exchange for pair {trade.pair} "
|
|
|
|
f"(orderid:{order['id']}) in order to add another one ...")
|
2019-06-20 18:56:58 +00:00
|
|
|
try:
|
2020-08-14 09:25:20 +00:00
|
|
|
co = self.exchange.cancel_stoploss_order(order['id'], trade.pair)
|
|
|
|
trade.update_order(co)
|
2019-06-20 18:56:58 +00:00
|
|
|
except InvalidOrderException:
|
|
|
|
logger.exception(f"Could not cancel stoploss order {order['id']} "
|
|
|
|
f"for pair {trade.pair}")
|
|
|
|
|
2019-08-31 14:11:04 +00:00
|
|
|
# Create new stoploss order
|
2020-08-12 09:21:00 +00:00
|
|
|
if not self.create_stoploss_order(trade=trade, stop_price=trade.stop_loss):
|
2019-08-31 14:11:04 +00:00
|
|
|
logger.warning(f"Could not create trailing stoploss order "
|
|
|
|
f"for pair {trade.pair}.")
|
2019-01-16 11:16:32 +00:00
|
|
|
|
2019-06-27 19:29:17 +00:00
|
|
|
def _check_and_execute_sell(self, trade: Trade, sell_rate: float,
|
|
|
|
buy: bool, sell: bool) -> bool:
|
|
|
|
"""
|
|
|
|
Check and execute sell
|
|
|
|
"""
|
|
|
|
should_sell = self.strategy.should_sell(
|
2020-01-22 19:50:09 +00:00
|
|
|
trade, sell_rate, datetime.utcnow(), buy, sell,
|
|
|
|
force_stoploss=self.edge.stoploss(trade.pair) if self.edge else 0
|
2019-06-27 19:29:17 +00:00
|
|
|
)
|
2018-09-21 15:41:31 +00:00
|
|
|
|
2018-07-12 20:21:52 +00:00
|
|
|
if should_sell.sell_flag:
|
2020-02-11 14:49:57 +00:00
|
|
|
logger.info(f'Executing Sell for {trade.pair}. Reason: {should_sell.sell_type}')
|
2018-08-05 04:41:06 +00:00
|
|
|
self.execute_sell(trade, sell_rate, should_sell.sell_type)
|
2018-02-04 09:21:16 +00:00
|
|
|
return True
|
|
|
|
return False
|
|
|
|
|
2019-11-12 14:43:10 +00:00
|
|
|
def _check_timed_out(self, side: str, order: dict) -> bool:
|
|
|
|
"""
|
|
|
|
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
|
2019-11-13 18:38:38 +00:00
|
|
|
if timeout is not None:
|
2019-11-12 14:43:10 +00:00
|
|
|
timeout_threshold = arrow.utcnow().shift(minutes=-timeout).datetime
|
|
|
|
|
|
|
|
return (order['status'] == 'open' and order['side'] == side
|
|
|
|
and ordertime < timeout_threshold)
|
|
|
|
return False
|
|
|
|
|
2018-06-14 01:32:52 +00:00
|
|
|
def check_handle_timedout(self) -> None:
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
|
|
|
Check if any orders are timed out and cancel if neccessary
|
|
|
|
:param timeoutvalue: Number of minutes until order is considered timed out
|
|
|
|
:return: None
|
|
|
|
"""
|
|
|
|
|
2019-10-29 12:32:07 +00:00
|
|
|
for trade in Trade.get_open_order_trades():
|
2018-02-04 09:21:16 +00:00
|
|
|
try:
|
2018-06-08 00:34:44 +00:00
|
|
|
if not trade.open_order_id:
|
|
|
|
continue
|
2020-06-28 14:27:35 +00:00
|
|
|
order = self.exchange.fetch_order(trade.open_order_id, trade.pair)
|
2020-08-12 12:25:50 +00:00
|
|
|
except (ExchangeError):
|
2020-03-24 16:17:40 +00:00
|
|
|
logger.info('Cannot query order for %s due to %s', trade, traceback.format_exc())
|
2018-02-04 09:21:16 +00:00
|
|
|
continue
|
|
|
|
|
2020-08-21 05:17:52 +00:00
|
|
|
fully_cancelled = self.update_trade_state(trade, trade.open_order_id, order)
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2020-05-17 09:12:30 +00:00
|
|
|
if (order['side'] == 'buy' and (order['status'] == 'open' or fully_cancelled) and (
|
2020-05-17 08:53:07 +00:00
|
|
|
fully_cancelled
|
2020-02-06 19:30:17 +00:00
|
|
|
or self._check_timed_out('buy', order)
|
|
|
|
or strategy_safe_wrapper(self.strategy.check_buy_timeout,
|
|
|
|
default_retval=False)(pair=trade.pair,
|
|
|
|
trade=trade,
|
2020-02-25 18:55:23 +00:00
|
|
|
order=order))):
|
2020-04-24 22:16:52 +00:00
|
|
|
self.handle_cancel_buy(trade, order, constants.CANCEL_REASON['TIMEOUT'])
|
2019-10-18 05:01:05 +00:00
|
|
|
|
2020-05-17 09:12:30 +00:00
|
|
|
elif (order['side'] == 'sell' and (order['status'] == 'open' or fully_cancelled) and (
|
2020-05-17 08:53:07 +00:00
|
|
|
fully_cancelled
|
2020-02-21 19:35:07 +00:00
|
|
|
or self._check_timed_out('sell', order)
|
2020-02-21 19:27:13 +00:00
|
|
|
or strategy_safe_wrapper(self.strategy.check_sell_timeout,
|
|
|
|
default_retval=False)(pair=trade.pair,
|
|
|
|
trade=trade,
|
2020-02-25 18:55:23 +00:00
|
|
|
order=order))):
|
2020-04-24 22:16:52 +00:00
|
|
|
self.handle_cancel_sell(trade, order, constants.CANCEL_REASON['TIMEOUT'])
|
2019-02-03 12:39:05 +00:00
|
|
|
|
2020-04-24 22:16:52 +00:00
|
|
|
def cancel_all_open_orders(self) -> None:
|
|
|
|
"""
|
|
|
|
Cancel all orders that are currently open
|
|
|
|
:return: None
|
2019-11-20 19:08:12 +00:00
|
|
|
"""
|
2020-04-24 22:16:52 +00:00
|
|
|
|
|
|
|
for trade in Trade.get_open_order_trades():
|
|
|
|
try:
|
2020-06-28 14:27:35 +00:00
|
|
|
order = self.exchange.fetch_order(trade.open_order_id, trade.pair)
|
2020-08-12 12:25:50 +00:00
|
|
|
except (ExchangeError):
|
2020-04-24 22:16:52 +00:00
|
|
|
logger.info('Cannot query order for %s due to %s', trade, traceback.format_exc())
|
|
|
|
continue
|
|
|
|
|
|
|
|
if order['side'] == 'buy':
|
|
|
|
self.handle_cancel_buy(trade, order, constants.CANCEL_REASON['ALL_CANCELLED'])
|
|
|
|
|
|
|
|
elif order['side'] == 'sell':
|
|
|
|
self.handle_cancel_sell(trade, order, constants.CANCEL_REASON['ALL_CANCELLED'])
|
|
|
|
|
|
|
|
def handle_cancel_buy(self, trade: Trade, order: Dict, reason: str) -> bool:
|
|
|
|
"""
|
|
|
|
Buy cancel - cancel order
|
2018-02-04 09:21:16 +00:00
|
|
|
:return: True if order was fully cancelled
|
|
|
|
"""
|
2020-04-24 22:16:52 +00:00
|
|
|
was_trade_fully_canceled = False
|
|
|
|
|
2020-05-07 04:51:02 +00:00
|
|
|
# Cancelled orders may have the status of 'canceled' or 'closed'
|
2020-05-05 05:08:24 +00:00
|
|
|
if order['status'] not in ('canceled', 'closed'):
|
2020-04-17 17:55:53 +00:00
|
|
|
corder = self.exchange.cancel_order_with_result(trade.open_order_id, trade.pair,
|
|
|
|
trade.amount)
|
2020-08-01 13:59:50 +00:00
|
|
|
# Avoid race condition where the order could not be cancelled coz its already filled.
|
|
|
|
# Simply bailing here is the only safe way - as this order will then be
|
|
|
|
# handled in the next iteration.
|
|
|
|
if corder.get('status') not in ('canceled', 'closed'):
|
|
|
|
logger.warning(f"Order {trade.open_order_id} for {trade.pair} not cancelled.")
|
|
|
|
return False
|
2019-10-18 05:01:05 +00:00
|
|
|
else:
|
|
|
|
# Order was cancelled already, so we can reuse the existing dict
|
|
|
|
corder = order
|
2020-04-24 22:16:52 +00:00
|
|
|
reason = constants.CANCEL_REASON['CANCELLED_ON_EXCHANGE']
|
2019-10-18 05:01:05 +00:00
|
|
|
|
2020-04-17 15:53:56 +00:00
|
|
|
logger.info('Buy order %s for %s.', reason, trade)
|
2019-10-18 05:01:05 +00:00
|
|
|
|
2020-05-07 04:51:02 +00:00
|
|
|
# Using filled to determine the filled amount
|
2020-07-15 17:49:51 +00:00
|
|
|
filled_amount = safe_value_fallback2(corder, order, 'filled', 'filled')
|
2020-05-07 04:51:02 +00:00
|
|
|
if isclose(filled_amount, 0.0, abs_tol=constants.MATH_CLOSE_PREC):
|
2020-04-16 18:19:34 +00:00
|
|
|
logger.info('Buy order fully cancelled. Removing %s from database.', trade)
|
2018-02-04 09:21:16 +00:00
|
|
|
# if trade is not partially completed, just delete the trade
|
2020-09-06 12:27:36 +00:00
|
|
|
trade.delete()
|
2020-04-24 22:16:52 +00:00
|
|
|
was_trade_fully_canceled = True
|
2020-08-26 20:17:43 +00:00
|
|
|
reason += f", {constants.CANCEL_REASON['FULLY_CANCELLED']}"
|
2020-04-24 22:16:52 +00:00
|
|
|
else:
|
|
|
|
# if trade is partially complete, edit the stake details for the trade
|
|
|
|
# and close the order
|
|
|
|
# cancel_order may not contain the full order dict, so we need to fallback
|
|
|
|
# to the order dict aquired before cancelling.
|
|
|
|
# we need to fall back to the values from order if corder does not contain these keys.
|
2020-05-16 11:09:38 +00:00
|
|
|
trade.amount = filled_amount
|
2020-04-24 22:16:52 +00:00
|
|
|
trade.stake_amount = trade.amount * trade.open_rate
|
2020-09-19 07:37:11 +00:00
|
|
|
self.update_trade_state(trade, trade.open_order_id, corder)
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2020-04-24 22:16:52 +00:00
|
|
|
trade.open_order_id = None
|
|
|
|
logger.info('Partial buy order timeout for %s.', trade)
|
2020-08-26 20:17:43 +00:00
|
|
|
reason += f", {constants.CANCEL_REASON['PARTIALLY_FILLED']}"
|
2020-04-24 22:16:52 +00:00
|
|
|
|
|
|
|
self.wallets.update()
|
2020-08-26 20:17:43 +00:00
|
|
|
self._notify_buy_cancel(trade, order_type=self.strategy.order_types['buy'],
|
|
|
|
reason=reason)
|
2020-04-24 22:16:52 +00:00
|
|
|
return was_trade_fully_canceled
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2020-04-24 22:16:52 +00:00
|
|
|
def handle_cancel_sell(self, trade: Trade, order: Dict, reason: str) -> str:
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
2020-04-24 22:16:52 +00:00
|
|
|
Sell cancel - cancel order and update trade
|
2020-03-24 16:12:24 +00:00
|
|
|
:return: Reason for cancel
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
2020-05-16 11:09:38 +00:00
|
|
|
# if trade is not partially completed, just cancel the order
|
2020-03-24 16:20:16 +00:00
|
|
|
if order['remaining'] == order['amount'] or order.get('filled') == 0.0:
|
2020-03-24 16:17:40 +00:00
|
|
|
if not self.exchange.check_order_canceled_empty(order):
|
2020-05-10 15:44:45 +00:00
|
|
|
try:
|
2020-05-16 11:09:38 +00:00
|
|
|
# if trade is not partially completed, just delete the order
|
2020-05-10 15:44:45 +00:00
|
|
|
self.exchange.cancel_order(trade.open_order_id, trade.pair)
|
|
|
|
except InvalidOrderException:
|
|
|
|
logger.exception(f"Could not cancel sell order {trade.open_order_id}")
|
|
|
|
return 'error cancelling order'
|
2020-02-08 20:02:52 +00:00
|
|
|
logger.info('Sell order %s for %s.', reason, trade)
|
2019-02-03 12:39:05 +00:00
|
|
|
else:
|
2020-04-24 22:16:52 +00:00
|
|
|
reason = constants.CANCEL_REASON['CANCELLED_ON_EXCHANGE']
|
2020-02-08 20:02:52 +00:00
|
|
|
logger.info('Sell order %s for %s.', reason, trade)
|
|
|
|
|
2018-02-04 09:21:16 +00:00
|
|
|
trade.close_rate = None
|
2020-03-24 16:12:24 +00:00
|
|
|
trade.close_rate_requested = None
|
2018-02-04 09:21:16 +00:00
|
|
|
trade.close_profit = None
|
2020-03-22 10:16:09 +00:00
|
|
|
trade.close_profit_abs = None
|
2018-02-04 09:21:16 +00:00
|
|
|
trade.close_date = None
|
|
|
|
trade.is_open = True
|
|
|
|
trade.open_order_id = None
|
2020-04-24 22:16:52 +00:00
|
|
|
else:
|
|
|
|
# TODO: figure out how to handle partially complete sell orders
|
2020-08-26 20:17:43 +00:00
|
|
|
reason = constants.CANCEL_REASON['PARTIALLY_FILLED_KEEP_OPEN']
|
2019-02-03 12:39:05 +00:00
|
|
|
|
2020-04-24 22:16:52 +00:00
|
|
|
self.wallets.update()
|
|
|
|
self._notify_sell_cancel(
|
|
|
|
trade,
|
|
|
|
order_type=self.strategy.order_types['sell'],
|
|
|
|
reason=reason
|
|
|
|
)
|
|
|
|
return reason
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2019-12-13 05:52:33 +00:00
|
|
|
def _safe_sell_amount(self, pair: str, amount: float) -> float:
|
|
|
|
"""
|
|
|
|
Get sellable amount.
|
|
|
|
Should be trade.amount - but will fall back to the available amount if necessary.
|
|
|
|
This should cover cases where get_real_amount() was not able to update the amount
|
|
|
|
for whatever reason.
|
2019-12-18 19:16:53 +00:00
|
|
|
:param pair: Pair we're trying to sell
|
2019-12-13 05:52:33 +00:00
|
|
|
:param amount: amount we expect to be available
|
|
|
|
:return: amount to sell
|
|
|
|
:raise: DependencyException: if available balance is not within 2% of the available amount.
|
|
|
|
"""
|
2020-01-15 20:52:10 +00:00
|
|
|
# Update wallets to ensure amounts tied up in a stoploss is now free!
|
|
|
|
self.wallets.update()
|
2020-02-26 06:08:09 +00:00
|
|
|
trade_base_currency = self.exchange.get_pair_base_currency(pair)
|
|
|
|
wallet_amount = self.wallets.get_free(trade_base_currency)
|
2020-01-15 20:52:10 +00:00
|
|
|
logger.debug(f"{pair} - Wallet: {wallet_amount} - Trade-amount: {amount}")
|
2020-01-15 18:56:14 +00:00
|
|
|
if wallet_amount >= amount:
|
2019-12-13 05:52:33 +00:00
|
|
|
return amount
|
|
|
|
elif wallet_amount > amount * 0.98:
|
2020-05-03 18:32:45 +00:00
|
|
|
logger.info(f"{pair} - Falling back to wallet-amount {wallet_amount} -> {amount}.")
|
2019-12-13 05:52:33 +00:00
|
|
|
return wallet_amount
|
|
|
|
else:
|
2020-01-15 20:52:10 +00:00
|
|
|
raise DependencyException(
|
|
|
|
f"Not enough amount to sell. Trade-amount: {amount}, Wallet: {wallet_amount}")
|
2019-12-13 05:52:33 +00:00
|
|
|
|
2020-02-08 20:02:52 +00:00
|
|
|
def execute_sell(self, trade: Trade, limit: float, sell_reason: SellType) -> bool:
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
|
|
|
Executes a limit sell for the given trade and limit
|
|
|
|
:param trade: Trade instance
|
|
|
|
:param limit: limit rate for the sell order
|
2018-07-22 23:54:20 +00:00
|
|
|
:param sellreason: Reason the sell was triggered
|
2020-02-08 20:31:36 +00:00
|
|
|
:return: True if it succeeds (supported) False (not supported)
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
2018-11-15 05:58:24 +00:00
|
|
|
sell_type = 'sell'
|
|
|
|
if sell_reason in (SellType.STOP_LOSS, SellType.TRAILING_STOP_LOSS):
|
|
|
|
sell_type = 'stoploss'
|
2018-11-25 18:48:46 +00:00
|
|
|
|
2018-12-01 09:50:41 +00:00
|
|
|
# if stoploss is on exchange and we are on dry_run mode,
|
|
|
|
# we consider the sell price stop price
|
2020-01-20 19:24:40 +00:00
|
|
|
if self.config['dry_run'] and sell_type == 'stoploss' \
|
2018-12-01 09:50:41 +00:00
|
|
|
and self.strategy.order_types['stoploss_on_exchange']:
|
2019-01-31 05:51:03 +00:00
|
|
|
limit = trade.stop_loss
|
2018-11-25 18:48:46 +00:00
|
|
|
|
2018-11-22 16:02:02 +00:00
|
|
|
# First cancelling stoploss on exchange ...
|
2018-11-25 16:22:56 +00:00
|
|
|
if self.strategy.order_types.get('stoploss_on_exchange') and trade.stoploss_order_id:
|
2019-06-20 18:32:46 +00:00
|
|
|
try:
|
2020-03-25 16:01:11 +00:00
|
|
|
self.exchange.cancel_stoploss_order(trade.stoploss_order_id, trade.pair)
|
2019-06-20 18:32:46 +00:00
|
|
|
except InvalidOrderException:
|
|
|
|
logger.exception(f"Could not cancel stoploss order {trade.stoploss_order_id}")
|
2018-11-22 16:02:02 +00:00
|
|
|
|
2020-01-02 10:56:16 +00:00
|
|
|
order_type = self.strategy.order_types[sell_type]
|
2019-09-01 07:09:07 +00:00
|
|
|
if sell_reason == SellType.EMERGENCY_SELL:
|
2020-02-08 20:02:52 +00:00
|
|
|
# Emergency sells (default to market!)
|
2020-01-02 10:56:16 +00:00
|
|
|
order_type = self.strategy.order_types.get("emergencysell", "market")
|
2019-09-01 07:09:07 +00:00
|
|
|
|
2019-12-13 05:52:33 +00:00
|
|
|
amount = self._safe_sell_amount(trade.pair, trade.amount)
|
2020-06-14 08:08:19 +00:00
|
|
|
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=order_type, amount=amount, rate=limit,
|
|
|
|
time_in_force=time_in_force,
|
|
|
|
sell_reason=sell_reason.value):
|
|
|
|
logger.info(f"User requested abortion of selling {trade.pair}")
|
|
|
|
return False
|
2019-12-13 05:52:33 +00:00
|
|
|
|
2020-08-14 08:59:55 +00:00
|
|
|
try:
|
|
|
|
# Execute sell and update trade record
|
|
|
|
order = self.exchange.sell(pair=trade.pair,
|
|
|
|
ordertype=order_type,
|
|
|
|
amount=amount, rate=limit,
|
|
|
|
time_in_force=time_in_force
|
|
|
|
)
|
|
|
|
except InsufficientFundsError as e:
|
|
|
|
logger.warning(f"Unable to place order {e}.")
|
2020-08-22 13:48:00 +00:00
|
|
|
# Try to figure out what went wrong
|
|
|
|
self.handle_insufficient_funds(trade)
|
2020-08-14 08:59:55 +00:00
|
|
|
return False
|
2018-11-25 21:02:59 +00:00
|
|
|
|
2020-08-13 14:14:28 +00:00
|
|
|
order_obj = Order.parse_from_ccxt_object(order, trade.pair, 'sell')
|
2020-08-13 07:34:53 +00:00
|
|
|
trade.orders.append(order_obj)
|
|
|
|
|
2019-08-12 14:34:55 +00:00
|
|
|
trade.open_order_id = order['id']
|
2018-04-25 18:16:36 +00:00
|
|
|
trade.close_rate_requested = limit
|
2018-07-22 23:54:20 +00:00
|
|
|
trade.sell_reason = sell_reason.value
|
2019-08-12 14:34:55 +00:00
|
|
|
# In case of market sell orders the order can be closed immediately
|
|
|
|
if order.get('status', 'unknown') == 'closed':
|
2020-08-21 05:17:52 +00:00
|
|
|
self.update_trade_state(trade, trade.open_order_id, order)
|
2018-02-04 09:21:16 +00:00
|
|
|
Trade.session.flush()
|
2019-08-12 18:39:34 +00:00
|
|
|
|
|
|
|
# Lock pair for one candle to prevent immediate rebuys
|
2020-10-17 09:28:34 +00:00
|
|
|
self.strategy.lock_pair(trade.pair, timeframe_to_next_date(self.config['timeframe']),
|
2020-10-20 17:39:38 +00:00
|
|
|
reason='Auto lock')
|
2019-08-12 18:39:34 +00:00
|
|
|
|
2020-01-02 10:56:16 +00:00
|
|
|
self._notify_sell(trade, order_type)
|
2019-03-12 21:01:19 +00:00
|
|
|
|
2020-02-08 20:02:52 +00:00
|
|
|
return True
|
|
|
|
|
2020-02-02 04:00:40 +00:00
|
|
|
def _notify_sell(self, trade: Trade, order_type: str) -> None:
|
2019-03-12 21:01:19 +00:00
|
|
|
"""
|
|
|
|
Sends rpc notification when a sell occured.
|
|
|
|
"""
|
2019-03-13 18:41:58 +00:00
|
|
|
profit_rate = trade.close_rate if trade.close_rate else trade.close_rate_requested
|
|
|
|
profit_trade = trade.calc_profit(rate=profit_rate)
|
2020-03-08 10:35:31 +00:00
|
|
|
# Use cached rates here - it was updated seconds ago.
|
2019-03-16 12:24:10 +00:00
|
|
|
current_rate = self.get_sell_rate(trade.pair, False)
|
2020-02-28 09:36:39 +00:00
|
|
|
profit_ratio = trade.calc_profit_ratio(profit_rate)
|
|
|
|
gain = "profit" if profit_ratio > 0 else "loss"
|
2019-03-12 21:01:19 +00:00
|
|
|
|
|
|
|
msg = {
|
|
|
|
'type': RPCMessageType.SELL_NOTIFICATION,
|
2020-07-20 17:50:29 +00:00
|
|
|
'trade_id': trade.id,
|
2019-03-12 21:01:19 +00:00
|
|
|
'exchange': trade.exchange.capitalize(),
|
|
|
|
'pair': trade.pair,
|
|
|
|
'gain': gain,
|
2020-02-08 20:02:52 +00:00
|
|
|
'limit': profit_rate,
|
2019-09-01 07:17:58 +00:00
|
|
|
'order_type': order_type,
|
2019-03-12 21:01:19 +00:00
|
|
|
'amount': trade.amount,
|
|
|
|
'open_rate': trade.open_rate,
|
|
|
|
'current_rate': current_rate,
|
|
|
|
'profit_amount': profit_trade,
|
2020-02-28 09:36:39 +00:00
|
|
|
'profit_ratio': profit_ratio,
|
2019-12-08 13:07:46 +00:00
|
|
|
'sell_reason': trade.sell_reason,
|
|
|
|
'open_date': trade.open_date,
|
2020-01-02 10:51:25 +00:00
|
|
|
'close_date': trade.close_date or datetime.utcnow(),
|
2020-01-02 11:38:25 +00:00
|
|
|
'stake_currency': self.config['stake_currency'],
|
2020-02-08 20:02:52 +00:00
|
|
|
'fiat_currency': self.config.get('fiat_display_currency', None),
|
|
|
|
}
|
|
|
|
|
|
|
|
if 'fiat_display_currency' in self.config:
|
|
|
|
msg.update({
|
|
|
|
'fiat_currency': self.config['fiat_display_currency'],
|
|
|
|
})
|
|
|
|
|
|
|
|
# Send the message
|
|
|
|
self.rpc.send_msg(msg)
|
|
|
|
|
2020-03-24 16:12:24 +00:00
|
|
|
def _notify_sell_cancel(self, trade: Trade, order_type: str, reason: str) -> None:
|
2020-02-08 20:02:52 +00:00
|
|
|
"""
|
|
|
|
Sends rpc notification when a sell cancel occured.
|
|
|
|
"""
|
2020-05-17 08:53:07 +00:00
|
|
|
if trade.sell_order_status == reason:
|
|
|
|
return
|
|
|
|
else:
|
|
|
|
trade.sell_order_status = reason
|
|
|
|
|
2020-02-08 20:02:52 +00:00
|
|
|
profit_rate = trade.close_rate if trade.close_rate else trade.close_rate_requested
|
|
|
|
profit_trade = trade.calc_profit(rate=profit_rate)
|
2020-02-22 10:16:20 +00:00
|
|
|
current_rate = self.get_sell_rate(trade.pair, False)
|
2020-02-28 09:36:39 +00:00
|
|
|
profit_ratio = trade.calc_profit_ratio(profit_rate)
|
|
|
|
gain = "profit" if profit_ratio > 0 else "loss"
|
2020-02-08 20:02:52 +00:00
|
|
|
|
|
|
|
msg = {
|
|
|
|
'type': RPCMessageType.SELL_CANCEL_NOTIFICATION,
|
2020-07-20 17:50:29 +00:00
|
|
|
'trade_id': trade.id,
|
2020-02-08 20:02:52 +00:00
|
|
|
'exchange': trade.exchange.capitalize(),
|
|
|
|
'pair': trade.pair,
|
|
|
|
'gain': gain,
|
|
|
|
'limit': profit_rate,
|
|
|
|
'order_type': order_type,
|
|
|
|
'amount': trade.amount,
|
|
|
|
'open_rate': trade.open_rate,
|
|
|
|
'current_rate': current_rate,
|
|
|
|
'profit_amount': profit_trade,
|
2020-02-28 09:36:39 +00:00
|
|
|
'profit_ratio': profit_ratio,
|
2020-02-08 20:02:52 +00:00
|
|
|
'sell_reason': trade.sell_reason,
|
|
|
|
'open_date': trade.open_date,
|
|
|
|
'close_date': trade.close_date,
|
|
|
|
'stake_currency': self.config['stake_currency'],
|
|
|
|
'fiat_currency': self.config.get('fiat_display_currency', None),
|
2020-03-24 16:12:24 +00:00
|
|
|
'reason': reason,
|
2019-03-12 21:01:19 +00:00
|
|
|
}
|
|
|
|
|
2020-01-02 11:38:25 +00:00
|
|
|
if 'fiat_display_currency' in self.config:
|
2019-03-12 21:01:19 +00:00
|
|
|
msg.update({
|
2020-01-02 19:20:29 +00:00
|
|
|
'fiat_currency': self.config['fiat_display_currency'],
|
2019-03-12 21:01:19 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
# Send the message
|
|
|
|
self.rpc.send_msg(msg)
|
2020-01-02 08:50:54 +00:00
|
|
|
|
|
|
|
#
|
|
|
|
# Common update trade state methods
|
|
|
|
#
|
|
|
|
|
2020-09-19 07:37:11 +00:00
|
|
|
def update_trade_state(self, trade: Trade, order_id: str, action_order: Dict[str, Any] = None,
|
|
|
|
stoploss_order: bool = False) -> bool:
|
2020-01-02 08:50:54 +00:00
|
|
|
"""
|
|
|
|
Checks trades with open orders and updates the amount if necessary
|
2020-03-24 15:16:19 +00:00
|
|
|
Handles closing both buy and sell orders.
|
2020-08-21 05:31:22 +00:00
|
|
|
:param trade: Trade object of the trade we're analyzing
|
|
|
|
:param order_id: Order-id of the order we're analyzing
|
|
|
|
:param action_order: Already aquired order object
|
2020-03-24 19:05:25 +00:00
|
|
|
:return: True if order has been cancelled without being filled partially, False otherwise
|
2020-01-02 08:50:54 +00:00
|
|
|
"""
|
2020-08-21 05:17:52 +00:00
|
|
|
if not order_id:
|
|
|
|
logger.warning(f'Orderid for trade {trade} is empty.')
|
2020-09-06 13:05:47 +00:00
|
|
|
return False
|
2020-08-21 05:17:52 +00:00
|
|
|
|
2020-05-13 18:25:32 +00:00
|
|
|
# Update trade with order values
|
|
|
|
logger.info('Found open order for %s', trade)
|
|
|
|
try:
|
2020-08-22 07:30:25 +00:00
|
|
|
order = action_order or self.exchange.fetch_order_or_stoploss_order(order_id,
|
|
|
|
trade.pair,
|
|
|
|
stoploss_order)
|
2020-05-13 18:25:32 +00:00
|
|
|
except InvalidOrderException as exception:
|
|
|
|
logger.warning('Unable to fetch order %s: %s', order_id, exception)
|
|
|
|
return False
|
2020-08-13 14:18:03 +00:00
|
|
|
|
2020-08-13 13:39:29 +00:00
|
|
|
trade.update_order(order)
|
2020-08-13 14:18:03 +00:00
|
|
|
|
2020-05-13 18:25:32 +00:00
|
|
|
# Try update amount (binance-fix)
|
|
|
|
try:
|
2020-09-19 07:37:11 +00:00
|
|
|
new_amount = self.get_real_amount(trade, order)
|
2020-07-15 19:02:31 +00:00
|
|
|
if not isclose(safe_value_fallback(order, 'filled', 'amount'), new_amount,
|
|
|
|
abs_tol=constants.MATH_CLOSE_PREC):
|
2020-05-13 18:25:32 +00:00
|
|
|
order['amount'] = new_amount
|
|
|
|
order.pop('filled', None)
|
|
|
|
trade.recalc_open_trade_price()
|
|
|
|
except DependencyException as exception:
|
|
|
|
logger.warning("Could not update trade amount: %s", exception)
|
|
|
|
|
|
|
|
if self.exchange.check_order_canceled_empty(order):
|
|
|
|
# Trade has been cancelled on exchange
|
|
|
|
# Handling of this will happen in check_handle_timeout.
|
|
|
|
return True
|
|
|
|
trade.update(order)
|
2020-01-02 08:50:54 +00:00
|
|
|
|
2020-05-13 18:25:32 +00:00
|
|
|
# Updating wallets when order is closed
|
|
|
|
if not trade.is_open:
|
|
|
|
self.wallets.update()
|
2020-03-24 16:17:40 +00:00
|
|
|
return False
|
|
|
|
|
2020-05-03 08:50:59 +00:00
|
|
|
def apply_fee_conditional(self, trade: Trade, trade_base_currency: str,
|
2020-05-03 09:13:59 +00:00
|
|
|
amount: float, fee_abs: float) -> float:
|
2020-05-03 08:50:59 +00:00
|
|
|
"""
|
|
|
|
Applies the fee to amount (either from Order or from Trades).
|
|
|
|
Can eat into dust if more than the required asset is available.
|
|
|
|
"""
|
2020-05-03 09:13:59 +00:00
|
|
|
self.wallets.update()
|
|
|
|
if fee_abs != 0 and self.wallets.get_free(trade_base_currency) >= amount:
|
2020-05-03 08:50:59 +00:00
|
|
|
# Eat into dust if we own more than base currency
|
|
|
|
logger.info(f"Fee amount for {trade} was in base currency - "
|
2020-05-03 09:13:59 +00:00
|
|
|
f"Eating Fee {fee_abs} into dust.")
|
|
|
|
elif fee_abs != 0:
|
|
|
|
real_amount = self.exchange.amount_to_precision(trade.pair, amount - fee_abs)
|
2020-05-03 08:50:59 +00:00
|
|
|
logger.info(f"Applying fee on amount for {trade} "
|
|
|
|
f"(from {amount} to {real_amount}).")
|
|
|
|
return real_amount
|
|
|
|
return amount
|
|
|
|
|
2020-09-19 07:37:11 +00:00
|
|
|
def get_real_amount(self, trade: Trade, order: Dict) -> float:
|
2020-01-02 08:50:54 +00:00
|
|
|
"""
|
2020-05-01 14:13:07 +00:00
|
|
|
Detect and update trade fee.
|
|
|
|
Calls trade.update_fee() uppon correct detection.
|
|
|
|
Returns modified amount if the fee was taken from the destination currency.
|
2020-01-02 08:50:54 +00:00
|
|
|
Necessary for exchanges which charge fees in base currency (e.g. binance)
|
2020-05-01 14:13:07 +00:00
|
|
|
:return: identical (or new) amount for the trade
|
2020-01-02 08:50:54 +00:00
|
|
|
"""
|
2020-05-01 14:01:33 +00:00
|
|
|
# Init variables
|
2020-09-19 07:37:11 +00:00
|
|
|
order_amount = safe_value_fallback(order, 'filled', 'amount')
|
2020-01-02 08:50:54 +00:00
|
|
|
# Only run for closed orders
|
2020-05-01 18:34:58 +00:00
|
|
|
if trade.fee_updated(order.get('side', '')) or order['status'] == 'open':
|
2020-01-02 08:50:54 +00:00
|
|
|
return order_amount
|
|
|
|
|
2020-02-24 20:50:27 +00:00
|
|
|
trade_base_currency = self.exchange.get_pair_base_currency(trade.pair)
|
2020-01-02 08:50:54 +00:00
|
|
|
# use fee from order-dict if possible
|
2020-05-01 14:01:33 +00:00
|
|
|
if self.exchange.order_has_fee(order):
|
|
|
|
fee_cost, fee_currency, fee_rate = self.exchange.extract_cost_curr_rate(order)
|
2020-05-01 18:03:06 +00:00
|
|
|
logger.info(f"Fee for Trade {trade} [{order.get('side')}]: "
|
|
|
|
f"{fee_cost:.8g} {fee_currency} - rate: {fee_rate}")
|
2020-05-03 08:50:59 +00:00
|
|
|
|
2020-05-01 18:34:58 +00:00
|
|
|
trade.update_fee(fee_cost, fee_currency, fee_rate, order.get('side', ''))
|
2020-05-03 08:50:59 +00:00
|
|
|
if trade_base_currency == fee_currency:
|
|
|
|
# Apply fee to amount
|
|
|
|
return self.apply_fee_conditional(trade, trade_base_currency,
|
2020-05-03 09:13:59 +00:00
|
|
|
amount=order_amount, fee_abs=fee_cost)
|
2020-05-01 14:01:33 +00:00
|
|
|
return order_amount
|
2020-05-01 14:13:07 +00:00
|
|
|
return self.fee_detection_from_trades(trade, order, order_amount)
|
2020-01-02 08:50:54 +00:00
|
|
|
|
2020-05-01 14:13:07 +00:00
|
|
|
def fee_detection_from_trades(self, trade: Trade, order: Dict, order_amount: float) -> float:
|
|
|
|
"""
|
|
|
|
fee-detection fallback to Trades. Parses result of fetch_my_trades to get correct fee.
|
|
|
|
"""
|
2020-08-21 17:51:31 +00:00
|
|
|
trades = self.exchange.get_trades_for_order(order['id'], trade.pair,
|
2020-01-02 08:50:54 +00:00
|
|
|
trade.open_date)
|
|
|
|
|
|
|
|
if len(trades) == 0:
|
|
|
|
logger.info("Applying fee on amount for %s failed: myTrade-Dict empty found", trade)
|
|
|
|
return order_amount
|
2020-05-01 14:13:07 +00:00
|
|
|
fee_currency = None
|
2020-01-02 08:50:54 +00:00
|
|
|
amount = 0
|
2020-05-01 14:01:33 +00:00
|
|
|
fee_abs = 0.0
|
|
|
|
fee_cost = 0.0
|
2020-05-01 14:13:07 +00:00
|
|
|
trade_base_currency = self.exchange.get_pair_base_currency(trade.pair)
|
2020-05-01 14:01:33 +00:00
|
|
|
fee_rate_array: List[float] = []
|
2020-01-02 08:50:54 +00:00
|
|
|
for exectrade in trades:
|
|
|
|
amount += exectrade['amount']
|
2020-05-01 14:01:33 +00:00
|
|
|
if self.exchange.order_has_fee(exectrade):
|
|
|
|
fee_cost_, fee_currency, fee_rate_ = self.exchange.extract_cost_curr_rate(exectrade)
|
|
|
|
fee_cost += fee_cost_
|
|
|
|
if fee_rate_ is not None:
|
|
|
|
fee_rate_array.append(fee_rate_)
|
2020-01-02 08:50:54 +00:00
|
|
|
# only applies if fee is in quote currency!
|
2020-05-01 14:01:33 +00:00
|
|
|
if trade_base_currency == fee_currency:
|
|
|
|
fee_abs += fee_cost_
|
|
|
|
# Ensure at least one trade was found:
|
|
|
|
if fee_currency:
|
|
|
|
# fee_rate should use mean
|
|
|
|
fee_rate = sum(fee_rate_array) / float(len(fee_rate_array)) if fee_rate_array else None
|
2020-05-01 18:34:58 +00:00
|
|
|
trade.update_fee(fee_cost, fee_currency, fee_rate, order.get('side', ''))
|
2020-01-02 08:50:54 +00:00
|
|
|
|
|
|
|
if not isclose(amount, order_amount, abs_tol=constants.MATH_CLOSE_PREC):
|
|
|
|
logger.warning(f"Amount {amount} does not match amount {trade.amount}")
|
|
|
|
raise DependencyException("Half bought? Amounts don't match")
|
2020-05-03 08:50:59 +00:00
|
|
|
|
2020-01-02 08:50:54 +00:00
|
|
|
if fee_abs != 0:
|
2020-05-03 08:50:59 +00:00
|
|
|
return self.apply_fee_conditional(trade, trade_base_currency,
|
2020-05-03 09:13:59 +00:00
|
|
|
amount=amount, fee_abs=fee_abs)
|
2020-05-03 08:50:59 +00:00
|
|
|
else:
|
|
|
|
return amount
|