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
|
2022-06-07 05:03:40 +00:00
|
|
|
from datetime import datetime, time, timedelta, timezone
|
2019-09-26 05:04:56 +00:00
|
|
|
from math import isclose
|
2020-01-22 19:50:09 +00:00
|
|
|
from threading import Lock
|
2022-04-04 14:51:57 +00:00
|
|
|
from typing import Any, Dict, List, Optional, Tuple
|
2018-03-17 21:44:47 +00:00
|
|
|
|
2021-10-11 18:28:23 +00:00
|
|
|
from schedule import Scheduler
|
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
|
2022-09-18 11:20:36 +00:00
|
|
|
from freqtrade.constants import BuySell, Config, LongShort
|
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
|
2022-08-29 19:41:15 +00:00
|
|
|
from freqtrade.enums import (ExitCheckTuple, ExitType, RPCMessageType, RunMode, SignalDirection,
|
|
|
|
State, TradingMode)
|
2020-08-14 08:59:55 +00:00
|
|
|
from freqtrade.exceptions import (DependencyException, ExchangeError, InsufficientFundsError,
|
2022-02-28 18:45:15 +00:00
|
|
|
InvalidOrderException, PricingError)
|
2022-08-25 05:08:58 +00:00
|
|
|
from freqtrade.exchange import timeframe_to_minutes, timeframe_to_next_date, timeframe_to_seconds
|
2022-08-29 19:41:15 +00:00
|
|
|
from freqtrade.misc import safe_value_fallback, safe_value_fallback2
|
2020-11-22 10:41:09 +00:00
|
|
|
from freqtrade.mixins import LoggingMixin
|
2022-08-06 15:45:18 +00:00
|
|
|
from freqtrade.persistence import Order, PairLocks, Trade, init_db
|
2020-12-23 16:00:02 +00:00
|
|
|
from freqtrade.plugins.pairlistmanager import PairListManager
|
2020-10-14 18:03:56 +00:00
|
|
|
from freqtrade.plugins.protectionmanager import ProtectionManager
|
2019-11-09 05:55:16 +00:00
|
|
|
from freqtrade.resolvers import ExchangeResolver, StrategyResolver
|
2021-06-09 17:51:44 +00:00
|
|
|
from freqtrade.rpc import RPCManager
|
2022-08-31 17:43:02 +00:00
|
|
|
from freqtrade.rpc.external_message_consumer import ExternalMessageConsumer
|
2022-03-25 05:50:18 +00:00
|
|
|
from freqtrade.strategy.interface import IStrategy
|
2020-02-06 19:30:17 +00:00
|
|
|
from freqtrade.strategy.strategy_wrapper import strategy_safe_wrapper
|
2022-08-11 04:34:12 +00:00
|
|
|
from freqtrade.util import FtPrecise
|
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__)
|
|
|
|
|
|
|
|
|
2020-11-22 10:41:09 +00:00
|
|
|
class FreqtradeBot(LoggingMixin):
|
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.
|
|
|
|
"""
|
|
|
|
|
2022-09-18 11:20:36 +00:00
|
|
|
def __init__(self, config: Config) -> 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
|
|
|
"""
|
2021-06-02 08:39:49 +00:00
|
|
|
self.active_pair_whitelist: List[str] = []
|
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
|
|
|
|
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
|
|
|
|
2022-07-23 17:56:38 +00:00
|
|
|
self.exchange = ExchangeResolver.load_exchange(
|
|
|
|
self.config['exchange']['name'], self.config, load_leverage_tiers=True)
|
2019-02-17 03:18:56 +00:00
|
|
|
|
2022-06-23 18:43:35 +00:00
|
|
|
init_db(self.config['db_url'])
|
2019-12-15 08:38:18 +00:00
|
|
|
|
2019-12-15 08:48:35 +00:00
|
|
|
self.wallets = Wallets(self.config, self.exchange)
|
|
|
|
|
2020-10-26 06:37:07 +00:00
|
|
|
PairLocks.timeframe = self.config['timeframe']
|
|
|
|
|
2022-08-22 04:45:36 +00:00
|
|
|
self.pairlists = PairListManager(self.exchange, self.config)
|
|
|
|
|
2021-06-02 08:39:49 +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)
|
|
|
|
|
2022-08-31 17:43:02 +00:00
|
|
|
self.dataprovider = DataProvider(self.config, self.exchange, self.pairlists, self.rpc)
|
2018-12-26 13:32:17 +00:00
|
|
|
|
2021-09-19 23:44:12 +00:00
|
|
|
# Attach Dataprovider to strategy instance
|
|
|
|
self.strategy.dp = self.dataprovider
|
|
|
|
# Attach Wallets to strategy instance
|
|
|
|
self.strategy.wallets = self.wallets
|
2018-12-26 13:32:17 +00:00
|
|
|
|
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
|
|
|
|
2022-08-31 01:21:34 +00:00
|
|
|
# Init ExternalMessageConsumer if enabled
|
2022-08-31 16:40:26 +00:00
|
|
|
self.emc = ExternalMessageConsumer(self.config, self.dataprovider) if \
|
2022-08-31 01:21:34 +00:00
|
|
|
self.config.get('external_message_consumer', {}).get('enabled', False) else None
|
|
|
|
|
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
|
|
|
|
2021-09-08 07:12:08 +00:00
|
|
|
# Protect exit-logic from forcesell and vice versa
|
2021-09-08 06:49:04 +00:00
|
|
|
self._exit_lock = Lock()
|
2020-11-22 10:41:09 +00:00
|
|
|
LoggingMixin.__init__(self, logger, timeframe_to_seconds(self.strategy.timeframe))
|
2019-10-24 19:33:44 +00:00
|
|
|
|
2022-02-21 18:19:12 +00:00
|
|
|
self.trading_mode: TradingMode = self.config.get('trading_mode', TradingMode.SPOT)
|
2021-09-11 05:39:31 +00:00
|
|
|
|
2021-10-11 18:28:23 +00:00
|
|
|
self._schedule = Scheduler()
|
2021-08-03 18:55:22 +00:00
|
|
|
|
2021-09-08 19:56:58 +00:00
|
|
|
if self.trading_mode == TradingMode.FUTURES:
|
2021-10-06 07:39:02 +00:00
|
|
|
|
|
|
|
def update():
|
|
|
|
self.update_funding_fees()
|
2021-09-08 19:56:58 +00:00
|
|
|
self.wallets.update()
|
|
|
|
|
2021-10-09 23:48:53 +00:00
|
|
|
# TODO: This would be more efficient if scheduled in utc time, and performed at each
|
|
|
|
# TODO: funding interval, specified by funding_fee_times on the exchange classes
|
2021-10-09 17:27:26 +00:00
|
|
|
for time_slot in range(0, 24):
|
2021-10-09 23:48:53 +00:00
|
|
|
for minutes in [0, 15, 30, 45]:
|
2021-10-11 07:31:21 +00:00
|
|
|
t = str(time(time_slot, minutes, 2))
|
2021-10-11 18:28:23 +00:00
|
|
|
self._schedule.every().day.at(t).do(update)
|
2022-01-28 06:57:43 +00:00
|
|
|
self.last_process = datetime(1970, 1, 1, tzinfo=timezone.utc)
|
2021-09-11 05:39:31 +00:00
|
|
|
|
2022-05-25 18:01:21 +00:00
|
|
|
self.strategy.ft_bot_start()
|
2022-06-13 17:59:00 +00:00
|
|
|
# Initialize protections AFTER bot start - otherwise parameters are not loaded.
|
|
|
|
self.protections = ProtectionManager(self.config, self.strategy.protections)
|
2022-04-01 14:39:56 +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({
|
2021-04-20 04:41:58 +00:00
|
|
|
'type': RPCMessageType.STATUS,
|
2020-01-27 00:34:53 +00:00
|
|
|
'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 ...')
|
2022-09-06 18:25:46 +00:00
|
|
|
try:
|
|
|
|
# Wrap db activities in shutdown to avoid problems if database is gone,
|
|
|
|
# and raises further exceptions.
|
|
|
|
if self.config['cancel_open_orders_on_exit']:
|
|
|
|
self.cancel_all_open_orders()
|
2019-03-10 17:05:33 +00:00
|
|
|
|
2022-09-06 18:25:46 +00:00
|
|
|
self.check_for_open_trades()
|
2020-06-28 09:02:50 +00:00
|
|
|
|
2022-09-06 18:25:46 +00:00
|
|
|
finally:
|
|
|
|
self.strategy.ft_bot_cleanup()
|
2022-09-03 19:24:14 +00:00
|
|
|
|
2018-02-04 09:21:16 +00:00
|
|
|
self.rpc.cleanup()
|
2022-08-31 01:21:34 +00:00
|
|
|
if self.emc:
|
|
|
|
self.emc.shutdown()
|
2022-08-06 15:45:18 +00:00
|
|
|
Trade.commit()
|
2021-12-31 10:21:02 +00:00
|
|
|
self.exchange.close()
|
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
|
|
|
|
"""
|
2020-12-07 09:54:37 +00:00
|
|
|
self.rpc.startup_messages(self.config, self.pairlists, self.protections)
|
2022-08-15 17:58:40 +00:00
|
|
|
# Update older trades with precision and precision mode
|
|
|
|
self.startup_backpopulate_precision()
|
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
|
2021-09-30 05:24:16 +00:00
|
|
|
self.startup_update_open_orders()
|
2020-08-13 17:37:41 +00:00
|
|
|
|
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),
|
2021-09-19 23:44:12 +00:00
|
|
|
self.strategy.gather_informative_pairs())
|
2019-03-22 21:20:20 +00:00
|
|
|
|
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
|
|
|
|
2022-09-02 02:06:36 +00:00
|
|
|
self.strategy.analyze(self.active_pair_whitelist)
|
2020-06-13 16:06:52 +00:00
|
|
|
|
2021-09-08 06:49:04 +00:00
|
|
|
with self._exit_lock:
|
2022-04-16 12:03:09 +00:00
|
|
|
# Check for exchange cancelations, timeouts and user requested replace
|
|
|
|
self.manage_open_orders()
|
2020-03-24 16:16:35 +00:00
|
|
|
|
2022-04-05 10:31:53 +00:00
|
|
|
# Protect from collisions with force_exit.
|
2020-01-22 19:50:09 +00:00
|
|
|
# Without this, freqtrade my try to recreate stoploss_on_exchange orders
|
2021-09-08 07:12:08 +00:00
|
|
|
# while exiting is in process, since telegram messages arrive in an different thread.
|
2021-09-08 06:49:04 +00:00
|
|
|
with self._exit_lock:
|
2021-02-18 11:49:14 +00:00
|
|
|
trades = Trade.get_open_trades()
|
2020-01-22 19:50:09 +00:00
|
|
|
# First process current opened trades (positions)
|
|
|
|
self.exit_positions(trades)
|
2019-03-22 21:20:20 +00:00
|
|
|
|
2021-12-07 09:16:11 +00:00
|
|
|
# Check if we need to adjust our current positions before attempting to buy new trades.
|
2021-12-24 10:38:43 +00:00
|
|
|
if self.strategy.position_adjustment_enable:
|
2022-01-13 16:18:07 +00:00
|
|
|
with self._exit_lock:
|
|
|
|
self.process_open_trade_positions()
|
2021-12-07 09:16:11 +00:00
|
|
|
|
2019-03-22 21:20:20 +00:00
|
|
|
# Then looking for buy opportunities
|
2020-10-24 12:46:13 +00:00
|
|
|
if self.get_free_open_trades():
|
2019-12-30 19:50:56 +00:00
|
|
|
self.enter_positions()
|
2021-10-12 17:10:38 +00:00
|
|
|
if self.trading_mode == TradingMode.FUTURES:
|
|
|
|
self._schedule.run_pending()
|
2021-04-15 05:57:52 +00:00
|
|
|
Trade.commit()
|
2022-07-26 18:15:49 +00:00
|
|
|
self.rpc.process_msg_queue(self.dataprovider._msg_queue)
|
2022-01-28 06:57:43 +00:00
|
|
|
self.last_process = datetime.now(timezone.utc)
|
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
|
|
|
"""
|
2021-11-05 17:49:10 +00:00
|
|
|
Notify the user when the bot is stopped (not reloaded)
|
2020-06-27 16:40:44 +00:00
|
|
|
and there are still open trades active.
|
|
|
|
"""
|
2022-06-09 05:04:46 +00:00
|
|
|
open_trades = Trade.get_open_trades()
|
2020-06-27 16:35:46 +00:00
|
|
|
|
2021-11-07 09:55:11 +00:00
|
|
|
if len(open_trades) != 0 and self.state != State.RELOAD_CONFIG:
|
2020-06-27 16:35:46 +00:00
|
|
|
msg = {
|
2021-04-20 04:41:58 +00:00
|
|
|
'type': RPCMessageType.WARNING,
|
2021-11-07 09:55:11 +00:00
|
|
|
'status':
|
|
|
|
f"{len(open_trades)} open trades active.\n\n"
|
|
|
|
f"Handle these trades manually on {self.exchange.name}, "
|
2022-08-28 09:32:53 +00:00
|
|
|
f"or '/start' the bot again and use '/stopentry' "
|
2021-11-07 09:55:11 +00:00
|
|
|
f"to handle open trades gracefully. \n"
|
|
|
|
f"{'Note: Trades are simulated (dry run).' 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
|
2022-09-02 02:06:36 +00:00
|
|
|
_prev_whitelist = self.pairlists.whitelist
|
2019-10-26 07:38:29 +00:00
|
|
|
self.pairlists.refresh_pairlist()
|
|
|
|
_whitelist = self.pairlists.whitelist
|
|
|
|
|
|
|
|
# Calculating Edge positioning
|
|
|
|
if self.edge:
|
2021-03-30 18:20:24 +00:00
|
|
|
self.edge.calculate(_whitelist)
|
2019-10-26 07:38:29 +00:00
|
|
|
_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])
|
2022-08-19 06:06:19 +00:00
|
|
|
|
2022-09-02 02:06:36 +00:00
|
|
|
# Called last to include the included pairs
|
|
|
|
if _prev_whitelist != _whitelist:
|
|
|
|
self.rpc.send_msg({'type': RPCMessageType.WHITELIST, 'data': _whitelist})
|
|
|
|
|
2019-10-26 07:38:29 +00:00
|
|
|
return _whitelist
|
2019-02-20 12:12:04 +00:00
|
|
|
|
2021-02-03 19:00:33 +00:00
|
|
|
def get_free_open_trades(self) -> int:
|
2019-12-28 00:46:42 +00:00
|
|
|
"""
|
|
|
|
Return the number of free open trades slots or 0 if
|
|
|
|
max number of open trades reached
|
|
|
|
"""
|
2022-08-21 08:03:04 +00:00
|
|
|
open_trades = Trade.get_open_trade_count()
|
2019-12-28 00:46:42 +00:00
|
|
|
return max(0, self.config['max_open_trades'] - open_trades)
|
|
|
|
|
2021-09-08 19:56:58 +00:00
|
|
|
def update_funding_fees(self):
|
|
|
|
if self.trading_mode == TradingMode.FUTURES:
|
2021-11-04 04:52:37 +00:00
|
|
|
trades = Trade.get_open_trades()
|
2022-09-08 05:18:38 +00:00
|
|
|
try:
|
|
|
|
for trade in trades:
|
|
|
|
funding_fees = self.exchange.get_funding_fees(
|
|
|
|
pair=trade.pair,
|
|
|
|
amount=trade.amount,
|
|
|
|
is_short=trade.is_short,
|
|
|
|
open_date=trade.date_last_filled_utc
|
|
|
|
)
|
|
|
|
trade.funding_fees = funding_fees
|
|
|
|
except ExchangeError:
|
|
|
|
logger.warning("Could not update funding fees for open trades.")
|
2021-09-08 19:56:58 +00:00
|
|
|
|
2022-08-15 17:58:40 +00:00
|
|
|
def startup_backpopulate_precision(self):
|
|
|
|
|
2022-08-22 18:32:55 +00:00
|
|
|
trades = Trade.get_trades([Trade.contract_size.is_(None)])
|
2022-08-15 17:58:40 +00:00
|
|
|
for trade in trades:
|
2022-08-16 07:32:31 +00:00
|
|
|
if trade.exchange != self.exchange.id:
|
|
|
|
continue
|
2022-08-15 17:58:40 +00:00
|
|
|
trade.precision_mode = self.exchange.precisionMode
|
|
|
|
trade.amount_precision = self.exchange.get_precision_amount(trade.pair)
|
|
|
|
trade.price_precision = self.exchange.get_precision_price(trade.pair)
|
2022-08-22 18:32:55 +00:00
|
|
|
trade.contract_size = self.exchange.get_contract_size(trade.pair)
|
2022-08-15 17:58:40 +00:00
|
|
|
Trade.commit()
|
|
|
|
|
2021-09-30 05:24:16 +00:00
|
|
|
def startup_update_open_orders(self):
|
2020-08-13 15:18:56 +00:00
|
|
|
"""
|
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
|
|
|
"""
|
2021-02-05 19:17:38 +00:00
|
|
|
if self.config['dry_run'] or self.config['exchange'].get('skip_open_order_update', False):
|
2021-01-06 08:57:36 +00:00
|
|
|
# Updating open orders in dry-run does not make sense and will fail.
|
|
|
|
return
|
|
|
|
|
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
|
|
|
|
2022-05-22 07:01:46 +00:00
|
|
|
self.update_trade_state(order.trade, order.order_id, fo,
|
|
|
|
stoploss_order=(order.ft_order_side == 'stoploss'))
|
2020-08-13 17:37:41 +00:00
|
|
|
|
2022-06-07 05:03:40 +00:00
|
|
|
except InvalidOrderException as e:
|
|
|
|
logger.warning(f"Error updating Order {order.order_id} due to {e}.")
|
|
|
|
if order.order_date_utc - timedelta(days=5) < datetime.now(timezone.utc):
|
|
|
|
logger.warning(
|
|
|
|
"Order is older than 5 days. Assuming order was fully cancelled.")
|
|
|
|
fo = order.to_ccxt_object()
|
|
|
|
fo['status'] = 'canceled'
|
|
|
|
self.handle_timedout_order(fo, order.trade)
|
|
|
|
|
2020-09-06 17:32:00 +00:00
|
|
|
except ExchangeError as e:
|
2021-01-06 08:57:36 +00:00
|
|
|
|
2020-09-06 17:32:00 +00:00
|
|
|
logger.warning(f"Error updating Order {order.order_id} due to {e}")
|
2020-08-13 15:18:56 +00:00
|
|
|
|
2021-09-08 19:56:58 +00:00
|
|
|
if self.trading_mode == TradingMode.FUTURES:
|
2021-10-11 18:28:23 +00:00
|
|
|
self._schedule.run_pending()
|
2021-09-08 19:56:58 +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.
|
2021-05-16 12:50:25 +00:00
|
|
|
Only acts when Orders are in the database, otherwise the last order-id is unknown.
|
2020-08-22 06:39:10 +00:00
|
|
|
"""
|
2021-01-17 19:31:27 +00:00
|
|
|
if self.config['dry_run']:
|
|
|
|
# Updating open orders in dry-run does not make sense and will fail.
|
|
|
|
return
|
|
|
|
|
2021-06-20 04:19:09 +00:00
|
|
|
trades: List[Trade] = Trade.get_closed_trades_without_assigned_fees()
|
2020-08-22 06:39:10 +00:00
|
|
|
for trade in trades:
|
2021-09-10 17:34:57 +00:00
|
|
|
if not trade.is_open and not trade.fee_updated(trade.exit_side):
|
2020-08-22 06:39:10 +00:00
|
|
|
# Get sell fee
|
2021-09-10 17:34:57 +00:00
|
|
|
order = trade.select_order(trade.exit_side, False)
|
2022-07-16 10:52:35 +00:00
|
|
|
if not order:
|
|
|
|
order = trade.select_order('stoploss', False)
|
2020-08-22 06:39:10 +00:00
|
|
|
if order:
|
2021-09-10 17:34:57 +00:00
|
|
|
logger.info(
|
|
|
|
f"Updating {trade.exit_side}-fee on trade {trade}"
|
|
|
|
f"for order {order.order_id}."
|
|
|
|
)
|
2020-08-22 07:30:25 +00:00
|
|
|
self.update_trade_state(trade, order.order_id,
|
2021-11-30 19:19:59 +00:00
|
|
|
stoploss_order=order.ft_order_side == 'stoploss',
|
|
|
|
send_msg=False)
|
2020-08-22 13:48:42 +00:00
|
|
|
|
|
|
|
trades: List[Trade] = Trade.get_open_trades_without_assigned_fees()
|
|
|
|
for trade in trades:
|
2022-04-06 01:02:13 +00:00
|
|
|
if trade.is_open and not trade.fee_updated(trade.entry_side):
|
|
|
|
order = trade.select_order(trade.entry_side, False)
|
|
|
|
open_order = trade.select_order(trade.entry_side, True)
|
2021-12-20 20:07:42 +00:00
|
|
|
if order and open_order is None:
|
2021-09-10 17:34:57 +00:00
|
|
|
logger.info(
|
2022-04-06 01:02:13 +00:00
|
|
|
f"Updating {trade.entry_side}-fee on trade {trade}"
|
2021-09-10 17:34:57 +00:00
|
|
|
f"for order {order.order_id}."
|
|
|
|
)
|
2021-11-30 19:19:59 +00:00
|
|
|
self.update_trade_state(trade, order.order_id, send_msg=False)
|
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-14 08:59:55 +00:00
|
|
|
"""
|
|
|
|
Try refinding a lost trade.
|
2021-09-08 07:12:08 +00:00
|
|
|
Only used when InsufficientFunds appears on exit orders (stoploss or long sell/short buy).
|
2020-08-14 08:59:55 +00:00
|
|
|
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-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
|
2021-09-10 17:34:57 +00:00
|
|
|
elif order.ft_order_side == trade.exit_side:
|
2020-08-14 08:59:55 +00:00
|
|
|
if fo and fo['status'] == 'open':
|
|
|
|
# Assume this as the open order
|
|
|
|
trade.open_order_id = order.order_id
|
2022-04-06 01:02:13 +00:00
|
|
|
elif order.ft_order_side == trade.entry_side:
|
2022-02-12 19:13:12 +00:00
|
|
|
if fo and fo['status'] == 'open':
|
|
|
|
trade.open_order_id = order.order_id
|
2020-08-14 08:59:55 +00:00
|
|
|
if fo:
|
2021-06-08 19:04:34 +00:00
|
|
|
logger.info(f"Found {order} for trade {trade}.")
|
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:
|
|
|
|
"""
|
2021-09-09 08:10:12 +00:00
|
|
|
Tries to execute entry orders for new trades (positions)
|
2020-01-01 23:53:25 +00:00
|
|
|
"""
|
|
|
|
trades_created = 0
|
|
|
|
|
|
|
|
whitelist = copy.deepcopy(self.active_pair_whitelist)
|
|
|
|
if not whitelist:
|
2022-08-18 07:09:37 +00:00
|
|
|
self.log_once("Active pair whitelist is empty.", logger.info)
|
2020-10-25 09:54:30 +00:00
|
|
|
return trades_created
|
|
|
|
# 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:
|
2022-08-18 07:09:37 +00:00
|
|
|
self.log_once("No currency pair in active pair whitelist, "
|
|
|
|
"but checking to exit open trades.", logger.info)
|
2020-10-25 09:54:30 +00:00
|
|
|
return trades_created
|
2022-04-24 12:10:25 +00:00
|
|
|
if PairLocks.is_global_lock(side='*'):
|
|
|
|
# This only checks for total locks (both sides).
|
|
|
|
# per-side locks will be evaluated by `is_pair_locked` within create_trade,
|
|
|
|
# once the direction for the trade is clear.
|
2020-11-25 10:54:11 +00:00
|
|
|
lock = PairLocks.get_pair_longest_lock('*')
|
|
|
|
if lock:
|
|
|
|
self.log_once(f"Global pairlock active until "
|
|
|
|
f"{lock.lock_end_time.strftime(constants.DATETIME_PRINT_FORMAT)}. "
|
2021-04-21 21:02:33 +00:00
|
|
|
f"Not creating new trades, reason: {lock.reason}.", logger.info)
|
2020-11-25 10:54:11 +00:00
|
|
|
else:
|
|
|
|
self.log_once("Global pairlock active. Not creating new trades.", logger.info)
|
2020-10-24 12:46:13 +00:00
|
|
|
return trades_created
|
2020-10-25 09:54:30 +00:00
|
|
|
# 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)
|
2020-01-01 23:53:25 +00:00
|
|
|
|
2020-10-26 06:37:07 +00:00
|
|
|
if not trades_created:
|
2021-09-08 07:48:22 +00:00
|
|
|
logger.debug("Found no enter signals for whitelisted currencies. Trying again...")
|
2020-01-01 23:53:25 +00:00
|
|
|
|
|
|
|
return trades_created
|
|
|
|
|
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)
|
2020-11-25 10:54:11 +00:00
|
|
|
nowtime = analyzed_df.iloc[-1]['date'] if len(analyzed_df) > 0 else None
|
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
|
2021-09-27 05:07:49 +00:00
|
|
|
(signal, enter_tag) = self.strategy.get_entry_signal(
|
2021-07-20 16:56:03 +00:00
|
|
|
pair,
|
|
|
|
self.strategy.timeframe,
|
|
|
|
analyzed_df
|
2021-09-08 06:45:55 +00:00
|
|
|
)
|
2018-09-26 14:36:41 +00:00
|
|
|
|
2021-09-27 05:07:49 +00:00
|
|
|
if signal:
|
2022-04-24 12:10:25 +00:00
|
|
|
if self.strategy.is_pair_locked(pair, candle_date=nowtime, side=signal):
|
|
|
|
lock = PairLocks.get_pair_longest_lock(pair, nowtime, signal)
|
|
|
|
if lock:
|
|
|
|
self.log_once(f"Pair {pair} {lock.side} is locked until "
|
|
|
|
f"{lock.lock_end_time.strftime(constants.DATETIME_PRINT_FORMAT)} "
|
|
|
|
f"due to {lock.reason}.",
|
|
|
|
logger.info)
|
|
|
|
else:
|
|
|
|
self.log_once(f"Pair {pair} is currently locked.", logger.info)
|
|
|
|
return False
|
2021-04-21 18:01:10 +00:00
|
|
|
stake_amount = self.wallets.get_trade_stake_amount(pair, self.edge)
|
2018-07-31 18:25:10 +00:00
|
|
|
|
2022-03-27 16:03:49 +00:00
|
|
|
bid_check_dom = self.config.get('entry_pricing', {}).get('check_depth_of_market', {})
|
2019-12-30 13:00:34 +00:00
|
|
|
if ((bid_check_dom.get('enabled', False)) and
|
2021-07-21 13:05:35 +00:00
|
|
|
(bid_check_dom.get('bids_to_ask_delta', 0) > 0)):
|
2021-10-18 06:16:49 +00:00
|
|
|
if self._check_depth_of_market(pair, bid_check_dom, side=signal):
|
2021-10-09 22:32:22 +00:00
|
|
|
return self.execute_entry(
|
|
|
|
pair,
|
|
|
|
stake_amount,
|
|
|
|
enter_tag=enter_tag,
|
|
|
|
is_short=(signal == SignalDirection.SHORT)
|
|
|
|
)
|
2019-12-29 01:17:49 +00:00
|
|
|
else:
|
|
|
|
return False
|
2019-08-13 08:01:29 +00:00
|
|
|
|
2021-10-09 22:32:22 +00:00
|
|
|
return self.execute_entry(
|
|
|
|
pair,
|
|
|
|
stake_amount,
|
|
|
|
enter_tag=enter_tag,
|
|
|
|
is_short=(signal == SignalDirection.SHORT)
|
|
|
|
)
|
2019-12-29 01:17:49 +00:00
|
|
|
else:
|
|
|
|
return False
|
2018-07-10 13:10:56 +00:00
|
|
|
|
2021-12-07 09:16:11 +00:00
|
|
|
#
|
2021-12-18 09:01:06 +00:00
|
|
|
# BUY / increase positions / DCA logic and methods
|
2021-12-07 09:16:11 +00:00
|
|
|
#
|
2021-12-09 12:47:44 +00:00
|
|
|
def process_open_trade_positions(self):
|
2021-12-07 09:16:11 +00:00
|
|
|
"""
|
2021-12-09 12:47:44 +00:00
|
|
|
Tries to execute additional buy or sell orders for open trades (positions)
|
2021-12-07 09:16:11 +00:00
|
|
|
"""
|
2021-12-09 12:47:44 +00:00
|
|
|
# Walk through each pair and check if it needs changes
|
2021-12-07 09:16:11 +00:00
|
|
|
for trade in Trade.get_open_trades():
|
2021-12-24 10:38:43 +00:00
|
|
|
# If there is any open orders, wait for them to finish.
|
2022-01-08 15:20:02 +00:00
|
|
|
if trade.open_order_id is None:
|
2021-12-27 17:41:33 +00:00
|
|
|
try:
|
|
|
|
self.check_and_call_adjust_trade_position(trade)
|
|
|
|
except DependencyException as exception:
|
2022-01-23 18:07:37 +00:00
|
|
|
logger.warning(
|
|
|
|
f"Unable to adjust position of trade for {trade.pair}: {exception}")
|
2021-12-07 09:16:11 +00:00
|
|
|
|
2021-12-24 10:38:43 +00:00
|
|
|
def check_and_call_adjust_trade_position(self, trade: Trade):
|
2021-12-07 09:16:11 +00:00
|
|
|
"""
|
|
|
|
Check the implemented trading strategy for adjustment command.
|
2021-12-11 16:25:05 +00:00
|
|
|
If the strategy triggers the adjustment, a new order gets issued.
|
2021-12-07 09:16:11 +00:00
|
|
|
Once that completes, the existing trade is modified to match new data.
|
|
|
|
"""
|
2022-07-31 12:19:04 +00:00
|
|
|
current_entry_rate, current_exit_rate = self.exchange.get_rates(
|
|
|
|
trade.pair, True, trade.is_short)
|
2022-01-11 10:05:57 +00:00
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
current_entry_profit = trade.calc_profit_ratio(current_entry_rate)
|
|
|
|
current_exit_profit = trade.calc_profit_ratio(current_exit_rate)
|
|
|
|
|
|
|
|
min_entry_stake = self.exchange.get_min_pair_stake_amount(trade.pair,
|
|
|
|
current_entry_rate,
|
|
|
|
self.strategy.stoploss)
|
|
|
|
min_exit_stake = self.exchange.get_min_pair_stake_amount(trade.pair,
|
|
|
|
current_exit_rate,
|
|
|
|
self.strategy.stoploss)
|
|
|
|
max_entry_stake = self.exchange.get_max_pair_stake_amount(trade.pair, current_entry_rate)
|
2022-02-02 02:39:22 +00:00
|
|
|
stake_available = self.wallets.get_available_stake_amount()
|
2021-12-24 10:38:43 +00:00
|
|
|
logger.debug(f"Calling adjust_trade_position for pair {trade.pair}")
|
2021-12-18 09:01:06 +00:00
|
|
|
stake_amount = strategy_safe_wrapper(self.strategy.adjust_trade_position,
|
|
|
|
default_retval=None)(
|
2022-07-31 12:19:04 +00:00
|
|
|
trade=trade,
|
|
|
|
current_time=datetime.now(timezone.utc), current_rate=current_entry_rate,
|
|
|
|
current_profit=current_entry_profit, min_stake=min_entry_stake,
|
|
|
|
max_stake=min(max_entry_stake, stake_available),
|
|
|
|
current_entry_rate=current_entry_rate, current_exit_rate=current_exit_rate,
|
|
|
|
current_entry_profit=current_entry_profit, current_exit_profit=current_exit_profit
|
|
|
|
)
|
2021-12-07 09:16:11 +00:00
|
|
|
|
2021-12-18 09:01:06 +00:00
|
|
|
if stake_amount is not None and stake_amount > 0.0:
|
2021-12-07 09:16:11 +00:00
|
|
|
# We should increase our position
|
2022-07-31 12:19:04 +00:00
|
|
|
if self.strategy.max_entry_position_adjustment > -1:
|
|
|
|
count_of_entries = trade.nr_of_successful_entries
|
|
|
|
if count_of_entries > self.strategy.max_entry_position_adjustment:
|
|
|
|
logger.debug(f"Max adjustment entries for {trade.pair} has been reached.")
|
|
|
|
return
|
|
|
|
else:
|
|
|
|
logger.debug("Max adjustment entries is set to unlimited.")
|
|
|
|
self.execute_entry(trade.pair, stake_amount, price=current_entry_rate,
|
2022-05-14 14:16:32 +00:00
|
|
|
trade=trade, is_short=trade.is_short)
|
2021-12-07 09:16:11 +00:00
|
|
|
|
2021-12-18 09:01:06 +00:00
|
|
|
if stake_amount is not None and stake_amount < 0.0:
|
2021-12-07 09:16:11 +00:00
|
|
|
# We should decrease our position
|
2022-09-07 04:43:08 +00:00
|
|
|
amount = self.exchange.amount_to_contract_precision(
|
|
|
|
trade.pair,
|
|
|
|
abs(float(FtPrecise(stake_amount) / FtPrecise(current_exit_rate))))
|
2022-07-31 12:19:04 +00:00
|
|
|
if amount > trade.amount:
|
|
|
|
# This is currently ineffective as remaining would become < min tradable
|
|
|
|
# Fixing this would require checking for 0.0 there -
|
|
|
|
# if we decide that this callback is allowed to "fully exit"
|
|
|
|
logger.info(
|
|
|
|
f"Adjusting amount to trade.amount as it is higher. {amount} > {trade.amount}")
|
|
|
|
amount = trade.amount
|
|
|
|
|
2022-09-07 04:43:08 +00:00
|
|
|
if amount == 0.0:
|
|
|
|
logger.info("Amount to sell is 0.0 due to exchange limits - not selling.")
|
|
|
|
return
|
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
remaining = (trade.amount - amount) * current_exit_rate
|
|
|
|
if remaining < min_exit_stake:
|
2022-09-07 04:43:08 +00:00
|
|
|
logger.info(f"Remaining amount of {remaining} would be smaller "
|
|
|
|
f"than the minimum of {min_exit_stake}.")
|
2022-07-31 12:19:04 +00:00
|
|
|
return
|
|
|
|
|
|
|
|
self.execute_trade_exit(trade, current_exit_rate, exit_check=ExitCheckTuple(
|
|
|
|
exit_type=ExitType.PARTIAL_EXIT), sub_trade_amt=amount)
|
2021-12-07 09:16:11 +00:00
|
|
|
|
2022-03-27 15:00:45 +00:00
|
|
|
def _check_depth_of_market(self, pair: str, conf: Dict, side: SignalDirection) -> 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()
|
2021-09-10 17:34:57 +00:00
|
|
|
|
2022-04-06 01:02:13 +00:00
|
|
|
entry_side = order_book_bids if side == SignalDirection.LONG else order_book_asks
|
2021-09-10 17:34:57 +00:00
|
|
|
exit_side = order_book_asks if side == SignalDirection.LONG else order_book_bids
|
2022-04-06 01:02:13 +00:00
|
|
|
bids_ask_delta = entry_side / exit_side
|
2021-09-10 17:34:57 +00:00
|
|
|
|
|
|
|
bids = f"Bids: {order_book_bids}"
|
|
|
|
asks = f"Asks: {order_book_asks}"
|
|
|
|
delta = f"Delta: {bids_ask_delta}"
|
|
|
|
|
2020-01-28 16:09:44 +00:00
|
|
|
logger.info(
|
2021-09-10 17:34:57 +00:00
|
|
|
f"{bids}, {asks}, {delta}, Direction: {side.value}"
|
2020-02-04 00:57:24 +00:00
|
|
|
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
|
|
|
|
2021-09-10 17:34:57 +00:00
|
|
|
def execute_entry(
|
|
|
|
self,
|
|
|
|
pair: str,
|
|
|
|
stake_amount: float,
|
|
|
|
price: Optional[float] = None,
|
2021-12-01 06:11:11 +00:00
|
|
|
*,
|
2021-09-10 17:34:57 +00:00
|
|
|
is_short: bool = False,
|
2021-12-01 06:11:11 +00:00
|
|
|
ordertype: Optional[str] = None,
|
2022-01-22 16:25:21 +00:00
|
|
|
enter_tag: Optional[str] = None,
|
|
|
|
trade: Optional[Trade] = None,
|
2022-08-02 18:15:47 +00:00
|
|
|
order_adjust: bool = False,
|
|
|
|
leverage_: Optional[float] = None,
|
2021-09-10 17:34:57 +00:00
|
|
|
) -> 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
|
2021-06-25 17:13:31 +00:00
|
|
|
:param stake_amount: amount of stake-currency for the pair
|
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
|
|
|
"""
|
2022-03-07 06:09:01 +00:00
|
|
|
time_in_force = self.strategy.order_time_in_force['entry']
|
2018-09-26 14:36:41 +00:00
|
|
|
|
2022-05-07 06:45:37 +00:00
|
|
|
side: BuySell = 'sell' if is_short else 'buy'
|
|
|
|
name = 'Short' if is_short else 'Long'
|
2022-04-04 14:51:57 +00:00
|
|
|
trade_side: LongShort = 'short' if is_short else 'long'
|
2021-12-18 09:01:06 +00:00
|
|
|
pos_adjust = trade is not None
|
2021-09-10 17:34:57 +00:00
|
|
|
|
2022-03-19 14:27:06 +00:00
|
|
|
enter_limit_requested, stake_amount, leverage = self.get_valid_enter_price_and_stake(
|
2022-08-02 18:15:47 +00:00
|
|
|
pair, price, stake_amount, trade_side, enter_tag, trade, order_adjust, leverage_)
|
2021-07-11 09:20:31 +00:00
|
|
|
|
|
|
|
if not stake_amount:
|
2018-06-16 23:23:12 +00:00
|
|
|
return False
|
2022-03-19 14:27:06 +00:00
|
|
|
|
2022-09-08 05:18:38 +00:00
|
|
|
msg = (f"Position adjust: about to create a new order for {pair} with stake: "
|
|
|
|
f"{stake_amount} for {trade}" if pos_adjust
|
|
|
|
else
|
|
|
|
f"{name} signal found: about create a new trade for {pair} with stake_amount: "
|
|
|
|
f"{stake_amount} ...")
|
|
|
|
logger.info(msg)
|
2021-09-10 17:34:57 +00:00
|
|
|
amount = (stake_amount / enter_limit_requested) * leverage
|
2022-03-07 19:32:16 +00:00
|
|
|
order_type = ordertype or self.strategy.order_types['entry']
|
2021-03-05 19:22:04 +00:00
|
|
|
|
2021-12-18 09:01:06 +00:00
|
|
|
if not pos_adjust and not strategy_safe_wrapper(
|
|
|
|
self.strategy.confirm_trade_entry, default_retval=True)(
|
2021-09-08 07:40:22 +00:00
|
|
|
pair=pair, order_type=order_type, amount=amount, rate=enter_limit_requested,
|
2021-09-26 17:32:24 +00:00
|
|
|
time_in_force=time_in_force, current_time=datetime.now(timezone.utc),
|
2022-01-29 13:19:30 +00:00
|
|
|
entry_tag=enter_tag, side=trade_side):
|
2022-07-05 10:58:43 +00:00
|
|
|
logger.info(f"User denied entry for {pair}.")
|
2020-06-14 08:08:19 +00:00
|
|
|
return False
|
2021-09-13 05:39:08 +00:00
|
|
|
order = self.exchange.create_order(
|
|
|
|
pair=pair,
|
|
|
|
ordertype=order_type,
|
|
|
|
side=side,
|
|
|
|
amount=amount,
|
|
|
|
rate=enter_limit_requested,
|
2022-02-02 04:23:05 +00:00
|
|
|
reduceOnly=False,
|
2021-09-13 05:39:08 +00:00
|
|
|
time_in_force=time_in_force,
|
|
|
|
leverage=leverage
|
|
|
|
)
|
2021-09-10 17:34:57 +00:00
|
|
|
order_obj = Order.parse_from_ccxt_object(order, pair, side)
|
2018-11-27 18:05:59 +00:00
|
|
|
order_id = order['id']
|
2022-05-17 22:11:10 +00:00
|
|
|
order_status = order.get('status')
|
2021-12-16 20:57:56 +00:00
|
|
|
logger.info(f"Order #{order_id} was created for {pair} and status is {order_status}.")
|
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
|
2021-09-08 07:40:22 +00:00
|
|
|
enter_limit_filled_price = enter_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-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:
|
2022-03-07 06:09:01 +00:00
|
|
|
logger.warning(f'{name} {time_in_force} order with time in force {order_type} '
|
|
|
|
f'for {pair} is {order_status} by {self.exchange.name}.'
|
|
|
|
' zero amount is fulfilled.')
|
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
|
2021-09-10 17:34:57 +00:00
|
|
|
logger.warning('%s %s order with time in force %s for %s is %s by %s.'
|
2018-12-09 14:59:05 +00:00
|
|
|
' %s amount fulfilled out of %s (%s remaining which is canceled).',
|
2022-03-07 06:09:01 +00:00
|
|
|
name, time_in_force, order_type, pair, order_status,
|
|
|
|
self.exchange.name, order['filled'], order['amount'],
|
|
|
|
order['remaining']
|
2018-12-09 14:59:05 +00:00
|
|
|
)
|
2020-08-12 13:32:56 +00:00
|
|
|
amount = safe_value_fallback(order, 'filled', 'amount')
|
2021-09-08 07:40:22 +00:00
|
|
|
enter_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':
|
2020-07-15 19:02:31 +00:00
|
|
|
amount = safe_value_fallback(order, 'filled', 'amount')
|
2021-09-08 07:40:22 +00:00
|
|
|
enter_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')
|
2022-04-09 14:42:18 +00:00
|
|
|
base_currency = self.exchange.get_pair_base_currency(pair)
|
2021-09-30 04:32:02 +00:00
|
|
|
open_date = datetime.now(timezone.utc)
|
2022-09-02 18:55:13 +00:00
|
|
|
|
2021-12-26 18:03:10 +00:00
|
|
|
# This is a new trade
|
2021-12-18 09:15:59 +00:00
|
|
|
if trade is None:
|
2022-09-08 07:19:17 +00:00
|
|
|
funding_fees = 0.0
|
2022-09-08 05:18:38 +00:00
|
|
|
try:
|
|
|
|
funding_fees = self.exchange.get_funding_fees(
|
|
|
|
pair=pair, amount=amount, is_short=is_short, open_date=open_date)
|
|
|
|
except ExchangeError:
|
2022-09-08 07:19:17 +00:00
|
|
|
logger.warning("Could not find funding fee.")
|
2022-09-08 05:18:38 +00:00
|
|
|
|
2021-12-13 00:27:09 +00:00
|
|
|
trade = Trade(
|
|
|
|
pair=pair,
|
2022-04-09 14:42:18 +00:00
|
|
|
base_currency=base_currency,
|
|
|
|
stake_currency=self.config['stake_currency'],
|
2021-12-13 00:27:09 +00:00
|
|
|
stake_amount=stake_amount,
|
|
|
|
amount=amount,
|
|
|
|
is_open=True,
|
|
|
|
amount_requested=amount_requested,
|
|
|
|
fee_open=fee,
|
|
|
|
fee_close=fee,
|
|
|
|
open_rate=enter_limit_filled_price,
|
|
|
|
open_rate_requested=enter_limit_requested,
|
2022-01-22 16:25:21 +00:00
|
|
|
open_date=open_date,
|
2021-12-13 00:27:09 +00:00
|
|
|
exchange=self.exchange.id,
|
|
|
|
open_order_id=order_id,
|
|
|
|
strategy=self.strategy.get_strategy_name(),
|
2022-01-22 16:25:21 +00:00
|
|
|
enter_tag=enter_tag,
|
|
|
|
timeframe=timeframe_to_minutes(self.config['timeframe']),
|
|
|
|
leverage=leverage,
|
|
|
|
is_short=is_short,
|
|
|
|
trading_mode=self.trading_mode,
|
2022-08-15 17:58:40 +00:00
|
|
|
funding_fees=funding_fees,
|
|
|
|
amount_precision=self.exchange.get_precision_amount(pair),
|
|
|
|
price_precision=self.exchange.get_precision_price(pair),
|
|
|
|
precision_mode=self.exchange.precisionMode,
|
2022-08-22 18:48:02 +00:00
|
|
|
contract_size=self.exchange.get_contract_size(pair),
|
2021-12-13 00:27:09 +00:00
|
|
|
)
|
2021-12-26 18:03:10 +00:00
|
|
|
else:
|
|
|
|
# This is additional buy, we reset fee_open_currency so timeout checking can work
|
|
|
|
trade.is_open = True
|
|
|
|
trade.fee_open_currency = None
|
2022-01-08 15:41:59 +00:00
|
|
|
trade.open_rate_requested = enter_limit_requested
|
2021-12-26 18:03:10 +00:00
|
|
|
trade.open_order_id = order_id
|
2021-09-08 19:56:58 +00:00
|
|
|
|
2020-08-13 07:34:53 +00:00
|
|
|
trade.orders.append(order_obj)
|
2021-12-13 00:27:09 +00:00
|
|
|
trade.recalc_trade_from_orders()
|
2021-04-05 05:28:51 +00:00
|
|
|
Trade.query.session.add(trade)
|
2021-04-15 05:57:52 +00:00
|
|
|
Trade.commit()
|
2018-11-17 20:22:54 +00:00
|
|
|
|
|
|
|
# Updating wallets
|
|
|
|
self.wallets.update()
|
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
self._notify_enter(trade, order_obj, order_type, sub_trade=pos_adjust)
|
2020-02-14 03:23:03 +00:00
|
|
|
|
2021-12-18 09:01:06 +00:00
|
|
|
if pos_adjust:
|
|
|
|
if order_status == 'closed':
|
|
|
|
logger.info(f"DCA order closed, trade should be up to date: {trade}")
|
|
|
|
trade = self.cancel_stoploss_on_exchange(trade)
|
|
|
|
else:
|
|
|
|
logger.info(f"DCA order {order_status}, will wait for resolution: {trade}")
|
2020-02-14 03:23:03 +00:00
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
# Update fees if order is non-opened
|
|
|
|
if order_status in constants.NON_OPEN_EXCHANGE_STATES:
|
2021-11-30 19:19:59 +00:00
|
|
|
self.update_trade_state(trade, order_id, order)
|
|
|
|
|
2018-02-04 09:21:16 +00:00
|
|
|
return True
|
|
|
|
|
2021-12-18 09:01:06 +00:00
|
|
|
def cancel_stoploss_on_exchange(self, trade: Trade) -> Trade:
|
|
|
|
# First cancelling stoploss on exchange ...
|
|
|
|
if self.strategy.order_types.get('stoploss_on_exchange') and trade.stoploss_order_id:
|
|
|
|
try:
|
|
|
|
logger.info(f"Canceling stoploss on exchange for {trade}")
|
|
|
|
co = self.exchange.cancel_stoploss_order_with_result(
|
|
|
|
trade.stoploss_order_id, trade.pair, trade.amount)
|
|
|
|
trade.update_order(co)
|
|
|
|
except InvalidOrderException:
|
|
|
|
logger.exception(f"Could not cancel stoploss order {trade.stoploss_order_id}")
|
|
|
|
return trade
|
|
|
|
|
2021-12-26 14:29:10 +00:00
|
|
|
def get_valid_enter_price_and_stake(
|
2022-02-03 07:22:23 +00:00
|
|
|
self, pair: str, price: Optional[float], stake_amount: float,
|
2022-04-04 14:51:57 +00:00
|
|
|
trade_side: LongShort,
|
2022-02-03 07:22:23 +00:00
|
|
|
entry_tag: Optional[str],
|
2022-05-14 14:16:32 +00:00
|
|
|
trade: Optional[Trade],
|
|
|
|
order_adjust: bool,
|
2022-08-02 18:15:47 +00:00
|
|
|
leverage_: Optional[float],
|
2022-03-19 14:27:06 +00:00
|
|
|
) -> Tuple[float, float, float]:
|
2022-02-03 07:22:23 +00:00
|
|
|
|
2021-12-18 09:01:06 +00:00
|
|
|
if price:
|
|
|
|
enter_limit_requested = price
|
|
|
|
else:
|
|
|
|
# Calculate price
|
2022-05-14 14:16:32 +00:00
|
|
|
enter_limit_requested = self.exchange.get_rate(
|
2022-03-28 05:03:10 +00:00
|
|
|
pair, side='entry', is_short=(trade_side == 'short'), refresh=True)
|
2022-05-14 14:16:32 +00:00
|
|
|
if not order_adjust:
|
|
|
|
# Don't call custom_entry_price in order-adjust scenario
|
2021-12-18 09:01:06 +00:00
|
|
|
custom_entry_price = strategy_safe_wrapper(self.strategy.custom_entry_price,
|
2022-05-14 14:16:32 +00:00
|
|
|
default_retval=enter_limit_requested)(
|
2021-12-18 09:01:06 +00:00
|
|
|
pair=pair, current_time=datetime.now(timezone.utc),
|
2022-05-14 14:16:32 +00:00
|
|
|
proposed_rate=enter_limit_requested, entry_tag=entry_tag,
|
2022-04-04 14:48:27 +00:00
|
|
|
side=trade_side,
|
|
|
|
)
|
2021-12-18 09:01:06 +00:00
|
|
|
|
2022-05-14 14:16:32 +00:00
|
|
|
enter_limit_requested = self.get_valid_price(custom_entry_price, enter_limit_requested)
|
2022-01-22 16:25:21 +00:00
|
|
|
|
2021-12-18 09:01:06 +00:00
|
|
|
if not enter_limit_requested:
|
2022-03-28 05:03:10 +00:00
|
|
|
raise PricingError('Could not determine entry price.')
|
2022-01-22 16:25:21 +00:00
|
|
|
|
2022-08-02 18:15:47 +00:00
|
|
|
if self.trading_mode != TradingMode.SPOT and trade is None:
|
2022-03-19 14:27:06 +00:00
|
|
|
max_leverage = self.exchange.get_max_leverage(pair, stake_amount)
|
2022-08-02 18:15:47 +00:00
|
|
|
if leverage_:
|
|
|
|
leverage = leverage_
|
|
|
|
else:
|
|
|
|
leverage = strategy_safe_wrapper(self.strategy.leverage, default_retval=1.0)(
|
|
|
|
pair=pair,
|
|
|
|
current_time=datetime.now(timezone.utc),
|
|
|
|
current_rate=enter_limit_requested,
|
|
|
|
proposed_leverage=1.0,
|
|
|
|
max_leverage=max_leverage,
|
|
|
|
side=trade_side, entry_tag=entry_tag,
|
|
|
|
)
|
2022-03-19 14:27:06 +00:00
|
|
|
# Cap leverage between 1.0 and max_leverage.
|
|
|
|
leverage = min(max(leverage, 1.0), max_leverage)
|
|
|
|
else:
|
|
|
|
# Changing leverage currently not possible
|
|
|
|
leverage = trade.leverage if trade else 1.0
|
|
|
|
|
2022-01-22 16:25:21 +00:00
|
|
|
# Min-stake-amount should actually include Leverage - this way our "minimal"
|
|
|
|
# stake- amount might be higher than necessary.
|
|
|
|
# We do however also need min-stake to determine leverage, therefore this is ignored as
|
|
|
|
# edge-case for now.
|
|
|
|
min_stake_amount = self.exchange.get_min_pair_stake_amount(
|
2022-03-19 14:27:06 +00:00
|
|
|
pair, enter_limit_requested, self.strategy.stoploss, leverage)
|
|
|
|
max_stake_amount = self.exchange.get_max_pair_stake_amount(
|
|
|
|
pair, enter_limit_requested, leverage)
|
2022-01-22 16:25:21 +00:00
|
|
|
|
2021-12-18 09:01:06 +00:00
|
|
|
if not self.edge and trade is None:
|
2022-02-02 02:39:22 +00:00
|
|
|
stake_available = self.wallets.get_available_stake_amount()
|
2021-12-18 09:01:06 +00:00
|
|
|
stake_amount = strategy_safe_wrapper(self.strategy.custom_stake_amount,
|
|
|
|
default_retval=stake_amount)(
|
|
|
|
pair=pair, current_time=datetime.now(timezone.utc),
|
|
|
|
current_rate=enter_limit_requested, proposed_stake=stake_amount,
|
2022-02-02 02:39:22 +00:00
|
|
|
min_stake=min_stake_amount, max_stake=min(max_stake_amount, stake_available),
|
2022-07-08 17:44:20 +00:00
|
|
|
leverage=leverage, entry_tag=entry_tag, side=trade_side
|
2022-01-22 16:25:21 +00:00
|
|
|
)
|
|
|
|
|
2022-02-04 01:48:54 +00:00
|
|
|
stake_amount = self.wallets.validate_stake_amount(
|
|
|
|
pair=pair,
|
|
|
|
stake_amount=stake_amount,
|
|
|
|
min_stake_amount=min_stake_amount,
|
|
|
|
max_stake_amount=max_stake_amount,
|
|
|
|
)
|
2022-01-22 16:25:21 +00:00
|
|
|
|
2022-03-19 14:27:06 +00:00
|
|
|
return enter_limit_requested, stake_amount, leverage
|
2021-12-18 09:01:06 +00:00
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
def _notify_enter(self, trade: Trade, order: Order, order_type: Optional[str] = None,
|
|
|
|
fill: bool = False, sub_trade: bool = False) -> None:
|
2020-01-02 10:51:25 +00:00
|
|
|
"""
|
2021-09-09 08:10:12 +00:00
|
|
|
Sends rpc notification when a entry order occurred.
|
2020-01-02 10:51:25 +00:00
|
|
|
"""
|
2022-04-04 17:29:15 +00:00
|
|
|
msg_type = RPCMessageType.ENTRY_FILL if fill else RPCMessageType.ENTRY
|
2022-07-31 12:19:04 +00:00
|
|
|
open_rate = order.safe_price
|
|
|
|
|
2021-12-13 09:17:24 +00:00
|
|
|
if open_rate is None:
|
|
|
|
open_rate = trade.open_rate
|
|
|
|
|
2022-01-10 18:30:32 +00:00
|
|
|
current_rate = trade.open_rate_requested
|
|
|
|
if self.dataprovider.runmode in (RunMode.DRY_RUN, RunMode.LIVE):
|
2022-03-28 05:03:10 +00:00
|
|
|
current_rate = self.exchange.get_rate(
|
|
|
|
trade.pair, side='entry', is_short=trade.is_short, refresh=False)
|
2021-12-02 05:53:15 +00:00
|
|
|
|
2020-01-02 10:51:25 +00:00
|
|
|
msg = {
|
2020-07-20 17:50:29 +00:00
|
|
|
'trade_id': trade.id,
|
2021-12-02 05:53:15 +00:00
|
|
|
'type': msg_type,
|
2021-11-21 08:51:16 +00:00
|
|
|
'buy_tag': trade.enter_tag,
|
|
|
|
'enter_tag': trade.enter_tag,
|
2022-05-08 07:16:58 +00:00
|
|
|
'exchange': trade.exchange.capitalize(),
|
2020-01-02 10:51:25 +00:00
|
|
|
'pair': trade.pair,
|
2021-12-29 13:24:12 +00:00
|
|
|
'leverage': trade.leverage if trade.leverage else None,
|
|
|
|
'direction': 'Short' if trade.is_short else 'Long',
|
2021-12-13 11:54:01 +00:00
|
|
|
'limit': open_rate, # Deprecated (?)
|
2021-12-13 09:17:24 +00:00
|
|
|
'open_rate': open_rate,
|
2020-01-02 10:51:25 +00:00
|
|
|
'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),
|
2022-09-07 16:19:25 +00:00
|
|
|
'amount': order.safe_amount_after_fee if fill else order.amount,
|
2020-02-08 20:02:52 +00:00
|
|
|
'open_date': trade.open_date or datetime.utcnow(),
|
2022-01-08 19:30:42 +00:00
|
|
|
'current_rate': current_rate,
|
2022-07-31 12:19:04 +00:00
|
|
|
'sub_trade': sub_trade,
|
2020-02-08 20:02:52 +00:00
|
|
|
}
|
|
|
|
|
2022-07-11 11:55:32 +00:00
|
|
|
# Send the message
|
|
|
|
self.rpc.send_msg(msg)
|
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
def _notify_enter_cancel(self, trade: Trade, order_type: str, reason: str,
|
|
|
|
sub_trade: bool = False) -> None:
|
2020-02-08 20:02:52 +00:00
|
|
|
"""
|
2021-09-09 08:10:12 +00:00
|
|
|
Sends rpc notification when a entry order cancel occurred.
|
2020-02-08 20:02:52 +00:00
|
|
|
"""
|
2022-03-28 05:03:10 +00:00
|
|
|
current_rate = self.exchange.get_rate(
|
|
|
|
trade.pair, side='entry', is_short=trade.is_short, refresh=False)
|
2022-04-04 17:29:15 +00:00
|
|
|
|
2020-02-08 20:02:52 +00:00
|
|
|
msg = {
|
2020-07-20 17:50:29 +00:00
|
|
|
'trade_id': trade.id,
|
2022-04-04 17:29:15 +00:00
|
|
|
'type': RPCMessageType.ENTRY_CANCEL,
|
2021-11-21 08:51:16 +00:00
|
|
|
'buy_tag': trade.enter_tag,
|
|
|
|
'enter_tag': trade.enter_tag,
|
2022-05-08 07:16:58 +00:00
|
|
|
'exchange': trade.exchange.capitalize(),
|
2020-02-08 20:02:52 +00:00
|
|
|
'pair': trade.pair,
|
2021-12-29 13:24:12 +00:00
|
|
|
'leverage': trade.leverage,
|
|
|
|
'direction': 'Short' if trade.is_short else 'Long',
|
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,
|
2022-07-31 12:19:04 +00:00
|
|
|
'sub_trade': sub_trade,
|
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
|
|
|
"""
|
2021-09-09 08:10:12 +00:00
|
|
|
Tries to execute exit 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
|
2021-04-15 05:57:52 +00:00
|
|
|
Trade.commit()
|
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:
|
2022-01-01 18:16:24 +00:00
|
|
|
logger.warning(f'Unable to exit trade {trade.pair}: {exception}')
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2021-05-16 11:16:17 +00:00
|
|
|
# Updating wallets if any trade occurred
|
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
|
|
|
|
|
2018-03-15 22:48:22 +00:00
|
|
|
def handle_trade(self, trade: Trade) -> bool:
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
2021-09-08 07:12:08 +00:00
|
|
|
Sells/exits_short the current pair if the threshold is reached and updates the trade record.
|
|
|
|
:return: True if trade has been sold/exited_short, False otherwise
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
|
|
|
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
|
|
|
|
2021-08-24 18:40:35 +00:00
|
|
|
(enter, exit_) = (False, False)
|
2021-10-18 20:56:41 +00:00
|
|
|
exit_tag = None
|
2021-09-10 17:34:57 +00:00
|
|
|
exit_signal_type = "exit_short" if trade.is_short else "exit_long"
|
|
|
|
|
2022-04-05 18:07:58 +00:00
|
|
|
if (self.config.get('use_exit_signal', True) or
|
2022-04-05 18:20:51 +00:00
|
|
|
self.config.get('ignore_roi_if_entry_signal', False)):
|
2021-05-02 09:17:59 +00:00
|
|
|
analyzed_df, _ = self.dataprovider.get_analyzed_dataframe(trade.pair,
|
|
|
|
self.strategy.timeframe)
|
2020-06-18 06:01:09 +00:00
|
|
|
|
2021-11-06 14:24:52 +00:00
|
|
|
(enter, exit_, exit_tag) = self.strategy.get_exit_signal(
|
2021-07-20 16:56:03 +00:00
|
|
|
trade.pair,
|
|
|
|
self.strategy.timeframe,
|
2021-09-10 17:34:57 +00:00
|
|
|
analyzed_df,
|
|
|
|
is_short=trade.is_short
|
2021-07-20 16:56:03 +00:00
|
|
|
)
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2021-09-10 17:34:57 +00:00
|
|
|
logger.debug('checking exit')
|
2022-03-28 05:03:10 +00:00
|
|
|
exit_rate = self.exchange.get_rate(
|
|
|
|
trade.pair, side='exit', is_short=trade.is_short, refresh=True)
|
2021-11-06 14:24:52 +00:00
|
|
|
if self._check_and_execute_exit(trade, exit_rate, enter, exit_, exit_tag):
|
2021-06-25 18:36:39 +00:00
|
|
|
return True
|
2018-08-05 04:41:06 +00:00
|
|
|
|
2021-09-10 17:34:57 +00:00
|
|
|
logger.debug(f'Found no {exit_signal_type} signal for %s.', trade)
|
2018-08-05 04:41:06 +00:00
|
|
|
return False
|
|
|
|
|
2022-07-03 11:35:26 +00:00
|
|
|
def _check_and_execute_exit(self, trade: Trade, exit_rate: float,
|
|
|
|
enter: bool, exit_: bool, exit_tag: Optional[str]) -> bool:
|
|
|
|
"""
|
|
|
|
Check and execute trade exit
|
|
|
|
"""
|
|
|
|
exits: List[ExitCheckTuple] = self.strategy.should_exit(
|
|
|
|
trade,
|
|
|
|
exit_rate,
|
|
|
|
datetime.now(timezone.utc),
|
|
|
|
enter=enter,
|
|
|
|
exit_=exit_,
|
|
|
|
force_stoploss=self.edge.stoploss(trade.pair) if self.edge else 0
|
|
|
|
)
|
|
|
|
for should_exit in exits:
|
|
|
|
if should_exit.exit_flag:
|
|
|
|
exit_tag1 = exit_tag if should_exit.exit_type == ExitType.EXIT_SIGNAL else None
|
|
|
|
logger.info(f'Exit for {trade.pair} detected. Reason: {should_exit.exit_type}'
|
|
|
|
f'{f" Tag: {exit_tag1}" if exit_tag1 is not None else ""}')
|
|
|
|
exited = self.execute_trade_exit(trade, exit_rate, should_exit, exit_tag=exit_tag1)
|
|
|
|
if exited:
|
|
|
|
return True
|
|
|
|
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:
|
2021-07-26 06:01:57 +00:00
|
|
|
stoploss_order = self.exchange.stoploss(
|
|
|
|
pair=trade.pair,
|
|
|
|
amount=trade.amount,
|
|
|
|
stop_price=stop_price,
|
|
|
|
order_types=self.strategy.order_types,
|
2021-09-19 23:44:12 +00:00
|
|
|
side=trade.exit_side,
|
|
|
|
leverage=trade.leverage
|
2021-07-26 06:01:57 +00:00
|
|
|
)
|
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'])
|
2022-09-17 15:07:47 +00:00
|
|
|
trade.stoploss_last_update = datetime.now(timezone.utc)
|
2019-08-31 14:11:04 +00:00
|
|
|
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}')
|
2021-09-08 07:40:22 +00:00
|
|
|
logger.warning('Exiting the trade forcefully')
|
2022-07-30 07:18:15 +00:00
|
|
|
self.execute_trade_exit(trade, stop_price, exit_check=ExitCheckTuple(
|
2022-04-04 15:03:27 +00:00
|
|
|
exit_type=ExitType.EMERGENCY_EXIT))
|
2019-09-01 07:08:35 +00:00
|
|
|
|
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.
|
2022-03-25 14:17:46 +00:00
|
|
|
# TODO: liquidation price always on exchange, even without stoploss_on_exchange
|
|
|
|
# Therefore fetching account liquidations for open pairs may make sense.
|
2018-11-24 16:10:51 +00:00
|
|
|
"""
|
|
|
|
|
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'):
|
2022-03-24 19:33:47 +00:00
|
|
|
trade.exit_reason = ExitType.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-26 06:37:07 +00:00
|
|
|
self.strategy.lock_pair(trade.pair, datetime.now(timezone.utc),
|
2020-10-20 17:39:38 +00:00
|
|
|
reason='Auto lock')
|
2022-05-22 17:16:31 +00:00
|
|
|
self._notify_exit(trade, "stoploss", True)
|
2020-01-23 18:40:31 +00:00
|
|
|
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
|
|
|
|
|
2021-09-08 07:12:08 +00:00
|
|
|
# If enter 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:
|
2022-02-18 11:43:16 +00:00
|
|
|
stoploss = (
|
|
|
|
self.edge.stoploss(pair=trade.pair)
|
|
|
|
if self.edge else
|
|
|
|
self.strategy.stoploss / trade.leverage
|
|
|
|
)
|
2021-09-10 17:34:57 +00:00
|
|
|
if trade.is_short:
|
|
|
|
stop_price = trade.open_rate * (1 - stoploss)
|
|
|
|
else:
|
|
|
|
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):
|
2022-03-11 07:27:42 +00:00
|
|
|
# The above will return False if the placement failed and the trade was force-sold.
|
|
|
|
# in which case the trade will be closed - which we must check below.
|
2019-04-04 15:13:54 +00:00
|
|
|
return False
|
2019-03-31 13:41:10 +00:00
|
|
|
|
2022-09-17 15:07:47 +00:00
|
|
|
# If stoploss order is canceled for some reason we add it again
|
2022-03-11 07:27:42 +00:00
|
|
|
if (trade.is_open
|
|
|
|
and stoploss_order
|
|
|
|
and stoploss_order['status'] in ('canceled', 'cancelled')):
|
2022-07-30 07:19:48 +00:00
|
|
|
if self.create_stoploss_order(trade=trade, stop_price=trade.stoploss_or_liquidation):
|
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.
|
2021-06-13 09:06:34 +00:00
|
|
|
# Triggered Orders are now real orders - so don't replace stoploss anymore
|
|
|
|
if (
|
2022-03-11 07:27:42 +00:00
|
|
|
trade.is_open and stoploss_order
|
2021-06-13 09:06:34 +00:00
|
|
|
and stoploss_order.get('status_stop') != 'triggered'
|
|
|
|
and (self.config.get('trailing_stop', False)
|
|
|
|
or self.config.get('use_custom_stoploss', False))
|
|
|
|
):
|
2019-04-04 15:13:54 +00:00
|
|
|
# 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
|
2021-10-02 09:58:02 +00:00
|
|
|
self.handle_trailing_stoploss_on_exchange(trade, stoploss_order)
|
2019-04-04 15:13:54 +00:00
|
|
|
|
|
|
|
return False
|
2018-11-23 19:47:17 +00:00
|
|
|
|
2022-02-03 05:55:58 +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
|
2021-06-25 17:13:31 +00:00
|
|
|
:param trade: Corresponding Trade
|
2019-01-16 14:00:35 +00:00
|
|
|
:param order: Current on exchange stoploss order
|
|
|
|
:return: None
|
|
|
|
"""
|
2022-07-30 07:18:15 +00:00
|
|
|
stoploss_norm = self.exchange.price_to_precision(trade.pair, trade.stoploss_or_liquidation)
|
2022-03-08 18:35:30 +00:00
|
|
|
|
2022-03-10 05:54:20 +00:00
|
|
|
if self.exchange.stoploss_adjust(stoploss_norm, order, side=trade.exit_side):
|
2021-05-16 11:16:17 +00:00
|
|
|
# we check if the update is necessary
|
2019-01-18 11:02:29 +00:00
|
|
|
update_beat = self.strategy.order_types.get('stoploss_on_exchange_interval', 60)
|
2022-09-17 15:07:47 +00:00
|
|
|
upd_req = datetime.now(timezone.utc) - timedelta(seconds=update_beat)
|
|
|
|
if trade.stoploss_last_update_utc and upd_req >= trade.stoploss_last_update_utc:
|
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:
|
2021-05-16 12:15:24 +00:00
|
|
|
co = self.exchange.cancel_stoploss_order_with_result(order['id'], trade.pair,
|
|
|
|
trade.amount)
|
2020-08-14 09:25:20 +00:00
|
|
|
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
|
2022-07-30 07:18:15 +00:00
|
|
|
if not self.create_stoploss_order(trade=trade, stop_price=stoploss_norm):
|
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
|
|
|
|
2022-04-16 12:03:09 +00:00
|
|
|
def manage_open_orders(self) -> None:
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
2022-04-16 12:03:09 +00:00
|
|
|
Management of open orders on exchange. Unfilled orders might be cancelled if timeout
|
|
|
|
was met or replaced if there's a new candle and user has requested it.
|
|
|
|
Timeout setting takes priority over limit order adjustment request.
|
2018-02-04 09:21:16 +00:00
|
|
|
: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)
|
2021-10-18 06:45:48 +00:00
|
|
|
not_closed = order['status'] == 'open' or fully_cancelled
|
2022-01-30 16:47:37 +00:00
|
|
|
order_obj = trade.select_order_by_order_id(trade.open_order_id)
|
|
|
|
|
2022-04-16 12:03:09 +00:00
|
|
|
if not_closed:
|
|
|
|
if fully_cancelled or (order_obj and self.strategy.ft_check_timed_out(
|
|
|
|
trade, order_obj, datetime.now(timezone.utc))):
|
2022-04-18 18:16:45 +00:00
|
|
|
self.handle_timedout_order(order, trade)
|
2021-10-18 06:45:48 +00:00
|
|
|
else:
|
2022-04-18 18:16:45 +00:00
|
|
|
self.replace_order(order, order_obj, trade)
|
2022-04-16 12:03:09 +00:00
|
|
|
|
2022-04-18 18:16:45 +00:00
|
|
|
def handle_timedout_order(self, order: Dict, trade: Trade) -> None:
|
2022-04-16 12:03:09 +00:00
|
|
|
"""
|
2022-04-18 18:16:45 +00:00
|
|
|
Check if current analyzed order timed out and cancel if necessary.
|
2022-04-16 12:03:09 +00:00
|
|
|
:param order: Order dict grabbed with exchange.fetch_order()
|
|
|
|
:param trade: Trade object.
|
|
|
|
:return: None
|
|
|
|
"""
|
|
|
|
if order['side'] == trade.entry_side:
|
|
|
|
self.handle_cancel_enter(trade, order, constants.CANCEL_REASON['TIMEOUT'])
|
|
|
|
else:
|
|
|
|
canceled = self.handle_cancel_exit(
|
|
|
|
trade, order, constants.CANCEL_REASON['TIMEOUT'])
|
|
|
|
canceled_count = trade.get_exit_order_count()
|
|
|
|
max_timeouts = self.config.get('unfilledtimeout', {}).get('exit_timeout_count', 0)
|
|
|
|
if canceled and max_timeouts > 0 and canceled_count >= max_timeouts:
|
|
|
|
logger.warning(f'Emergency exiting trade {trade}, as the exit order '
|
|
|
|
f'timed out {max_timeouts} times.')
|
|
|
|
try:
|
|
|
|
self.execute_trade_exit(
|
|
|
|
trade, order['price'],
|
|
|
|
exit_check=ExitCheckTuple(exit_type=ExitType.EMERGENCY_EXIT))
|
|
|
|
except DependencyException as exception:
|
|
|
|
logger.warning(
|
|
|
|
f'Unable to emergency sell trade {trade.pair}: {exception}')
|
|
|
|
|
2022-04-18 18:16:45 +00:00
|
|
|
def replace_order(self, order: Dict, order_obj: Optional[Order], trade: Trade) -> None:
|
2022-04-16 12:03:09 +00:00
|
|
|
"""
|
2022-04-28 21:10:17 +00:00
|
|
|
Check if current analyzed entry order should be replaced or simply cancelled.
|
|
|
|
To simply cancel the existing order(no replacement) adjust_entry_price() should return None
|
|
|
|
To maintain existing order adjust_entry_price() should return order_obj.price
|
|
|
|
To replace existing order adjust_entry_price() should return desired price for limit order
|
2022-04-16 12:03:09 +00:00
|
|
|
:param order: Order dict grabbed with exchange.fetch_order()
|
|
|
|
:param order_obj: Order object.
|
|
|
|
:param trade: Trade object.
|
|
|
|
:return: None
|
|
|
|
"""
|
|
|
|
analyzed_df, _ = self.dataprovider.get_analyzed_dataframe(trade.pair,
|
|
|
|
self.strategy.timeframe)
|
|
|
|
latest_candle_open_date = analyzed_df.iloc[-1]['date'] if len(analyzed_df) > 0 else None
|
|
|
|
latest_candle_close_date = timeframe_to_next_date(self.strategy.timeframe,
|
|
|
|
latest_candle_open_date)
|
|
|
|
# Check if new candle
|
2022-04-17 09:11:30 +00:00
|
|
|
if order_obj and latest_candle_close_date > order_obj.order_date_utc:
|
2022-04-16 12:03:09 +00:00
|
|
|
# New candle
|
|
|
|
proposed_rate = self.exchange.get_rate(
|
|
|
|
trade.pair, side='entry', is_short=trade.is_short, refresh=True)
|
2022-04-18 18:16:45 +00:00
|
|
|
adjusted_entry_price = strategy_safe_wrapper(self.strategy.adjust_entry_price,
|
2022-04-28 21:10:17 +00:00
|
|
|
default_retval=order_obj.price)(
|
2022-04-18 18:16:45 +00:00
|
|
|
trade=trade, order=order_obj, pair=trade.pair,
|
|
|
|
current_time=datetime.now(timezone.utc), proposed_rate=proposed_rate,
|
2022-04-28 21:10:17 +00:00
|
|
|
current_order_rate=order_obj.price, entry_tag=trade.enter_tag,
|
|
|
|
side=trade.entry_side)
|
2022-04-18 18:16:45 +00:00
|
|
|
|
2022-05-31 15:49:51 +00:00
|
|
|
replacing = True
|
2022-04-18 18:16:45 +00:00
|
|
|
cancel_reason = constants.CANCEL_REASON['REPLACE']
|
|
|
|
if not adjusted_entry_price:
|
2022-05-31 15:49:51 +00:00
|
|
|
replacing = False
|
2022-04-18 18:16:45 +00:00
|
|
|
cancel_reason = constants.CANCEL_REASON['USER_CANCEL']
|
2022-04-28 21:10:17 +00:00
|
|
|
if order_obj.price != adjusted_entry_price:
|
2022-04-18 18:16:45 +00:00
|
|
|
# cancel existing order if new price is supplied or None
|
|
|
|
self.handle_cancel_enter(trade, order, cancel_reason,
|
2022-05-31 15:49:51 +00:00
|
|
|
replacing=replacing)
|
2022-04-18 18:16:45 +00:00
|
|
|
if adjusted_entry_price:
|
|
|
|
# place new order only if new price is supplied
|
|
|
|
self.execute_entry(
|
|
|
|
pair=trade.pair,
|
|
|
|
stake_amount=(order_obj.remaining * order_obj.price),
|
|
|
|
price=adjusted_entry_price,
|
|
|
|
trade=trade,
|
2022-05-14 14:16:32 +00:00
|
|
|
is_short=trade.is_short,
|
|
|
|
order_adjust=True,
|
2022-04-18 18:16:45 +00:00
|
|
|
)
|
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
|
|
|
|
|
2022-04-06 01:02:13 +00:00
|
|
|
if order['side'] == trade.entry_side:
|
2021-09-08 06:53:09 +00:00
|
|
|
self.handle_cancel_enter(trade, order, constants.CANCEL_REASON['ALL_CANCELLED'])
|
2020-04-24 22:16:52 +00:00
|
|
|
|
2021-09-10 17:34:57 +00:00
|
|
|
elif order['side'] == trade.exit_side:
|
2021-09-08 06:53:09 +00:00
|
|
|
self.handle_cancel_exit(trade, order, constants.CANCEL_REASON['ALL_CANCELLED'])
|
2021-04-15 05:57:52 +00:00
|
|
|
Trade.commit()
|
2020-04-24 22:16:52 +00:00
|
|
|
|
2022-04-16 12:03:44 +00:00
|
|
|
def handle_cancel_enter(
|
|
|
|
self, trade: Trade, order: Dict, reason: str,
|
2022-05-31 15:49:51 +00:00
|
|
|
replacing: Optional[bool] = False
|
2022-04-16 12:03:44 +00:00
|
|
|
) -> bool:
|
2020-04-24 22:16:52 +00:00
|
|
|
"""
|
|
|
|
Buy cancel - cancel order
|
2022-05-31 15:49:51 +00:00
|
|
|
:param replacing: Replacing order - prevent trade deletion.
|
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'
|
2021-08-27 17:54:53 +00:00
|
|
|
if order['status'] not in constants.NON_OPEN_EXCHANGE_STATES:
|
2022-02-19 05:38:11 +00:00
|
|
|
filled_val: float = order.get('filled', 0.0) or 0.0
|
2021-05-21 17:19:38 +00:00
|
|
|
filled_stake = filled_val * trade.open_rate
|
|
|
|
minstake = self.exchange.get_min_pair_stake_amount(
|
|
|
|
trade.pair, trade.open_rate, self.strategy.stoploss)
|
|
|
|
|
2022-02-19 05:38:11 +00:00
|
|
|
if filled_val > 0 and minstake and filled_stake < minstake:
|
2021-05-21 17:19:38 +00:00
|
|
|
logger.warning(
|
|
|
|
f"Order {trade.open_order_id} for {trade.pair} not cancelled, "
|
2021-09-10 17:34:57 +00:00
|
|
|
f"as the filled amount of {filled_val} would result in an unexitable trade.")
|
2021-05-21 17:19:38 +00:00
|
|
|
return False
|
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.
|
2021-08-27 17:54:53 +00:00
|
|
|
if corder.get('status') not in constants.NON_OPEN_EXCHANGE_STATES:
|
2020-08-01 13:59:50 +00:00
|
|
|
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
|
|
|
|
2022-04-06 01:02:13 +00:00
|
|
|
side = trade.entry_side.capitalize()
|
2021-09-10 17:34:57 +00:00
|
|
|
logger.info('%s order %s for %s.', side, 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):
|
2021-12-13 18:44:18 +00:00
|
|
|
# if trade is not partially completed and it's the only order, just delete the trade
|
2022-04-19 10:33:37 +00:00
|
|
|
open_order_count = len([order for order in trade.orders if order.status == 'open'])
|
2022-05-31 15:49:51 +00:00
|
|
|
if open_order_count <= 1 and trade.nr_of_successful_entries == 0 and not replacing:
|
2022-05-02 15:09:28 +00:00
|
|
|
logger.info(f'{side} order fully cancelled. Removing {trade} from database.')
|
2021-12-13 18:44:18 +00:00
|
|
|
trade.delete()
|
|
|
|
was_trade_fully_canceled = True
|
|
|
|
reason += f", {constants.CANCEL_REASON['FULLY_CANCELLED']}"
|
|
|
|
else:
|
|
|
|
# FIXME TODO: This could possibly reworked to not duplicate the code 15 lines below.
|
|
|
|
self.update_trade_state(trade, trade.open_order_id, corder)
|
|
|
|
trade.open_order_id = None
|
2022-05-31 15:49:51 +00:00
|
|
|
logger.info(f'{side} Order timeout for {trade}.')
|
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
|
2021-08-16 12:16:24 +00:00
|
|
|
# to the order dict acquired before cancelling.
|
2020-04-24 22:16:52 +00:00
|
|
|
# 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
|
2022-02-02 19:23:05 +00:00
|
|
|
# * Check edge cases, we don't want to make leverage > 1.0 if we don't have to
|
|
|
|
# * (for leverage modes which aren't isolated futures)
|
2021-09-08 07:12:08 +00:00
|
|
|
|
2022-02-16 14:09:43 +00:00
|
|
|
trade.stake_amount = trade.amount * trade.open_rate / trade.leverage
|
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
|
2022-04-06 01:02:13 +00:00
|
|
|
logger.info(f'Partial {trade.entry_side} order timeout for {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()
|
2022-03-07 19:32:16 +00:00
|
|
|
self._notify_enter_cancel(trade, order_type=self.strategy.order_types['entry'],
|
2021-09-08 06:45:55 +00:00
|
|
|
reason=reason)
|
2020-04-24 22:16:52 +00:00
|
|
|
return was_trade_fully_canceled
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2022-02-25 14:07:35 +00:00
|
|
|
def handle_cancel_exit(self, trade: Trade, order: Dict, reason: str) -> bool:
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
2021-09-09 08:10:12 +00:00
|
|
|
exit order cancel - cancel order and update trade
|
2022-02-25 14:07:35 +00:00
|
|
|
:return: True if exit order was cancelled, false otherwise
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
2022-02-25 14:07:35 +00:00
|
|
|
cancelled = False
|
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
|
2021-02-06 08:23:10 +00:00
|
|
|
co = self.exchange.cancel_order_with_result(trade.open_order_id, trade.pair,
|
|
|
|
trade.amount)
|
|
|
|
trade.update_order(co)
|
2020-05-10 15:44:45 +00:00
|
|
|
except InvalidOrderException:
|
2021-09-10 17:34:57 +00:00
|
|
|
logger.exception(
|
|
|
|
f"Could not cancel {trade.exit_side} order {trade.open_order_id}")
|
2022-02-25 14:07:35 +00:00
|
|
|
return False
|
2021-09-10 17:34:57 +00:00
|
|
|
logger.info('%s order %s for %s.', trade.exit_side.capitalize(), 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']
|
2021-09-10 17:34:57 +00:00
|
|
|
logger.info('%s order %s for %s.', trade.exit_side.capitalize(), reason, trade)
|
2021-02-06 08:23:10 +00:00
|
|
|
trade.update_order(order)
|
2020-02-08 20:02:52 +00:00
|
|
|
|
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
|
2022-03-24 19:33:47 +00:00
|
|
|
trade.exit_reason = None
|
2022-02-25 14:07:35 +00:00
|
|
|
cancelled = True
|
2022-07-31 12:19:04 +00:00
|
|
|
self.wallets.update()
|
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']
|
2022-02-25 14:07:35 +00:00
|
|
|
cancelled = False
|
2019-02-03 12:39:05 +00:00
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
order_obj = trade.select_order_by_order_id(order['id'])
|
|
|
|
if not order_obj:
|
|
|
|
raise DependencyException(
|
|
|
|
f"Order_obj not found for {order['id']}. This should not have happened.")
|
|
|
|
|
|
|
|
sub_trade = order_obj.amount != trade.amount
|
2021-09-08 06:45:55 +00:00
|
|
|
self._notify_exit_cancel(
|
2020-04-24 22:16:52 +00:00
|
|
|
trade,
|
2022-03-07 19:32:16 +00:00
|
|
|
order_type=self.strategy.order_types['exit'],
|
2022-07-31 12:19:04 +00:00
|
|
|
reason=reason, order=order_obj, sub_trade=sub_trade
|
2020-04-24 22:16:52 +00:00
|
|
|
)
|
2022-02-25 14:07:35 +00:00
|
|
|
return cancelled
|
2018-02-04 09:21:16 +00:00
|
|
|
|
2021-09-08 07:20:52 +00:00
|
|
|
def _safe_exit_amount(self, pair: str, amount: float) -> float:
|
2019-12-13 05:52:33 +00:00
|
|
|
"""
|
|
|
|
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()
|
2022-02-19 10:06:47 +00:00
|
|
|
if self.trading_mode == TradingMode.FUTURES:
|
|
|
|
return amount
|
|
|
|
|
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}")
|
2022-02-19 10:06:47 +00:00
|
|
|
if wallet_amount >= amount:
|
2022-02-02 21:45:01 +00:00
|
|
|
# A safe exit amount isn't needed for futures, you can just exit/close the position
|
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(
|
2021-09-08 07:48:22 +00:00
|
|
|
f"Not enough amount to exit trade. Trade-amount: {amount}, Wallet: {wallet_amount}")
|
2019-12-13 05:52:33 +00:00
|
|
|
|
2021-09-10 09:25:54 +00:00
|
|
|
def execute_trade_exit(
|
2021-10-18 20:56:41 +00:00
|
|
|
self,
|
|
|
|
trade: Trade,
|
|
|
|
limit: float,
|
2022-03-25 05:46:29 +00:00
|
|
|
exit_check: ExitCheckTuple,
|
2021-11-27 08:10:18 +00:00
|
|
|
*,
|
|
|
|
exit_tag: Optional[str] = None,
|
|
|
|
ordertype: Optional[str] = None,
|
2022-07-31 12:19:04 +00:00
|
|
|
sub_trade_amt: float = None,
|
2022-01-01 16:34:33 +00:00
|
|
|
) -> bool:
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
2021-08-26 04:53:42 +00:00
|
|
|
Executes a trade exit for the given trade and limit
|
2018-02-04 09:21:16 +00:00
|
|
|
:param trade: Trade instance
|
|
|
|
:param limit: limit rate for the sell order
|
2022-03-25 05:38:58 +00:00
|
|
|
:param exit_check: CheckTuple with signal and reason
|
2022-05-22 09:28:11 +00:00
|
|
|
:return: True if it succeeds False
|
2018-02-04 09:21:16 +00:00
|
|
|
"""
|
2022-09-08 05:18:38 +00:00
|
|
|
try:
|
|
|
|
trade.funding_fees = self.exchange.get_funding_fees(
|
|
|
|
pair=trade.pair,
|
|
|
|
amount=trade.amount,
|
|
|
|
is_short=trade.is_short,
|
|
|
|
open_date=trade.date_last_filled_utc,
|
|
|
|
)
|
|
|
|
except ExchangeError:
|
|
|
|
logger.warning("Could not update funding fee.")
|
|
|
|
|
2022-03-09 06:04:59 +00:00
|
|
|
exit_type = 'exit'
|
2022-05-15 15:33:00 +00:00
|
|
|
exit_reason = exit_tag or exit_check.exit_reason
|
2022-07-30 07:18:15 +00:00
|
|
|
if exit_check.exit_type in (
|
|
|
|
ExitType.STOP_LOSS, ExitType.TRAILING_STOP_LOSS, ExitType.LIQUIDATION):
|
2021-09-10 09:25:54 +00:00
|
|
|
exit_type = 'stoploss'
|
2018-11-25 18:48:46 +00:00
|
|
|
|
2021-08-05 03:09:40 +00:00
|
|
|
# set custom_exit_price if available
|
2021-08-12 19:13:14 +00:00
|
|
|
proposed_limit_rate = limit
|
2021-08-05 03:09:40 +00:00
|
|
|
current_profit = trade.calc_profit_ratio(limit)
|
2021-08-12 19:13:14 +00:00
|
|
|
custom_exit_price = strategy_safe_wrapper(self.strategy.custom_exit_price,
|
|
|
|
default_retval=proposed_limit_rate)(
|
2021-08-05 03:09:40 +00:00
|
|
|
pair=trade.pair, trade=trade,
|
|
|
|
current_time=datetime.now(timezone.utc),
|
2022-04-26 06:39:15 +00:00
|
|
|
proposed_rate=proposed_limit_rate, current_profit=current_profit,
|
2022-05-15 15:33:00 +00:00
|
|
|
exit_tag=exit_reason)
|
2021-08-12 19:13:14 +00:00
|
|
|
|
|
|
|
limit = self.get_valid_price(custom_exit_price, proposed_limit_rate)
|
2021-08-05 03:09:40 +00:00
|
|
|
|
2018-11-22 16:02:02 +00:00
|
|
|
# First cancelling stoploss on exchange ...
|
2021-12-18 09:01:06 +00:00
|
|
|
trade = self.cancel_stoploss_on_exchange(trade)
|
2018-11-22 16:02:02 +00:00
|
|
|
|
2021-12-01 06:11:11 +00:00
|
|
|
order_type = ordertype or self.strategy.order_types[exit_type]
|
2022-04-04 15:03:27 +00:00
|
|
|
if exit_check.exit_type == ExitType.EMERGENCY_EXIT:
|
2020-02-08 20:02:52 +00:00
|
|
|
# Emergency sells (default to market!)
|
2022-04-05 10:31:53 +00:00
|
|
|
order_type = self.strategy.order_types.get("emergency_exit", "market")
|
2019-09-01 07:09:07 +00:00
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
amount = self._safe_exit_amount(trade.pair, sub_trade_amt or trade.amount)
|
2022-03-07 06:09:01 +00:00
|
|
|
time_in_force = self.strategy.order_time_in_force['exit']
|
2020-06-14 08:08:19 +00:00
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
if (exit_check.exit_type != ExitType.LIQUIDATION
|
|
|
|
and not sub_trade_amt
|
|
|
|
and 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, exit_reason=exit_reason,
|
|
|
|
sell_reason=exit_reason, # sellreason -> compatibility
|
|
|
|
current_time=datetime.now(timezone.utc))):
|
2022-07-05 10:58:43 +00:00
|
|
|
logger.info(f"User denied exit for {trade.pair}.")
|
2020-06-14 08:08:19 +00:00
|
|
|
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
|
2021-09-08 07:12:08 +00:00
|
|
|
order = self.exchange.create_order(
|
|
|
|
pair=trade.pair,
|
|
|
|
ordertype=order_type,
|
2021-10-09 22:53:42 +00:00
|
|
|
side=trade.exit_side,
|
2021-09-08 07:12:08 +00:00
|
|
|
amount=amount,
|
|
|
|
rate=limit,
|
2022-02-02 19:15:42 +00:00
|
|
|
leverage=trade.leverage,
|
2022-02-02 04:23:05 +00:00
|
|
|
reduceOnly=self.trading_mode == TradingMode.FUTURES,
|
2021-09-08 07:53:42 +00:00
|
|
|
time_in_force=time_in_force
|
2021-09-08 07:12:08 +00:00
|
|
|
)
|
2020-08-14 08:59:55 +00:00
|
|
|
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
|
|
|
|
2021-09-10 09:25:54 +00:00
|
|
|
order_obj = Order.parse_from_ccxt_object(order, trade.pair, trade.exit_side)
|
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']
|
2022-04-03 09:17:01 +00:00
|
|
|
trade.exit_order_status = ''
|
2018-04-25 18:16:36 +00:00
|
|
|
trade.close_rate_requested = limit
|
2022-05-15 15:33:00 +00:00
|
|
|
trade.exit_reason = exit_reason
|
2019-08-12 18:39:34 +00:00
|
|
|
|
2022-08-27 05:23:02 +00:00
|
|
|
if not sub_trade_amt:
|
|
|
|
# Lock pair for one candle to prevent immediate re-trading
|
|
|
|
self.strategy.lock_pair(trade.pair, datetime.now(timezone.utc),
|
|
|
|
reason='Auto lock')
|
2019-08-12 18:39:34 +00:00
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
self._notify_exit(trade, order_type, sub_trade=bool(sub_trade_amt), order=order_obj)
|
2021-11-30 19:19:59 +00:00
|
|
|
# In case of market sell orders the order can be closed immediately
|
|
|
|
if order.get('status', 'unknown') in ('closed', 'expired'):
|
|
|
|
self.update_trade_state(trade, trade.open_order_id, order)
|
|
|
|
Trade.commit()
|
2019-03-12 21:01:19 +00:00
|
|
|
|
2020-02-08 20:02:52 +00:00
|
|
|
return True
|
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
def _notify_exit(self, trade: Trade, order_type: str, fill: bool = False,
|
|
|
|
sub_trade: bool = False, order: Order = None) -> None:
|
2019-03-12 21:01:19 +00:00
|
|
|
"""
|
2021-05-16 11:16:17 +00:00
|
|
|
Sends rpc notification when a sell occurred.
|
2019-03-12 21:01:19 +00:00
|
|
|
"""
|
2020-03-08 10:35:31 +00:00
|
|
|
# Use cached rates here - it was updated seconds ago.
|
2021-07-18 03:58:54 +00:00
|
|
|
current_rate = self.exchange.get_rate(
|
2022-03-28 05:03:10 +00:00
|
|
|
trade.pair, side='exit', is_short=trade.is_short, refresh=False) if not fill else None
|
2022-07-31 12:19:04 +00:00
|
|
|
|
|
|
|
# second condition is for mypy only; order will always be passed during sub trade
|
|
|
|
if sub_trade and order is not None:
|
|
|
|
amount = order.safe_filled if fill else order.amount
|
|
|
|
profit_rate = order.safe_price
|
|
|
|
|
|
|
|
profit = trade.calc_profit(rate=profit_rate, amount=amount, open_rate=trade.open_rate)
|
|
|
|
profit_ratio = trade.calc_profit_ratio(profit_rate, amount, trade.open_rate)
|
|
|
|
else:
|
|
|
|
profit_rate = trade.close_rate if trade.close_rate else trade.close_rate_requested
|
2022-08-04 05:07:54 +00:00
|
|
|
profit = trade.calc_profit(rate=profit_rate) + (0.0 if fill else trade.realized_profit)
|
2022-07-31 12:19:04 +00:00
|
|
|
profit_ratio = trade.calc_profit_ratio(profit_rate)
|
|
|
|
amount = trade.amount
|
2020-02-28 09:36:39 +00:00
|
|
|
gain = "profit" if profit_ratio > 0 else "loss"
|
2019-03-12 21:01:19 +00:00
|
|
|
|
|
|
|
msg = {
|
2022-04-04 17:08:31 +00:00
|
|
|
'type': (RPCMessageType.EXIT_FILL if fill
|
2022-04-04 17:10:44 +00:00
|
|
|
else RPCMessageType.EXIT),
|
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,
|
2021-12-29 13:24:12 +00:00
|
|
|
'leverage': trade.leverage,
|
|
|
|
'direction': 'Short' if trade.is_short else 'Long',
|
2019-03-12 21:01:19 +00:00
|
|
|
'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,
|
2022-07-31 12:19:04 +00:00
|
|
|
'amount': amount,
|
2019-03-12 21:01:19 +00:00
|
|
|
'open_rate': trade.open_rate,
|
2022-07-31 12:19:04 +00:00
|
|
|
'close_rate': profit_rate,
|
2019-03-12 21:01:19 +00:00
|
|
|
'current_rate': current_rate,
|
2022-07-31 12:19:04 +00:00
|
|
|
'profit_amount': profit,
|
2020-02-28 09:36:39 +00:00
|
|
|
'profit_ratio': profit_ratio,
|
2021-11-21 08:51:16 +00:00
|
|
|
'buy_tag': trade.enter_tag,
|
|
|
|
'enter_tag': trade.enter_tag,
|
2022-03-24 19:33:47 +00:00
|
|
|
'sell_reason': trade.exit_reason, # Deprecated
|
|
|
|
'exit_reason': trade.exit_reason,
|
2019-12-08 13:07:46 +00:00
|
|
|
'open_date': trade.open_date,
|
2020-01-02 10:51:25 +00:00
|
|
|
'close_date': trade.close_date or datetime.utcnow(),
|
2022-07-31 12:19:04 +00:00
|
|
|
'stake_amount': trade.stake_amount,
|
2020-01-02 11:38:25 +00:00
|
|
|
'stake_currency': self.config['stake_currency'],
|
2022-05-17 22:11:10 +00:00
|
|
|
'fiat_currency': self.config.get('fiat_display_currency'),
|
2022-07-31 12:19:04 +00:00
|
|
|
'sub_trade': sub_trade,
|
|
|
|
'cumulative_profit': trade.realized_profit,
|
2020-02-08 20:02:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
# Send the message
|
|
|
|
self.rpc.send_msg(msg)
|
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
def _notify_exit_cancel(self, trade: Trade, order_type: str, reason: str,
|
|
|
|
order: Order, sub_trade: bool = False) -> None:
|
2020-02-08 20:02:52 +00:00
|
|
|
"""
|
2021-05-16 11:16:17 +00:00
|
|
|
Sends rpc notification when a sell cancel occurred.
|
2020-02-08 20:02:52 +00:00
|
|
|
"""
|
2022-04-03 09:17:01 +00:00
|
|
|
if trade.exit_order_status == reason:
|
2020-05-17 08:53:07 +00:00
|
|
|
return
|
|
|
|
else:
|
2022-04-03 09:17:01 +00:00
|
|
|
trade.exit_order_status = reason
|
2020-05-17 08:53:07 +00:00
|
|
|
|
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)
|
2022-03-28 05:03:10 +00:00
|
|
|
current_rate = self.exchange.get_rate(
|
|
|
|
trade.pair, side='exit', is_short=trade.is_short, refresh=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 = {
|
2022-04-04 17:07:20 +00:00
|
|
|
'type': RPCMessageType.EXIT_CANCEL,
|
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,
|
2021-12-29 13:24:12 +00:00
|
|
|
'leverage': trade.leverage,
|
|
|
|
'direction': 'Short' if trade.is_short else 'Long',
|
2020-02-08 20:02:52 +00:00
|
|
|
'gain': gain,
|
2021-09-21 21:20:40 +00:00
|
|
|
'limit': profit_rate or 0,
|
2020-02-08 20:02:52 +00:00
|
|
|
'order_type': order_type,
|
2022-07-31 12:19:04 +00:00
|
|
|
'amount': order.safe_amount_after_fee,
|
2020-02-08 20:02:52 +00:00
|
|
|
'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,
|
2021-11-21 08:51:16 +00:00
|
|
|
'buy_tag': trade.enter_tag,
|
|
|
|
'enter_tag': trade.enter_tag,
|
2022-03-24 19:33:47 +00:00
|
|
|
'sell_reason': trade.exit_reason, # Deprecated
|
|
|
|
'exit_reason': trade.exit_reason,
|
2020-02-08 20:02:52 +00:00
|
|
|
'open_date': trade.open_date,
|
2021-09-23 08:28:15 +00:00
|
|
|
'close_date': trade.close_date or datetime.now(timezone.utc),
|
2020-02-08 20:02:52 +00:00
|
|
|
'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,
|
2022-07-31 12:19:04 +00:00
|
|
|
'sub_trade': sub_trade,
|
|
|
|
'stake_amount': trade.stake_amount,
|
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,
|
2021-11-30 19:19:59 +00:00
|
|
|
stoploss_order: bool = False, send_msg: bool = True) -> 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
|
2021-05-16 12:50:25 +00:00
|
|
|
:param action_order: Already acquired order object
|
2021-11-30 19:19:59 +00:00
|
|
|
:param send_msg: Send notification - should always be True except in "recovery" methods
|
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
|
2021-12-27 15:07:43 +00:00
|
|
|
logger.info(f'Found open order for {trade}')
|
2020-05-13 18:25:32 +00:00
|
|
|
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
|
|
|
|
2021-11-05 18:47:13 +00:00
|
|
|
if self.exchange.check_order_canceled_empty(order):
|
|
|
|
# Trade has been cancelled on exchange
|
2021-11-06 10:48:49 +00:00
|
|
|
# Handling of this will happen in check_handle_timedout.
|
2021-11-05 18:47:13 +00:00
|
|
|
return True
|
|
|
|
|
2022-02-11 06:43:45 +00:00
|
|
|
order_obj = trade.select_order_by_order_id(order_id)
|
2022-02-20 15:34:35 +00:00
|
|
|
if not order_obj:
|
|
|
|
raise DependencyException(
|
|
|
|
f"Order_obj not found for {order_id}. This should not have happened.")
|
2022-03-26 13:57:42 +00:00
|
|
|
|
2022-02-20 14:36:25 +00:00
|
|
|
self.handle_order_fee(trade, order_obj, order)
|
2020-05-13 18:25:32 +00:00
|
|
|
|
2022-02-10 18:18:19 +00:00
|
|
|
trade.update_trade(order_obj)
|
2020-01-02 08:50:54 +00:00
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
if order.get('status') in constants.NON_OPEN_EXCHANGE_STATES:
|
2022-02-27 16:15:33 +00:00
|
|
|
# If a entry order was closed, force update on stoploss on exchange
|
2022-05-17 22:11:10 +00:00
|
|
|
if order.get('side') == trade.entry_side:
|
2021-12-26 18:03:10 +00:00
|
|
|
trade = self.cancel_stoploss_on_exchange(trade)
|
2022-07-31 12:19:04 +00:00
|
|
|
if not self.edge:
|
|
|
|
# TODO: should shorting/leverage be supported by Edge,
|
|
|
|
# then this will need to be fixed.
|
|
|
|
trade.adjust_stop_loss(trade.open_rate, self.strategy.stoploss, initial=True)
|
|
|
|
if order.get('side') == trade.entry_side or trade.amount > 0:
|
|
|
|
# Must also run for partial exits
|
2022-02-27 20:14:28 +00:00
|
|
|
# TODO: Margin will need to use interest_rate as well.
|
2022-02-28 19:07:19 +00:00
|
|
|
# interest_rate = self.exchange.get_interest_rate()
|
2022-07-30 07:19:48 +00:00
|
|
|
trade.set_liquidation_price(self.exchange.get_liquidation_price(
|
2022-02-27 20:14:28 +00:00
|
|
|
pair=trade.pair,
|
|
|
|
open_rate=trade.open_rate,
|
2022-08-29 04:45:00 +00:00
|
|
|
is_short=trade.is_short,
|
2022-02-27 20:14:28 +00:00
|
|
|
amount=trade.amount,
|
2022-08-26 18:04:36 +00:00
|
|
|
stake_amount=trade.stake_amount,
|
2022-08-29 04:45:00 +00:00
|
|
|
wallet_balance=trade.stake_amount,
|
2022-02-28 19:07:19 +00:00
|
|
|
))
|
|
|
|
|
2021-12-26 18:03:10 +00:00
|
|
|
# Updating wallets when order is closed
|
2021-12-22 09:20:03 +00:00
|
|
|
self.wallets.update()
|
2022-08-06 15:45:18 +00:00
|
|
|
Trade.commit()
|
2021-12-22 09:43:48 +00:00
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
self.order_close_notify(trade, order_obj, stoploss_order, send_msg)
|
|
|
|
|
|
|
|
return False
|
|
|
|
|
|
|
|
def order_close_notify(
|
|
|
|
self, trade: Trade, order: Order, stoploss_order: bool, send_msg: bool):
|
|
|
|
"""send "fill" notifications"""
|
|
|
|
|
|
|
|
sub_trade = not isclose(order.safe_amount_after_fee,
|
|
|
|
trade.amount, abs_tol=constants.MATH_CLOSE_PREC)
|
|
|
|
if order.ft_order_side == trade.exit_side:
|
|
|
|
# Exit notification
|
2021-11-30 19:19:59 +00:00
|
|
|
if send_msg and not stoploss_order and not trade.open_order_id:
|
2022-07-31 12:19:04 +00:00
|
|
|
self._notify_exit(trade, '', fill=True, sub_trade=sub_trade, order=order)
|
|
|
|
if not trade.is_open:
|
|
|
|
self.handle_protections(trade.pair, trade.trade_direction)
|
2022-05-22 07:01:46 +00:00
|
|
|
elif send_msg and not trade.open_order_id and not stoploss_order:
|
2022-02-27 16:15:33 +00:00
|
|
|
# Enter fill
|
2022-07-31 12:19:04 +00:00
|
|
|
self._notify_enter(trade, order, fill=True, sub_trade=sub_trade)
|
2020-03-24 16:17:40 +00:00
|
|
|
|
2022-04-24 08:58:21 +00:00
|
|
|
def handle_protections(self, pair: str, side: LongShort) -> None:
|
2022-04-23 17:58:20 +00:00
|
|
|
prot_trig = self.protections.stop_per_pair(pair, side=side)
|
2021-09-20 17:12:59 +00:00
|
|
|
if prot_trig:
|
|
|
|
msg = {'type': RPCMessageType.PROTECTION_TRIGGER, }
|
|
|
|
msg.update(prot_trig.to_json())
|
|
|
|
self.rpc.send_msg(msg)
|
|
|
|
|
2022-04-23 17:58:20 +00:00
|
|
|
prot_trig_glb = self.protections.global_stop(side=side)
|
2021-09-20 17:12:59 +00:00
|
|
|
if prot_trig_glb:
|
2021-09-20 17:23:40 +00:00
|
|
|
msg = {'type': RPCMessageType.PROTECTION_TRIGGER_GLOBAL, }
|
2021-09-20 17:12:59 +00:00
|
|
|
msg.update(prot_trig_glb.to_json())
|
|
|
|
self.rpc.send_msg(msg)
|
|
|
|
|
2020-05-03 08:50:59 +00:00
|
|
|
def apply_fee_conditional(self, trade: Trade, trade_base_currency: str,
|
2022-09-01 04:35:24 +00:00
|
|
|
amount: float, fee_abs: float, order_obj: Order) -> Optional[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.
|
2022-01-06 08:55:11 +00:00
|
|
|
Can't happen in Futures mode - where Fees are always in settlement currency,
|
|
|
|
never in base currency.
|
2020-05-03 08:50:59 +00:00
|
|
|
"""
|
2020-05-03 09:13:59 +00:00
|
|
|
self.wallets.update()
|
2022-09-01 04:35:24 +00:00
|
|
|
amount_ = amount
|
|
|
|
if order_obj.ft_order_side == trade.exit_side or order_obj.ft_order_side == 'stoploss':
|
|
|
|
# check against remaining amount!
|
|
|
|
amount_ = trade.amount - amount
|
|
|
|
|
|
|
|
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:
|
2022-08-30 18:46:06 +00:00
|
|
|
logger.info(f"Applying fee on amount for {trade}, fee={fee_abs}.")
|
|
|
|
return fee_abs
|
|
|
|
return None
|
2020-05-03 08:50:59 +00:00
|
|
|
|
2022-02-20 14:36:25 +00:00
|
|
|
def handle_order_fee(self, trade: Trade, order_obj: Order, order: Dict[str, Any]) -> None:
|
2021-12-27 15:07:43 +00:00
|
|
|
# Try update amount (binance-fix)
|
|
|
|
try:
|
2022-08-30 18:46:06 +00:00
|
|
|
fee_abs = self.get_real_amount(trade, order, order_obj)
|
|
|
|
if fee_abs is not None:
|
|
|
|
order_obj.ft_fee_base = fee_abs
|
2021-12-27 15:07:43 +00:00
|
|
|
except DependencyException as exception:
|
|
|
|
logger.warning("Could not update trade amount: %s", exception)
|
|
|
|
|
2022-08-30 18:46:06 +00:00
|
|
|
def get_real_amount(self, trade: Trade, order: Dict, order_obj: Order) -> Optional[float]:
|
2020-01-02 08:50:54 +00:00
|
|
|
"""
|
2020-05-01 14:13:07 +00:00
|
|
|
Detect and update trade fee.
|
2021-05-16 12:50:25 +00:00
|
|
|
Calls trade.update_fee() upon correct detection.
|
2020-05-01 14:13:07 +00:00
|
|
|
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)
|
2022-08-30 18:46:06 +00:00
|
|
|
:return: Absolute fee to apply for this order or None
|
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':
|
2022-08-30 18:46:06 +00:00
|
|
|
return None
|
2020-01-02 08:50:54 +00:00
|
|
|
|
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):
|
2022-07-06 17:15:55 +00:00
|
|
|
fee_cost, fee_currency, fee_rate = self.exchange.extract_cost_curr_rate(
|
|
|
|
order['fee'], order['symbol'], order['cost'], order_obj.safe_filled)
|
2022-03-20 08:42:34 +00:00
|
|
|
logger.info(f"Fee for Trade {trade} [{order_obj.ft_order_side}]: "
|
2020-05-01 18:03:06 +00:00
|
|
|
f"{fee_cost:.8g} {fee_currency} - rate: {fee_rate}")
|
2020-12-12 09:52:27 +00:00
|
|
|
if fee_rate is None or fee_rate < 0.02:
|
|
|
|
# Reject all fees that report as > 2%.
|
|
|
|
# These are most likely caused by a parsing bug in ccxt
|
|
|
|
# due to multiple trades (https://github.com/ccxt/ccxt/issues/8025)
|
|
|
|
trade.update_fee(fee_cost, fee_currency, fee_rate, order.get('side', ''))
|
|
|
|
if trade_base_currency == fee_currency:
|
|
|
|
# Apply fee to amount
|
|
|
|
return self.apply_fee_conditional(trade, trade_base_currency,
|
2022-09-01 04:35:24 +00:00
|
|
|
amount=order_amount, fee_abs=fee_cost,
|
|
|
|
order_obj=order_obj)
|
2022-08-30 18:46:06 +00:00
|
|
|
return None
|
2022-03-20 08:42:34 +00:00
|
|
|
return self.fee_detection_from_trades(
|
|
|
|
trade, order, order_obj, order_amount, order.get('trades', []))
|
2020-01-02 08:50:54 +00:00
|
|
|
|
2022-03-20 08:42:34 +00:00
|
|
|
def fee_detection_from_trades(self, trade: Trade, order: Dict, order_obj: Order,
|
2022-08-30 18:46:06 +00:00
|
|
|
order_amount: float, trades: List) -> Optional[float]:
|
2020-05-01 14:13:07 +00:00
|
|
|
"""
|
2021-11-10 18:43:36 +00:00
|
|
|
fee-detection fallback to Trades.
|
|
|
|
Either uses provided trades list or the result of fetch_my_trades to get correct fee.
|
2020-05-01 14:13:07 +00:00
|
|
|
"""
|
2021-11-10 18:43:36 +00:00
|
|
|
if not trades:
|
|
|
|
trades = self.exchange.get_trades_for_order(
|
2022-03-20 08:42:34 +00:00
|
|
|
self.exchange.get_order_id_conditional(order), trade.pair, order_obj.order_date)
|
2020-01-02 08:50:54 +00:00
|
|
|
|
|
|
|
if len(trades) == 0:
|
|
|
|
logger.info("Applying fee on amount for %s failed: myTrade-Dict empty found", trade)
|
2022-08-30 18:46:06 +00:00
|
|
|
return None
|
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):
|
2022-07-07 17:40:16 +00:00
|
|
|
# Prefer singular fee
|
|
|
|
fees = [exectrade['fee']]
|
|
|
|
else:
|
|
|
|
fees = exectrade.get('fees', [])
|
|
|
|
for fee in fees:
|
|
|
|
|
2022-07-06 17:15:55 +00:00
|
|
|
fee_cost_, fee_currency, fee_rate_ = self.exchange.extract_cost_curr_rate(
|
2022-07-07 17:40:16 +00:00
|
|
|
fee, exectrade['symbol'], exectrade['cost'], exectrade['amount']
|
2022-07-06 17:15:55 +00:00
|
|
|
)
|
2020-05-01 14:01:33 +00:00
|
|
|
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
|
2021-08-22 12:37:45 +00:00
|
|
|
if fee_rate is not None and fee_rate < 0.02:
|
|
|
|
# Only update if fee-rate is < 2%
|
|
|
|
trade.update_fee(fee_cost, fee_currency, fee_rate, order.get('side', ''))
|
2022-08-16 15:06:25 +00:00
|
|
|
else:
|
|
|
|
logger.warning(
|
|
|
|
f"Not updating {order.get('side', '')}-fee - rate: {fee_rate}, {fee_currency}.")
|
2020-01-02 08:50:54 +00:00
|
|
|
|
|
|
|
if not isclose(amount, order_amount, abs_tol=constants.MATH_CLOSE_PREC):
|
2022-03-30 17:38:25 +00:00
|
|
|
# * Leverage could be a cause for this warning
|
2020-01-02 08:50:54 +00:00
|
|
|
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:
|
2022-09-01 04:35:24 +00:00
|
|
|
return self.apply_fee_conditional(
|
|
|
|
trade, trade_base_currency, amount=amount, fee_abs=fee_abs, order_obj=order_obj)
|
2022-08-30 18:46:06 +00:00
|
|
|
return None
|
2021-08-12 19:13:14 +00:00
|
|
|
|
|
|
|
def get_valid_price(self, custom_price: float, proposed_price: float) -> float:
|
|
|
|
"""
|
|
|
|
Return the valid price.
|
|
|
|
Check if the custom price is of the good type if not return proposed_price
|
|
|
|
:return: valid price for the order
|
|
|
|
"""
|
2021-08-12 19:30:49 +00:00
|
|
|
if custom_price:
|
2021-08-13 15:06:15 +00:00
|
|
|
try:
|
2021-08-16 19:18:57 +00:00
|
|
|
valid_custom_price = float(custom_price)
|
2021-08-13 15:06:15 +00:00
|
|
|
except ValueError:
|
2021-08-16 19:18:57 +00:00
|
|
|
valid_custom_price = proposed_price
|
2021-08-12 19:13:14 +00:00
|
|
|
else:
|
2021-08-16 19:18:57 +00:00
|
|
|
valid_custom_price = proposed_price
|
|
|
|
|
2021-08-18 09:07:37 +00:00
|
|
|
cust_p_max_dist_r = self.config.get('custom_price_max_distance_ratio', 0.02)
|
|
|
|
min_custom_price_allowed = proposed_price - (proposed_price * cust_p_max_dist_r)
|
|
|
|
max_custom_price_allowed = proposed_price + (proposed_price * cust_p_max_dist_r)
|
2021-08-16 19:18:57 +00:00
|
|
|
|
2021-08-18 18:20:11 +00:00
|
|
|
# Bracket between min_custom_price_allowed and max_custom_price_allowed
|
|
|
|
return max(
|
|
|
|
min(valid_custom_price, max_custom_price_allowed),
|
|
|
|
min_custom_price_allowed)
|