XF
/
fisk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Documented the market system properly, squashed some bugs

This commit is contained in:
Mark Veidemanis 2022-11-11 07:20:00 +00:00
parent c3d908341a
commit afb0504dca
Signed by: m
GPG Key ID: 5ACFCEED46C0904F
3 changed files with 163 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core/exchanges/oanda.py
View File

@ -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(),

186
core/lib/market.py
View File

@ -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,

13
core/models.py
View File

@ -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):