fisk/core/lib/market.py

from decimal import Decimal as D

from core.exchanges import GenericAPIError
from core.models import Account, Strategy, Trade
from core.util import logs

log = logs.get_logger(__name__)


# def to_usd(account, amount, from_currency):
#     if account.exchange == "alpaca":
#         separator = "/"
#     elif account.exchange == "oanda":
#         separator = "_"
#     symbol = f"{from_currency.upper()}{separator}{to_currency.upper()}"
#     prices = account.client.get_currencies([symbol])


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
    """
    inverted = False

    # 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 = 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 = D(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) / price

    # Convert the amount to the destination currency
    converted = D(amount) * price

    return converted


def get_price(account, direction, symbol):
    """
    Get the price for a given symbol.
    :param account: Account object
    :param direction: direction of the trade
    :param symbol: symbol
    :return: price of bid for buys, price of ask for sells
    """
    if direction == "buy":
        price_index = "bids"
    elif direction == "sell":
        price_index = "asks"
    try:
        prices = account.client.get_currencies([symbol])
    except GenericAPIError as e:
        log.error(f"Error getting currencies: {e}")
        return None
    price = D(prices["prices"][0][price_index][0]["price"])
    return price


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
    """

    # 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}")

    # Convert the trade size to the base currency
    if account.currency.lower() == base.lower():
        trade_size_in_base = amount_fiat
    else:
        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, current_price):
    """
    Get the price bound for a given price using the slippage from the strategy.
    * Check that the price of the callback is within the callback price deviation of the
    current price
    * Calculate the price bounds such that the maximum slippage should be within the
    price slippage relative to the current price.
    Note that the maximum actual slippage may be as high as the sum of these two values.
    :param direction: Direction of the trade
    :param strategy: Strategy object
    :param price: Price of the trade
    :param current_price: current price from the exchange
    :return: Price bound
    """

    # Convert the callback price deviation to a ratio
    callback_price_deviation_as_ratio = D(
        strategy.callback_price_deviation_percent
    ) / D(100)
    log.debug(f"Callback price deviation as ratio: {callback_price_deviation_as_ratio}")

    maximum_price_deviation = D(current_price) * D(callback_price_deviation_as_ratio)

    # Ensure the current price is within price_slippage_as_ratio of the callback price
    if abs(current_price - price) <= maximum_price_deviation:
        log.debug("Current price is within price deviation of callback price")
    else:
        log.error("Current price is not within price deviation of callback price")
        log.debug(f"Difference: {abs(current_price - price)}")
        return None

    # Convert the maximum price slippage to a ratio
    price_slippage_as_ratio = D(strategy.price_slippage_percent) / D(100)
    log.debug(f"Maximum price slippage as ratio: {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(current_price) * D(price_slippage_as_ratio)
    log.debug(f"Maximum deviation from callback price: {price_slippage}")

    current_price_slippage = D(current_price) * D(price_slippage_as_ratio)
    log.debug(f"Maximum deviation from current price: {current_price_slippage}")

    # Subtract slippage for buys, since we lose money if the price goes down
    if direction == "buy":
        price_bound = D(current_price) - D(price_slippage)

    # Add slippage for sells, since we lose money if the price goes up
    elif direction == "sell":
        price_bound = D(current_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()
    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

    # 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

    # Get the required precision
    try:
        trade_precision = instrument["tradeUnitsPrecision"]
        display_precision = instrument["displayPrecision"]
    except KeyError:
        log.error(f"Precision not found for {symbol}")
        return

    # Round the received price to the display precision
    price = round(D(callback.price), display_precision)
    log.debug(f"Extracted price of quote: {price}")

    type = strategy.order_type

    current_price = get_price(account, direction, symbol)
    log.debug(f"Callback price: {price}")
    log.debug(f"Current price: {current_price}")

    # 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, 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 = get_price_bound(direction, strategy, price, current_price)
    if not price_bound:
        return
    price_bound = round(price_bound, 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,
        hook=hook,
        symbol=symbol,
        type=type,
        time_in_force=strategy.time_in_force,
        # amount_fiat=amount_fiat,
        amount=float(round(trade_size_in_base, trade_precision)),
        # price=price_bound,
        price=price_bound,
        stop_loss=float(round(stop_loss, display_precision)),
        take_profit=float(round(take_profit, display_precision)),
        direction=direction,
    )
    new_trade.save()
    info = new_trade.post()
    log.debug(f"Posted trade: {info}")


def process_callback(callback):
    log.info(f"Received callback for {callback.hook}")
    strategies = Strategy.objects.filter(hooks=callback.hook, enabled=True)
    log.debug(f"Matched strategies: {strategies}")
    for strategy in strategies:
        log.debug(f"Executing strategy {strategy}")
        if callback.hook.user != strategy.user:
            log.error("Ownership differs between callback and strategy.")
            continue
        execute_strategy(callback, strategy)