from decimal import Decimal as D, ROUND_DOWN
from json import JSONDecodeError
from simplejson.errors import JSONDecodeError as SimpleJSONDecodeError
-from ccxt import ExchangeError, InsufficientFunds, ExchangeNotAvailable, InvalidOrder
+from ccxt import ExchangeError, InsufficientFunds, ExchangeNotAvailable, InvalidOrder, OrderNotCached, OrderNotFound
from retry import retry
import requests
class Balance:
base_keys = ["total", "exchange_total", "exchange_used",
- "exchange_free", "margin_total", "margin_borrowed",
- "margin_free"]
+ "exchange_free", "margin_total", "margin_in_position",
+ "margin_available", "margin_borrowed", "margin_pending_gain"]
def __init__(self, currency, hash_):
self.currency = currency
base_currency = hash_["margin_borrowed_base_currency"]
for key in [
"margin_liquidation_price",
- "margin_pending_gain",
"margin_lending_fees",
+ "margin_pending_base_gain",
"margin_borrowed_base_price"
]:
setattr(self, key, Amount(base_currency, hash_.get(key, 0)))
exchange = ""
if self.margin_total > 0:
- if self.margin_free != 0 and self.margin_borrowed != 0:
- margin = " Margin: [✔{} + borrowed {} = {}]".format(str(self.margin_free), str(self.margin_borrowed), str(self.margin_total))
- elif self.margin_free != 0:
- margin = " Margin: [✔{}]".format(str(self.margin_free))
+ if self.margin_available != 0 and self.margin_in_position != 0:
+ margin = " Margin: [✔{} + ❌{} = {}]".format(str(self.margin_available), str(self.margin_in_position), str(self.margin_total))
+ elif self.margin_available != 0:
+ margin = " Margin: [✔{}]".format(str(self.margin_available))
else:
- margin = " Margin: [borrowed {}]".format(str(self.margin_borrowed))
+ margin = " Margin: [❌{}]".format(str(self.margin_in_position))
elif self.margin_total < 0:
margin = " Margin: [{} @@ {}/{}]".format(str(self.margin_total),
str(self.margin_borrowed_base_price),
self.value_to = value_to
self.orders = []
self.market = market
+ self.closed = False
+ self.inverted = None
+ assert self.value_from.value * self.value_to.value >= 0
assert self.value_from.currency == self.value_to.currency
if self.value_from != 0:
assert self.value_from.linked_to is not None and self.value_from.linked_to.currency == self.currency
self.value_from.linked_to = Amount(self.currency, 0)
self.base_currency = self.value_from.currency
+ @property
+ def delta(self):
+ return self.value_to - self.value_from
+
@property
def action(self):
if self.value_from == self.value_to:
else:
return "dispose"
- def order_action(self, inverted):
- if (self.value_from < self.value_to) != inverted:
+ def order_action(self):
+ if (self.value_from < self.value_to) != self.inverted:
return "buy"
else:
return "sell"
else:
return "long"
+ @property
+ def pending(self):
+ return not (self.is_fullfiled or self.closed)
+
+ def close(self):
+ for order in self.orders:
+ order.cancel()
+ self.closed = True
+
+ @property
+ def is_fullfiled(self):
+ return abs(self.filled_amount(in_base_currency=(not self.inverted))) >= abs(self.delta)
+
def filled_amount(self, in_base_currency=False):
filled_amount = 0
for order in self.orders:
return filled_amount
def update_order(self, order, tick):
- new_order = None
- if tick in [0, 1, 3, 4, 6]:
+ actions = {
+ 0: ["waiting", None],
+ 1: ["waiting", None],
+ 2: ["adjusting", lambda x, y: (x[y] + x["average"]) / 2],
+ 3: ["waiting", None],
+ 4: ["waiting", None],
+ 5: ["adjusting", lambda x, y: (x[y]*2 + x["average"]) / 3],
+ 6: ["waiting", None],
+ 7: ["market_fallback", "default"],
+ }
+
+ if tick in actions:
+ update, compute_value = actions[tick]
+ elif tick % 3 == 1:
+ update = "market_adjust"
+ compute_value = "default"
+ else:
update = "waiting"
compute_value = None
- elif tick == 2:
- update = "adjusting"
- compute_value = 'lambda x, y: (x[y] + x["average"]) / 2'
- new_order = self.prepare_order(compute_value=lambda x, y: (x[y] + x["average"]) / 2)
- elif tick ==5:
- update = "adjusting"
- compute_value = 'lambda x, y: (x[y]*2 + x["average"]) / 3'
- new_order = self.prepare_order(compute_value=lambda x, y: (x[y]*2 + x["average"]) / 3)
- elif tick >= 7:
- if (tick - 7) % 3 == 0:
- new_order = self.prepare_order(compute_value="default")
- update = "market_adjust"
- compute_value = "default"
- else:
- update = "waiting"
- compute_value = None
- if tick == 7:
- update = "market_fallback"
+
+ if compute_value is not None:
+ order.cancel()
+ new_order = self.prepare_order(compute_value=compute_value)
+ else:
+ new_order = None
self.market.report.log_order(order, tick, update=update,
compute_value=compute_value, new_order=new_order)
if new_order is not None:
- order.cancel()
new_order.run()
self.market.report.log_order(order, tick, new_order=new_order)
if self.action is None:
return None
ticker = self.market.get_ticker(self.currency, self.base_currency)
- inverted = ticker["inverted"]
- if inverted:
+ self.inverted = ticker["inverted"]
+ if self.inverted:
ticker = ticker["original"]
- rate = Computation.compute_value(ticker, self.order_action(inverted), compute_value=compute_value)
+ rate = Computation.compute_value(ticker, self.order_action(), compute_value=compute_value)
- #TODO: store when the order is considered filled
# FIXME: Dust amount should be removed from there if they werent
# honored in other sales
- delta_in_base = abs(self.value_from - self.value_to)
+ delta_in_base = abs(self.delta)
# 9 BTC's worth of move (10 - 1 or 1 - 10 depending on case)
- if not inverted:
+ if not self.inverted:
base_currency = self.base_currency
# BTC
if self.action == "dispose":
self.market.report.log_error("prepare_order", message="Less to do than already filled: {}".format(delta))
return None
- order = Order(self.order_action(inverted),
+ order = Order(self.order_action(),
delta, rate, base_currency, self.trade_type,
self.market, self, close_if_possible=close_if_possible)
self.orders.append(order)
}
def __repr__(self):
- return "Trade({} -> {} in {}, {})".format(
+ if self.closed and not self.is_fullfiled:
+ closed = " ❌"
+ elif self.is_fullfiled:
+ closed = " ✔"
+ else:
+ closed = ""
+
+ return "Trade({} -> {} in {}, {}{})".format(
self.value_from,
self.value_to,
self.currency,
- self.action)
+ self.action,
+ closed)
def print_with_order(self, ind=""):
self.market.report.print_log("{}{}".format(ind, self))
self.trade = trade
self.close_if_possible = close_if_possible
self.id = None
- self.fetch_cache_timestamp = None
self.tries = 0
def as_json(self):
@property
def finished(self):
- return self.status == "closed" or self.status == "canceled" or self.status == "error"
+ return self.status.startswith("closed") or self.status == "canceled" or self.status == "error"
@retry(InsufficientFunds)
def run(self):
# other states are "closed" and "canceled"
if not self.finished:
self.fetch()
- if self.finished:
- self.mark_finished_order()
return self.status
def mark_finished_order(self):
- if self.market.debug:
+ if self.status.startswith("closed") and self.market.debug:
self.market.report.log_debug_action("Mark {} as finished".format(self))
return
- if self.status == "closed":
+ if self.status.startswith("closed"):
if self.trade_type == "short" and self.action == "buy" and self.close_if_possible:
self.market.ccxt.close_margin_position(self.amount.currency, self.base_currency)
- def fetch(self, force=False):
+ def fetch(self):
if self.market.debug:
self.market.report.log_debug_action("Fetching {}".format(self))
return
- if (not force and self.fetch_cache_timestamp is not None
- and time.time() - self.fetch_cache_timestamp < 10):
- return
- self.fetch_cache_timestamp = time.time()
-
- result = self.market.ccxt.fetch_order(self.id, symbol=self.amount.currency)
- self.results.append(result)
+ try:
+ result = self.market.ccxt.fetch_order(self.id)
+ self.results.append(result)
+ self.status = result["status"]
+ # Time at which the order started
+ self.timestamp = result["datetime"]
+ except OrderNotCached:
+ self.status = "closed_unknown"
- self.status = result["status"]
- # Time at which the order started
- self.timestamp = result["datetime"]
self.fetch_mouvements()
+ self.mark_finished_order()
# FIXME: consider open order with dust remaining as closed
def dust_amount_remaining(self):
return self.remaining_amount() < Amount(self.amount.currency, D("0.001"))
def remaining_amount(self):
- if self.status == "open":
- self.fetch()
return self.amount - self.filled_amount()
def filled_amount(self, in_base_currency=False):
self.market.report.log_debug_action("Mark {} as cancelled".format(self))
self.status = "canceled"
return
- self.market.ccxt.cancel_order(self.id)
- self.fetch(force=True)
+ if self.open and self.id is not None:
+ try:
+ self.market.ccxt.cancel_order(self.id)
+ except OrderNotFound as e: # Closed inbetween
+ self.market.report.log_error("cancel_order", message="Already cancelled order", exception=e)
+ self.fetch()
class Mouvement:
def __init__(self, currency, base_currency, hash_):