stable/freqtrade/freqtradebot.py

1058 lines
43 KiB
Python
Raw Normal View History

"""
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
import traceback
2018-03-02 15:22:00 +00:00
from datetime import datetime
from math import isclose
2019-10-25 17:59:04 +00:00
from os import getpid
2019-03-22 17:16:54 +00:00
from typing import Any, Dict, List, Optional, Tuple
2018-03-17 21:44:47 +00:00
2018-03-02 15:22:00 +00:00
import arrow
from requests.exceptions import RequestException
2018-07-31 10:47:32 +00:00
from freqtrade import __version__, constants, persistence
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
from freqtrade.exceptions import DependencyException, InvalidOrderException
from freqtrade.exchange import timeframe_to_minutes, timeframe_to_next_date
from freqtrade.pairlist.pairlistmanager import PairListManager
from freqtrade.persistence import Trade
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
from freqtrade.state import State
2019-10-25 17:59:04 +00:00
from freqtrade.strategy.interface import IStrategy, SellType
from freqtrade.wallets import Wallets
2020-01-01 23:53:25 +00:00
2018-03-25 19:37:14 +00:00
logger = logging.getLogger(__name__)
2019-09-12 01:39:52 +00:00
class FreqtradeBot:
"""
Freqtrade is the main class of the bot.
This is from here the bot start its logic.
"""
def __init__(self, config: Dict[str, Any]) -> None:
"""
Init all variables and objects the bot needs to work
:param config: configuration dict, you can use Configuration.get_config()
to get the config dict.
"""
2019-03-22 17:16:54 +00:00
logger.info('Starting freqtrade %s', __version__)
# Init bot state
self.state = State.STOPPED
# Init objects
self.config = config
2019-10-25 17:59:04 +00:00
self._heartbeat_msg = 0
2019-10-25 13:00:16 +00:00
2019-10-26 07:21:51 +00:00
self.heartbeat_interval = self.config.get('internals', {}).get('heartbeat_interval', 60)
2019-10-25 13:00:16 +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
validate_config_consistency(config)
self.exchange = ExchangeResolver.load_exchange(self.config['exchange']['name'], self.config)
2019-02-17 03:18:56 +00:00
persistence.init(self.config.get('db_url', None),
clean_open_orders=self.config.get('dry_run', False))
self.wallets = Wallets(self.config, self.exchange)
2018-12-02 14:57:49 +00:00
self.dataprovider = DataProvider(self.config, self.exchange)
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
2019-11-09 05:55:16 +00:00
self.pairlists = PairListManager(self.exchange, self.config)
# Initializing Edge only if enabled
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
self.active_pair_whitelist = self._refresh_whitelist()
# Set initial bot state from config
initial_state = self.config.get('initial_state')
self.state = State[initial_state.upper()] if initial_state else State.STOPPED
# 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)
def cleanup(self) -> None:
"""
Cleanup pending resources on an already stopped bot
:return: None
"""
logger.info('Cleaning up modules ...')
self.rpc.cleanup()
persistence.cleanup()
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)
if not self.edge:
# Adjust stoploss if it was changed
Trade.stoploss_reinitialization(self.strategy.stoploss)
2019-05-19 18:06:26 +00:00
def process(self) -> None:
"""
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
"""
# Check whether markets have to be reloaded
self.exchange._reload_markets()
# Query trades from persistence layer
trades = Trade.get_open_trades()
self.active_pair_whitelist = self._refresh_whitelist(trades)
# Refreshing candles
self.dataprovider.refresh(self._create_pair_whitelist(self.active_pair_whitelist),
self.strategy.informative_pairs())
# First process current opened trades (positions)
self.exit_positions(trades)
# Then looking for buy opportunities
if self.get_free_open_trades():
self.enter_positions()
2019-11-12 14:43:10 +00:00
# Check and handle any timed out open orders
self.check_handle_timedout()
Trade.session.flush()
2019-10-26 07:21:51 +00:00
if (self.heartbeat_interval
and (arrow.utcnow().timestamp - self._heartbeat_msg > self.heartbeat_interval)):
2019-10-26 07:21:51 +00:00
logger.info(f"Bot heartbeat. PID={getpid()}")
2019-10-25 17:59:04 +00:00
self._heartbeat_msg = arrow.utcnow().timestamp
2019-10-25 13:00:16 +00:00
def _refresh_whitelist(self, trades: List[Trade] = []) -> List[str]:
2019-02-20 13:12:17 +00:00
"""
Refresh whitelist from pairlist or edge and extend it with trades.
2019-02-20 13:12:17 +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:
# Extend active-pair whitelist with pairs from open trades
# It ensures that tickers are downloaded for open trades
_whitelist.extend([trade.pair for trade in trades if trade.pair not in _whitelist])
return _whitelist
2019-02-20 12:12:04 +00:00
def _create_pair_whitelist(self, pairs: List[str]) -> List[Tuple[str, str]]:
"""
Create pair-whitelist tuple with (pair, ticker_interval)
"""
return [(pair, self.config['ticker_interval']) for pair in pairs]
def get_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-01-01 23:53:25 +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
2019-03-02 17:53:42 +00:00
def get_target_bid(self, pair: str, tick: Dict = None) -> float:
"""
Calculates bid target between current ask price and last price
:return: float: Price
"""
config_bid_strategy = self.config.get('bid_strategy', {})
if 'use_order_book' in config_bid_strategy and\
config_bid_strategy.get('use_order_book', False):
2018-08-05 04:41:06 +00:00
logger.info('Getting price from order book')
order_book_top = config_bid_strategy.get('order_book_top', 1)
2018-08-05 04:41:06 +00:00
order_book = self.exchange.get_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
order_book_rate = order_book['bids'][order_book_top - 1][0]
logger.info('...top %s order book buy rate %0.8f', order_book_top, order_book_rate)
used_rate = order_book_rate
2018-08-05 04:41:06 +00:00
else:
2019-03-02 17:53:42 +00:00
if not tick:
2019-03-02 16:24:48 +00:00
logger.info('Using Last Ask / Last Price')
2019-12-18 15:34:30 +00:00
ticker = self.exchange.fetch_ticker(pair)
2019-03-02 17:53:42 +00:00
else:
ticker = tick
if ticker['ask'] < ticker['last']:
ticker_rate = ticker['ask']
else:
balance = self.config['bid_strategy']['ask_last_balance']
ticker_rate = ticker['ask'] + balance * (ticker['last'] - ticker['ask'])
2018-08-05 04:41:06 +00:00
used_rate = ticker_rate
return used_rate
def get_trade_stake_amount(self, pair) -> Optional[float]:
"""
Calculate stake amount for the trade
:return: float: Stake amount
"""
2019-12-27 23:58:23 +00:00
stake_amount: Optional[float]
2018-11-06 18:45:41 +00:00
if self.edge:
stake_amount = self.edge.stake_amount(
2018-11-28 14:36:32 +00:00
pair,
self.wallets.get_free(self.config['stake_currency']),
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']
if stake_amount == constants.UNLIMITED_STAKE_AMOUNT:
stake_amount = self._calculate_unlimited_stake_amount()
return self._check_available_stake_amount(stake_amount)
def _calculate_unlimited_stake_amount(self) -> Optional[float]:
"""
Calculate stake amount for "unlimited" stake amount
:return: None if max number of trades reached
"""
free_open_trades = self.get_free_open_trades()
if not free_open_trades:
return None
available_amount = self.wallets.get_free(self.config['stake_currency'])
return available_amount / free_open_trades
def _check_available_stake_amount(self, stake_amount: Optional[float]) -> Optional[float]:
"""
Check if stake amount can be fulfilled with the available balance
for the stake currency
:return: float: Stake amount
"""
available_amount = self.wallets.get_free(self.config['stake_currency'])
if stake_amount is not None and available_amount < stake_amount:
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-11-06 18:45:41 +00:00
return stake_amount
2018-06-16 23:23:12 +00:00
def _get_min_pair_stake_amount(self, pair: str, price: float) -> Optional[float]:
try:
market = self.exchange.markets[pair]
except KeyError:
raise ValueError(f"Can't get market information for symbol {pair}")
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
# reserve some percent defined in config (5% default) + stoploss
amount_reserve_percent = 1.0 - self.config.get('amount_reserve_percent',
constants.DEFAULT_AMOUNT_RESERVE_PERCENT)
if self.strategy.stoploss is not None:
amount_reserve_percent += self.strategy.stoploss
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:
"""
Check the implemented trading strategy for buy signals.
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.
"""
2019-12-29 01:17:49 +00:00
logger.debug(f"create_trade for pair {pair}")
2019-12-29 01:17:49 +00:00
if self.strategy.is_pair_locked(pair):
logger.info(f"Pair {pair} is currently locked.")
2019-04-01 11:08:03 +00:00
return False
# running get_signal on historical data fetched
2019-12-29 01:17:49 +00:00
(buy, sell) = self.strategy.get_signal(
pair, self.strategy.ticker_interval,
self.dataprovider.ohlcv(pair, self.strategy.ticker_interval))
2019-12-29 01:17:49 +00:00
if buy and not sell:
if not self.get_free_open_trades():
logger.debug("Can't open a new trade: max number of trades is reached.")
2019-12-29 01:17:49 +00:00
return False
2019-12-29 01:17:49 +00:00
stake_amount = self.get_trade_stake_amount(pair)
if not stake_amount:
logger.debug("Stake amount is 0, ignoring possible trade for {pair}.")
return False
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} ...")
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):
2019-12-29 01:17:49 +00:00
return self.execute_buy(pair, stake_amount)
else:
return False
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)
2018-08-05 04:41:06 +00:00
logger.info('checking depth of market for %s', pair)
order_book = self.exchange.get_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
logger.info('bids: %s, asks: %s, delta: %s', order_book_bids,
2018-08-07 10:29:37 +00:00
order_book_asks, bids_ask_delta)
2018-08-05 04:41:06 +00:00
if bids_ask_delta >= conf_bids_to_ask_delta:
return True
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
:return: None
"""
time_in_force = self.strategy.order_time_in_force['buy']
2018-10-09 05:06:11 +00:00
if price:
buy_limit_requested = price
2018-10-09 05:06:11 +00:00
else:
2020-01-02 00:16:18 +00:00
# Calculate price
buy_limit_requested = self.get_target_bid(pair)
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 "
f"is too small ({stake_amount} < {min_stake_amount})"
2018-06-16 23:23:12 +00:00
)
return False
amount = stake_amount / buy_limit_requested
2019-06-17 04:55:54 +00:00
order_type = self.strategy.order_types['buy']
order = self.exchange.buy(pair=pair, ordertype=order_type,
amount=amount, rate=buy_limit_requested,
time_in_force=time_in_force)
order_id = order['id']
order_status = order.get('status', None)
# we assume the order is executed at the price requested
buy_limit_filled_price = buy_limit_requested
if order_status == 'expired' or order_status == 'rejected':
2018-11-29 12:22:41 +00:00
order_tif = self.strategy.order_time_in_force['buy']
2018-12-12 12:33:03 +00:00
# return false if the order is not filled
if float(order['filled']) == 0:
logger.warning('Buy %s order with time in force %s for %s is %s by %s.'
' zero amount is fulfilled.',
2019-12-27 22:34:31 +00:00
order_tif, order_type, pair, order_status, self.exchange.name)
return False
else:
# the order is partially fulfilled
# in case of IOC orders we can check immediately
# if the order is fulfilled fully or partially
logger.warning('Buy %s order with time in force %s for %s is %s by %s.'
' %s amount fulfilled out of %s (%s remaining which is canceled).',
2019-12-27 22:34:31 +00:00
order_tif, order_type, pair, order_status, self.exchange.name,
order['filled'], order['amount'], order['remaining']
)
2018-12-12 12:05:55 +00:00
stake_amount = order['cost']
amount = order['amount']
2018-12-12 12:05:55 +00:00
buy_limit_filled_price = order['price']
order_id = None
# 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']
amount = order['amount']
2018-12-12 12:05:55 +00:00
buy_limit_filled_price = order['price']
# 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')
trade = Trade(
pair=pair,
stake_amount=stake_amount,
amount=amount,
fee_open=fee,
fee_close=fee,
open_rate=buy_limit_filled_price,
open_rate_requested=buy_limit_requested,
open_date=datetime.utcnow(),
exchange=self.exchange.id,
open_order_id=order_id,
2018-07-19 17:41:42 +00:00
strategy=self.strategy.get_strategy_name(),
ticker_interval=timeframe_to_minutes(self.config['ticker_interval'])
)
2020-01-02 10:51:25 +00:00
self._notify_buy(trade, order_type)
2019-03-31 17:41:17 +00:00
# Update fees if order is closed
if order_status == 'closed':
self.update_trade_state(trade, order)
Trade.session.add(trade)
Trade.session.flush()
# Updating wallets
self.wallets.update()
return True
2020-01-02 10:51:25 +00:00
def _notify_buy(self, trade: Trade, order_type: str):
"""
Sends rpc notification when a buy occured.
"""
msg = {
'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-01-02 10:51:25 +00:00
}
# Send the message
self.rpc.send_msg(msg)
2020-01-01 23:53:25 +00:00
#
# SELL / exit positions / close trades logic and methods
2020-01-01 23:53:25 +00:00
#
def exit_positions(self, trades: List[Any]) -> int:
"""
Tries to execute sell orders for open trades (positions)
"""
trades_closed = 0
2019-10-02 00:27:17 +00:00
for trade in trades:
try:
self.update_trade_state(trade)
if (self.strategy.order_types.get('stoploss_on_exchange') and
self.handle_stoploss_on_exchange(trade)):
trades_closed += 1
continue
# Check if we can sell our current pair
if trade.open_order_id is None and self.handle_trade(trade):
trades_closed += 1
2019-10-02 00:27:17 +00:00
except DependencyException as exception:
logger.warning('Unable to sell trade: %s', exception)
# Updating wallets if any trade occured
if trades_closed:
self.wallets.update()
return trades_closed
def get_sell_rate(self, pair: str, refresh: bool) -> float:
"""
Get sell rate - either using get-ticker bid or first bid based on orderbook
The orderbook portion is only used for rpc messaging, which would otherwise fail
2019-12-18 15:34:30 +00:00
for BitMex (has no bid/ask in fetch_ticker)
or remain static in any other case since it's not updating.
:return: Bid rate
"""
config_ask_strategy = self.config.get('ask_strategy', {})
if config_ask_strategy.get('use_order_book', False):
logger.debug('Using order book to get sell rate')
order_book = self.exchange.get_order_book(pair, 1)
rate = order_book['bids'][0][0]
else:
2019-12-18 15:34:30 +00:00
rate = self.exchange.fetch_ticker(pair, refresh)['bid']
return rate
def handle_trade(self, trade: Trade) -> bool:
"""
Sells the current pair if the threshold is reached and updates the trade record.
:return: True if trade has been sold, False otherwise
"""
if not trade.is_open:
raise DependencyException(f'Attempt to handle closed trade: {trade}')
2018-03-25 19:37:14 +00:00
logger.debug('Handling %s ...', trade)
(buy, sell) = (False, False)
config_ask_strategy = self.config.get('ask_strategy', {})
if (config_ask_strategy.get('use_sell_signal', True) or
config_ask_strategy.get('ignore_roi_if_buy_signal')):
(buy, sell) = self.strategy.get_signal(
trade.pair, self.strategy.ticker_interval,
self.dataprovider.ohlcv(trade.pair, self.strategy.ticker_interval))
if config_ask_strategy.get('use_order_book', False):
2018-08-05 04:41:06 +00:00
logger.info('Using order book for selling...')
# logger.debug('Order book %s',orderBook)
order_book_min = config_ask_strategy.get('order_book_min', 1)
order_book_max = config_ask_strategy.get('order_book_max', 1)
2018-08-05 04:41:06 +00:00
order_book = self.exchange.get_order_book(trade.pair, order_book_max)
for i in range(order_book_min, order_book_max + 1):
order_book_rate = order_book['asks'][i - 1][0]
logger.info(' order book asks top %s: %0.8f', i, order_book_rate)
sell_rate = order_book_rate
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:
logger.debug('checking sell')
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
logger.debug('Found no sell signal for %s.', trade)
2018-08-05 04:41:06 +00:00
return False
def create_stoploss_order(self, trade: Trade, stop_price: float, rate: float) -> bool:
"""
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.
:return: True if the order succeeded, and False in case of problems.
"""
# Limit price threshold: As limit price should always be below stop-price
LIMIT_PRICE_PCT = self.strategy.order_types.get('stoploss_on_exchange_limit_ratio', 0.99)
try:
stoploss_order = self.exchange.stoploss_limit(pair=trade.pair, amount=trade.amount,
stop_price=stop_price,
rate=rate * LIMIT_PRICE_PCT)
trade.stoploss_order_id = str(stoploss_order['id'])
return True
except InvalidOrderException as e:
trade.stoploss_order_id = None
logger.error(f'Unable to place a stoploss order on exchange. {e}')
logger.warning('Selling the trade forcefully')
self.execute_sell(trade, trade.stop_loss, sell_reason=SellType.EMERGENCY_SELL)
except DependencyException:
trade.stoploss_order_id = None
logger.exception('Unable to place a stoploss order on exchange.')
return False
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
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
try:
2019-04-04 15:13:54 +00:00
# First we check if there is already a stoploss on exchange
stoploss_order = self.exchange.get_order(trade.stoploss_order_id, trade.pair) \
if trade.stoploss_order_id else None
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)
2019-04-05 18:20:16 +00:00
# If buy order is fulfilled but there is no stoploss, we add a stoploss on exchange
2019-08-31 14:15:39 +00:00
if (not trade.open_order_id and 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)
if self.create_stoploss_order(trade=trade, stop_price=stop_price, rate=stop_price):
trade.stoploss_last_update = datetime.now()
2019-04-04 15:13:54 +00:00
return False
2019-04-04 15:13:54 +00:00
# If stoploss order is canceled for some reason we add it
if stoploss_order and stoploss_order['status'] == 'canceled':
if self.create_stoploss_order(trade=trade, stop_price=trade.stop_loss,
rate=trade.stop_loss):
2019-04-04 15:13:54 +00:00
return False
else:
trade.stoploss_order_id = None
logger.warning('Stoploss order was cancelled, but unable to recreate one.')
2019-04-04 15:13:54 +00:00
# We check if stoploss order is fulfilled
if stoploss_order and stoploss_order['status'] == 'closed':
trade.sell_reason = SellType.STOPLOSS_ON_EXCHANGE.value
trade.update(stoploss_order)
# Lock pair for one candle to prevent immediate rebuys
self.strategy.lock_pair(trade.pair,
timeframe_to_next_date(self.config['ticker_interval']))
self._notify_sell(trade, "stoploss")
2019-04-04 15:13:54 +00:00
return True
# Finally we check if stoploss on exchange should be moved up because of trailing.
if stoploss_order and self.config.get('trailing_stop', False):
# if trailing stoploss is enabled we check if stoploss value has changed
# in which case we cancel stoploss order and put another one with new
# value immediately
self.handle_trailing_stoploss_on_exchange(trade, stoploss_order)
return False
def handle_trailing_stoploss_on_exchange(self, trade: Trade, order):
"""
Check to see if stoploss on exchange should be updated
in case of trailing stoploss on exchange
:param Trade: Corresponding Trade
:param order: Current on exchange stoploss order
:return: None
"""
if trade.stop_loss > float(order['info']['stopPrice']):
# we check if the update is neccesary
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:
# cancelling the current stoploss on exchange first
2019-04-02 16:57:06 +00:00
logger.info('Trailing stoploss: cancelling current stoploss on exchange (id:{%s})'
'in order to add another one ...', order['id'])
try:
self.exchange.cancel_order(order['id'], trade.pair)
except InvalidOrderException:
logger.exception(f"Could not cancel stoploss order {order['id']} "
f"for pair {trade.pair}")
# Create new stoploss order
if self.create_stoploss_order(trade=trade, stop_price=trade.stop_loss,
rate=trade.stop_loss):
return False
else:
logger.warning(f"Could not create trailing stoploss order "
f"for pair {trade.pair}.")
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(
trade, sell_rate, datetime.utcnow(), buy, sell,
force_stoploss=self.edge.stoploss(trade.pair) if self.edge else 0
)
2018-09-21 15:41:31 +00:00
2018-07-12 20:21:52 +00:00
if should_sell.sell_flag:
2018-08-05 04:41:06 +00:00
self.execute_sell(trade, sell_rate, should_sell.sell_type)
logger.info('executed sell, reason: %s', should_sell.sell_type)
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
def check_handle_timedout(self) -> None:
"""
Check if any orders are timed out and cancel if neccessary
:param timeoutvalue: Number of minutes until order is considered timed out
:return: None
"""
2019-10-29 12:32:07 +00:00
for trade in Trade.get_open_order_trades():
try:
if not trade.open_order_id:
continue
2018-06-17 10:41:33 +00:00
order = self.exchange.get_order(trade.open_order_id, trade.pair)
except (RequestException, DependencyException, InvalidOrderException):
2018-03-25 19:37:14 +00:00
logger.info(
'Cannot query order for %s due to %s',
trade,
traceback.format_exc())
continue
# Check if trade is still actually open
if float(order.get('remaining', 0.0)) == 0.0:
self.wallets.update()
continue
2019-10-18 20:41:07 +00:00
if ((order['side'] == 'buy' and order['status'] == 'canceled')
2019-11-12 14:43:10 +00:00
or (self._check_timed_out('buy', order))):
2019-10-18 05:01:05 +00:00
self.handle_timedout_limit_buy(trade, order)
self.wallets.update()
2019-10-18 20:41:07 +00:00
elif ((order['side'] == 'sell' and order['status'] == 'canceled')
2019-11-12 14:43:10 +00:00
or (self._check_timed_out('sell', order))):
2019-10-18 05:01:05 +00:00
self.handle_timedout_limit_sell(trade, order)
self.wallets.update()
def handle_buy_order_full_cancel(self, trade: Trade, reason: str) -> None:
"""Close trade in database and send message"""
Trade.session.delete(trade)
Trade.session.flush()
logger.info('Buy order %s for %s.', reason, trade)
self.rpc.send_msg({
'type': RPCMessageType.STATUS_NOTIFICATION,
'status': f'Unfilled buy order for {trade.pair} {reason}'
})
def handle_timedout_limit_buy(self, trade: Trade, order: Dict) -> bool:
"""
Buy timeout - cancel order
:return: True if order was fully cancelled
"""
2019-10-18 05:01:05 +00:00
reason = "cancelled due to timeout"
if order['status'] != 'canceled':
corder = self.exchange.cancel_order(trade.open_order_id, trade.pair)
else:
# Order was cancelled already, so we can reuse the existing dict
corder = order
reason = "canceled on Exchange"
if corder.get('remaining', order['remaining']) == order['amount']:
# if trade is not partially completed, just delete the trade
2019-10-18 05:01:05 +00:00
self.handle_buy_order_full_cancel(trade, reason)
return True
# 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.
trade.amount = order['amount'] - corder.get('remaining', order['remaining'])
trade.stake_amount = trade.amount * trade.open_rate
2019-10-18 04:46:48 +00:00
# verify if fees were taken from amount to avoid problems during selling
try:
2019-11-20 19:33:05 +00:00
new_amount = self.get_real_amount(trade, corder if 'fee' in corder else order,
trade.amount)
2019-10-18 04:46:48 +00:00
if not isclose(order['amount'], new_amount, abs_tol=constants.MATH_CLOSE_PREC):
trade.amount = new_amount
# Fee was applied, so set to 0
trade.fee_open = 0
trade.recalc_open_trade_price()
2019-10-18 04:46:48 +00:00
except DependencyException as e:
logger.warning("Could not update trade amount: %s", e)
trade.open_order_id = None
2018-03-25 19:37:14 +00:00
logger.info('Partial buy order timeout for %s.', trade)
2018-06-24 22:04:27 +00:00
self.rpc.send_msg({
'type': RPCMessageType.STATUS_NOTIFICATION,
'status': f'Remaining buy order for {trade.pair} cancelled due to timeout'
2018-06-24 22:04:27 +00:00
})
return False
def handle_timedout_limit_sell(self, trade: Trade, order: Dict) -> bool:
"""
Sell timeout - cancel order and update trade
:return: True if order was fully cancelled
"""
if order['remaining'] == order['amount']:
# if trade is not partially completed, just cancel the trade
if order["status"] != "canceled":
reason = "due to timeout"
self.exchange.cancel_order(trade.open_order_id, trade.pair)
logger.info('Sell order timeout for %s.', trade)
else:
reason = "on exchange"
2019-02-03 12:49:55 +00:00
logger.info('Sell order canceled on exchange for %s.', trade)
trade.close_rate = None
trade.close_profit = None
trade.close_date = None
trade.is_open = True
trade.open_order_id = None
2018-06-24 22:04:27 +00:00
self.rpc.send_msg({
'type': RPCMessageType.STATUS_NOTIFICATION,
'status': f'Unfilled sell order for {trade.pair} cancelled {reason}'
2018-06-24 22:04:27 +00:00
})
return True
# TODO: figure out how to handle partially complete sell orders
return False
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
: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.
"""
wallet_amount = self.wallets.get_free(pair.split('/')[0])
2019-12-13 06:06:54 +00:00
logger.debug(f"{pair} - Wallet: {wallet_amount} - Trade-amount: {amount}")
if wallet_amount > amount:
return amount
elif wallet_amount > amount * 0.98:
logger.info(f"{pair} - Falling back to wallet-amount.")
return wallet_amount
else:
raise DependencyException("Not enough amount to sell.")
def execute_sell(self, trade: Trade, limit: float, sell_reason: SellType) -> None:
"""
Executes a limit sell for the given trade and limit
:param trade: Trade instance
:param limit: limit rate for the sell order
:param sellreason: Reason the sell was triggered
:return: None
"""
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
if self.config.get('dry_run', False) and sell_type == 'stoploss' \
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
# First cancelling stoploss on exchange ...
if self.strategy.order_types.get('stoploss_on_exchange') and trade.stoploss_order_id:
try:
self.exchange.cancel_order(trade.stoploss_order_id, trade.pair)
except InvalidOrderException:
logger.exception(f"Could not cancel stoploss order {trade.stoploss_order_id}")
order_type = self.strategy.order_types[sell_type]
2019-09-01 07:09:07 +00:00
if sell_reason == SellType.EMERGENCY_SELL:
# Emergencysells (default to market!)
order_type = self.strategy.order_types.get("emergencysell", "market")
2019-09-01 07:09:07 +00:00
amount = self._safe_sell_amount(trade.pair, trade.amount)
# Execute sell and update trade record
order = self.exchange.sell(pair=str(trade.pair),
ordertype=order_type,
amount=amount, rate=limit,
time_in_force=self.strategy.order_time_in_force['sell']
)
2018-11-25 21:02:59 +00:00
trade.open_order_id = order['id']
trade.close_rate_requested = limit
trade.sell_reason = sell_reason.value
# In case of market sell orders the order can be closed immediately
if order.get('status', 'unknown') == 'closed':
trade.update(order)
Trade.session.flush()
# Lock pair for one candle to prevent immediate rebuys
self.strategy.lock_pair(trade.pair, timeframe_to_next_date(self.config['ticker_interval']))
self._notify_sell(trade, order_type)
def _notify_sell(self, trade: Trade, order_type: str):
"""
Sends rpc notification when a sell occured.
"""
profit_rate = trade.close_rate if trade.close_rate else trade.close_rate_requested
profit_trade = trade.calc_profit(rate=profit_rate)
# Use cached ticker here - it was updated seconds ago.
current_rate = self.get_sell_rate(trade.pair, False)
profit_percent = trade.calc_profit_ratio(profit_rate)
gain = "profit" if profit_percent > 0 else "loss"
msg = {
'type': RPCMessageType.SELL_NOTIFICATION,
'exchange': trade.exchange.capitalize(),
'pair': trade.pair,
'gain': gain,
'limit': trade.close_rate_requested,
'order_type': order_type,
'amount': trade.amount,
'open_rate': trade.open_rate,
'current_rate': current_rate,
'profit_amount': profit_trade,
'profit_percent': profit_percent,
'sell_reason': trade.sell_reason,
'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-01-02 11:38:25 +00:00
if 'fiat_display_currency' in self.config:
msg.update({
'fiat_currency': self.config['fiat_display_currency'],
})
# Send the message
self.rpc.send_msg(msg)
#
# Common update trade state methods
#
def update_trade_state(self, trade, action_order: dict = None):
"""
Checks trades with open orders and updates the amount if necessary
"""
# Get order details for actual price per unit
if trade.open_order_id:
# Update trade with order values
logger.info('Found open order for %s', trade)
try:
order = action_order or self.exchange.get_order(trade.open_order_id, trade.pair)
except InvalidOrderException as exception:
logger.warning('Unable to fetch order %s: %s', trade.open_order_id, exception)
return
# Try update amount (binance-fix)
try:
new_amount = self.get_real_amount(trade, order)
if not isclose(order['amount'], new_amount, abs_tol=constants.MATH_CLOSE_PREC):
order['amount'] = new_amount
# Fee was applied, so set to 0
trade.fee_open = 0
trade.recalc_open_trade_price()
except DependencyException as exception:
logger.warning("Could not update trade amount: %s", exception)
trade.update(order)
# Updating wallets when order is closed
if not trade.is_open:
self.wallets.update()
def get_real_amount(self, trade: Trade, order: Dict, order_amount: float = None) -> float:
"""
Get real amount for the trade
Necessary for exchanges which charge fees in base currency (e.g. binance)
"""
if order_amount is None:
order_amount = order['amount']
# Only run for closed orders
if trade.fee_open == 0 or order['status'] == 'open':
return order_amount
# use fee from order-dict if possible
if ('fee' in order and order['fee'] is not None and
(order['fee'].keys() >= {'currency', 'cost'})):
if (order['fee']['currency'] is not None and
order['fee']['cost'] is not None and
trade.pair.startswith(order['fee']['currency'])):
new_amount = order_amount - order['fee']['cost']
logger.info("Applying fee on amount for %s (from %s to %s) from Order",
trade, order['amount'], new_amount)
return new_amount
# Fallback to Trades
trades = self.exchange.get_trades_for_order(trade.open_order_id, trade.pair,
trade.open_date)
if len(trades) == 0:
logger.info("Applying fee on amount for %s failed: myTrade-Dict empty found", trade)
return order_amount
amount = 0
fee_abs = 0
for exectrade in trades:
amount += exectrade['amount']
if ("fee" in exectrade and exectrade['fee'] is not None and
(exectrade['fee'].keys() >= {'currency', 'cost'})):
# only applies if fee is in quote currency!
if (exectrade['fee']['currency'] is not None and
exectrade['fee']['cost'] is not None and
trade.pair.startswith(exectrade['fee']['currency'])):
fee_abs += exectrade['fee']['cost']
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")
real_amount = amount - fee_abs
if fee_abs != 0:
logger.info(f"Applying fee on amount for {trade} "
f"(from {order_amount} to {real_amount}) from Trades")
return real_amount