diff --git a/core/exchanges/oanda.py b/core/exchanges/oanda.py index bcfb1de..e1d8f66 100644 --- a/core/exchanges/oanda.py +++ b/core/exchanges/oanda.py @@ -54,7 +54,7 @@ class OANDAExchange(BaseExchange): # "price": "1.5000", - added later "stopLossOnFill": {"timeInForce": "GTC", "price": str(trade.stop_loss)}, "takeProfitOnFill": {"price": str(trade.take_profit)}, - # "timeInForce": "GTC", + "timeInForce": "GTC", "instrument": trade.symbol, "units": str(amount), "type": trade.type.upper(), diff --git a/core/lib/market.py b/core/lib/market.py index 64a6a43..ca9b0e5 100644 --- a/core/lib/market.py +++ b/core/lib/market.py @@ -1,7 +1,7 @@ from decimal import Decimal as D from core.exchanges import GenericAPIError -from core.models import Strategy, Trade +from core.models import Account, Strategy, Trade from core.util import logs log = logs.get_logger(__name__) @@ -16,132 +16,230 @@ log = logs.get_logger(__name__) # prices = account.client.get_currencies([symbol]) -def to_currency(direction, account, amount, from_currency, to_currency): +def get_pair(account, base, quote, invert=False): + """ + Get the pair for the given account and currencies. + :param account: Account object + :param base: Base currency + :param quote: Quote currency + :param invert: Invert the pair + :return: currency symbol, e.g. BTC_USD, BTC/USD, etc. + """ + # Currently we only have two exchanges with different pair separators if account.exchange == "alpaca": separator = "/" elif account.exchange == "oanda": separator = "_" + + # Flip the pair if needed + if invert: + symbol = f"{quote.upper()}{separator}{base.upper()}" + else: + symbol = f"{base.upper()}{separator}{quote.upper()}" + # Check it exists + if symbol not in account.supported_symbols: + return False + return symbol + + +def to_currency(direction, account, amount, from_currency, to_currency): + """ + Convert an amount from one currency to another. + :param direction: Direction of the trade + :param account: Account object + :param amount: Amount to convert + :param from_currency: Currency to convert from + :param to_currency: Currency to convert to + :return: Converted amount + """ + # This is needed because OANDA has different values for bid and ask if direction == "buy": price_index = "bids" elif direction == "sell": price_index = "asks" - symbol = f"{from_currency.upper()}{separator}{to_currency.upper()}" - if symbol not in account.supported_symbols: - symbol = f"{to_currency.upper()}{separator}{from_currency.upper()}" + symbol = get_pair(account, from_currency, to_currency) + if not symbol: + symbol = get_pair(account, from_currency, to_currency, invert=True) inverted = True + + # Bit of a hack but it works + if not symbol: + log.error(f"Could not find symbol for {from_currency} -> {to_currency}") + raise Exception("Could not find symbol") try: prices = account.client.get_currencies([symbol]) except GenericAPIError as e: log.error(f"Error getting currencies and inverted currencies: {e}") return None price = prices["prices"][0][price_index][0]["price"] + + # If we had to flip base and quote, we need to use the reciprocal of the price if inverted: price = D(1.0) / D(price) + + # Convert the amount to the destination currency converted = D(amount) * price return converted -def get_pair(account, base, quote): - if account.exchange == "alpaca": - separator = "/" - elif account.exchange == "oanda": - separator = "_" +def get_trade_size_in_base(direction, account, strategy, cash_balance, base): + """ + Get the trade size in the base currency. + :param direction: Direction of the trade + :param account: Account object + :param strategy: Strategy object + :param cash_balance: Cash balance in the Account's base currency + :param base: Base currency + :return: Trade size in the base currency + """ - symbol = f"{base.upper()}{separator}{quote.upper()}" - if symbol not in account.supported_symbols: - return False - return symbol - - -def get_trade_size_in_base( - direction, account, strategy, cash_balance, price, base, precision -): + # Convert the trade size in percent to a ratio trade_size_as_ratio = D(strategy.trade_size_percent) / D(100) log.debug(f"Trade size as ratio: {trade_size_as_ratio}") + + # Multiply with cash balance to get the trade size in the account's + # base currency amount_fiat = D(trade_size_as_ratio) * D(cash_balance) log.debug(f"Trade size: {amount_fiat}") - # We can do this because the quote IS in $ or equivalent - # trade_size_in_base = D(amount_fiat) / D(price) + + # Convert the trade size to the base currency trade_size_in_base = to_currency( direction, account, amount_fiat, account.currency, base ) log.debug(f"Trade size in base: {trade_size_in_base}") + return trade_size_in_base def get_tp_sl(direction, strategy, price): + """ + Get the take profit and stop loss prices. + :param direction: Direction of the trade + :param strategy: Strategy object + :param price: Price of the trade + :return: Take profit and stop loss prices + """ + + # Convert TP and SL to ratios stop_loss_as_ratio = D(strategy.stop_loss_percent) / D(100) take_profit_as_ratio = D(strategy.take_profit_percent) / D(100) log.debug(f"Stop loss as ratio: {stop_loss_as_ratio}") log.debug(f"Take profit as ratio: {take_profit_as_ratio}") + # Calculate the TP and SL prices by multiplying with the price stop_loss_var = D(price) * D(stop_loss_as_ratio) take_profit_var = D(price) * D(take_profit_as_ratio) log.debug(f"Stop loss var: {stop_loss_var}") log.debug(f"Take profit var: {take_profit_var}") + # Flip addition operators for inverse trade directions + # * We need to subtract the SL for buys, since we are losing money if + # the price goes down + # * We need to add the TP for buys, since we are gaining money if + # the price goes up + # * We need to add the SL for sells, since we are losing money if + # the price goes up + # * We need to subtract the TP for sells, since we are gaining money if + # the price goes down if direction == "buy": stop_loss = D(price) - D(stop_loss_var) take_profit = D(price) + D(take_profit_var) elif direction == "sell": stop_loss = D(price) + D(stop_loss_var) take_profit = D(price) - D(take_profit_var) - log.debug(f"Stop loss: {stop_loss}") log.debug(f"Take profit: {take_profit}") + return (stop_loss, take_profit) def get_price_bound(direction, strategy, price): + """ + Get the price bound for a given price using the slippage from the strategy. + :param direction: Direction of the trade + :param strategy: Strategy object + :param price: Price of the trade + :return: Price bound + """ + + # Convert the slippage to a ratio price_slippage_as_ratio = D(strategy.price_slippage_percent) / D(100) log.debug(f"Price slippage as ratio: {price_slippage_as_ratio}") - price_slippage = D(price) * D(price_slippage_as_ratio) + # Calculate the price bound by multiplying with the price + # The price bound is the worst price we are willing to pay for the trade + price_slippage = D(price) * D(price_slippage_as_ratio) log.debug(f"Price slippage: {price_slippage}") + # Subtract slippage for buys, since we lose money if the price goes down if direction == "buy": price_bound = D(price) - D(price_slippage) + + # Add slippage for sells, since we lose money if the price goes up elif direction == "sell": price_bound = D(price) + D(price_slippage) - price_bound = D(price) + D(price_slippage) - log.debug(f"Price bound: {price_bound}") return price_bound def execute_strategy(callback, strategy): + """ + Execute a strategy. + :param callback: Callback object + :param strategy: Strategy object + """ + + # Get the account's balance in the native account currency cash_balance = strategy.account.client.get_balance() - instruments = strategy.account.instruments log.debug(f"Cash balance: {cash_balance}") + # Instruments supported by the account + if not strategy.account.instruments: + strategy.account.update_info() + # Refresh account object + strategy.account = Account.objects.get(id=strategy.account.id) + + instruments = strategy.account.instruments + if not instruments: + log.error("No instruments found") + return + + # Shorten some hook, strategy and callback vars for convenience user = strategy.user account = strategy.account hook = callback.hook base = callback.base quote = callback.quote direction = hook.direction + + # Don't be silly if callback.exchange != account.exchange: log.error("Market exchange differs from account exchange.") return + # Get the pair we are trading symbol = get_pair(account, base, quote) - if not symbol: log.error(f"Symbol not supported by account: {symbol}") - return False + return + print("INSTRUMENTS", instruments) + # Extract the information for the symbol instrument = strategy.account.client.extract_instrument(instruments, symbol) if not instrument: log.error(f"Symbol not found: {symbol}") - return False + return + + # Get the required precision try: trade_precision = instrument["tradeUnitsPrecision"] display_precision = instrument["displayPrecision"] except KeyError: log.error(f"Precision not found for {symbol}") - return False + return + # Round the received price to the display precision price = round(D(callback.price), display_precision) log.debug(f"Extracted price of quote: {price}") @@ -152,15 +250,36 @@ def execute_strategy(callback, strategy): # return False # type = "limit" - type = "market" + # Only using market orders for now, but with price bounds, so it's a similar + # amount of protection from market fluctuations + # type = "market" + + # For OANDA we can use the price since it should match exactly + # Not yet sure how to use both limit and market orders + type = "limit" + + # Convert the trade size, which is currently in the account's base currency, + # to the base currency of the pair we are trading trade_size_in_base = get_trade_size_in_base( - direction, account, strategy, cash_balance, price, base, display_precision + direction, account, strategy, cash_balance, base ) + + # Calculate TP/SL stop_loss, take_profit = get_tp_sl(direction, strategy, price) + # Calculate price bound and round to the display precision price_bound = round(get_price_bound(direction, strategy, price), display_precision) + # Use the price reported by the callback for limit orders + if type == "limit": + price_for_trade = price + + # Use the price bound for market orders + elif type == "market": + price_for_trade = price_bound + + # Create object, note that the amount is rounded to the trade precision new_trade = Trade.objects.create( user=user, account=account, @@ -169,7 +288,8 @@ def execute_strategy(callback, strategy): type=type, # amount_fiat=amount_fiat, amount=float(round(trade_size_in_base, trade_precision)), - price=price_bound, + # price=price_bound, + price=price_for_trade, stop_loss=float(round(stop_loss, display_precision)), take_profit=float(round(take_profit, display_precision)), direction=direction, diff --git a/core/models.py b/core/models.py index e399321..deb6889 100644 --- a/core/models.py +++ b/core/models.py @@ -86,10 +86,7 @@ class Account(models.Model): name += " (sandbox)" return name - def save(self, *args, **kwargs): - """ - Override the save function to update supported symbols. - """ + def update_info(self, save=True): client = self.get_client() if client: response = client.get_instruments() @@ -99,6 +96,14 @@ class Account(models.Model): self.supported_symbols = supported_symbols self.instruments = response self.currency = currency + if save: + self.save() + + def save(self, *args, **kwargs): + """ + Override the save function to update supported symbols. + """ + self.update_info(save=False) super().save(*args, **kwargs) def get_client(self):