X-Git-Url: https://git.immae.eu/?p=perso%2FImmae%2FProjets%2FCryptomonnaies%2FCryptoportfolio%2FTrader.git;a=blobdiff_plain;f=portfolio.py;h=1d291069bfa08c7cb497e90046de010e6d7f2e02;hp=1d8bfd5f122775df881bcbbdd3a76e8422740896;hb=HEAD;hpb=f2da658998b6e6605c6ae27ff338ef23b96dce25

diff --git a/portfolio.py b/portfolio.py
index 1d8bfd5..1d29106 100644
--- a/portfolio.py
+++ b/portfolio.py
@@ -1,160 +1,77 @@
-import ccxt
-import time
-# Put your poloniex api key in market.py
-from market import market
-
-# FIXME: Améliorer le bid/ask
-# FIXME: J'essayais d'utiliser plus de bitcoins que j'en avais à disposition
-# FIXME: better compute moves to avoid rounding errors
-
-def static_var(varname, value):
-    def decorate(func):
-        setattr(func, varname, value)
-        return func
-    return decorate
-
-class Portfolio:
-    URL = "https://cryptoportfolio.io/wp-content/uploads/portfolio/json/cryptoportfolio.json"
-    liquidities = {}
-    data = None
+import datetime
+from retry import retry
+from decimal import Decimal as D, ROUND_DOWN
+from ccxt import ExchangeError, InsufficientFunds, ExchangeNotAvailable, InvalidOrder, OrderNotCached, OrderNotFound, RequestTimeout, InvalidNonce
+
+class Computation:
+    @staticmethod
+    def eat_several(market):
+        return lambda x, y: market.ccxt.fetch_nth_order_book(x["symbol"], y, 15)
+
+    computations = {
+            "default": lambda x, y: x[y],
+            "average": lambda x, y: x["average"],
+            "bid": lambda x, y: x["bid"],
+            "ask": lambda x, y: x["ask"],
+            }
 
     @classmethod
-    def repartition_pertenthousand(cls, liquidity="medium"):
-        cls.parse_cryptoportfolio()
-        liquidities = cls.liquidities[liquidity]
-        last_date = sorted(liquidities.keys())[-1]
-        return liquidities[last_date]
-
-    @classmethod
-    def get_cryptoportfolio(cls):
-        import json
-        import urllib3
-        urllib3.disable_warnings()
-        http = urllib3.PoolManager()
-
-        try:
-            r = http.request("GET", cls.URL)
-        except Exception:
-            return
-        try:
-            cls.data = json.loads(r.data)
-        except json.JSONDecodeError:
-            cls.data = None
-
-    @classmethod
-    def parse_cryptoportfolio(cls):
-        if cls.data is None:
-            cls.get_cryptoportfolio()
-
-        def filter_weights(weight_hash):
-            if weight_hash[1] == 0:
-                return False
-            if weight_hash[0] == "_row":
-                return False
-            return True
-
-        def clean_weights(i):
-            def clean_weights_(h):
-                if type(h[1][i]) == str:
-                    return [h[0], h[1][i]]
-                else:
-                    return [h[0], int(h[1][i] * 10000)]
-            return clean_weights_
-
-        def parse_weights(portfolio_hash):
-            # FIXME: we'll need shorts at some point
-            assert all(map(lambda x: x == "long", portfolio_hash["holding"]["direction"]))
-            weights_hash = portfolio_hash["weights"]
-            weights = {}
-            for i in range(len(weights_hash["_row"])):
-                weights[weights_hash["_row"][i]] = dict(filter(
-                        filter_weights,
-                        map(clean_weights(i), weights_hash.items())))
-            return weights
-
-        high_liquidity = parse_weights(cls.data["portfolio_1"])
-        medium_liquidity = parse_weights(cls.data["portfolio_2"])
-
-        cls.liquidities = {
-                "medium": medium_liquidity,
-                "high":   high_liquidity,
-                }
+    def compute_value(cls, ticker, action, compute_value="default"):
+        if action == "buy":
+            action = "ask"
+        if action == "sell":
+            action = "bid"
+        if isinstance(compute_value, str):
+            compute_value = cls.computations[compute_value]
+        return compute_value(ticker, action)
 
 class Amount:
-    MAX_DIGITS = 18
-
-    def __init__(self, currency, value, int_val=None, linked_to=None, ticker=None):
+    def __init__(self, currency, value, linked_to=None, ticker=None, rate=None):
         self.currency = currency
-        if int_val is None:
-            self._value = int(value * 10**self.MAX_DIGITS)
-        else:
-            self._value = int_val
+        self.value = D(value)
         self.linked_to = linked_to
         self.ticker = ticker
+        self.rate = rate
 
-        self.ticker_cache = {}
-        self.ticker_cache_timestamp = time.time()
-
-    @property
-    def value(self):
-        return self._value / 10 ** self.MAX_DIGITS
-
-    def in_currency(self, other_currency, market, action="average"):
+    def in_currency(self, other_currency, market, rate=None, action=None, compute_value="average"):
         if other_currency == self.currency:
             return self
-        asset_ticker = self.get_ticker(other_currency, market)
+        if rate is not None:
+            return Amount(
+                    other_currency,
+                    self.value * rate,
+                    linked_to=self,
+                    rate=rate)
+        asset_ticker = market.get_ticker(self.currency, other_currency)
         if asset_ticker is not None:
+            rate = Computation.compute_value(asset_ticker, action, compute_value=compute_value)
             return Amount(
                     other_currency,
-                    0,
-                    int_val=int(self._value * asset_ticker[action]),
+                    self.value * rate,
                     linked_to=self,
-                    ticker=asset_ticker)
+                    ticker=asset_ticker,
+                    rate=rate)
         else:
-            raise Exception("This asset is not available in the chosen market")
-
-    def get_ticker(self, c2, market, refresh=False):
-        c1 = self.currency
-
-        def invert(ticker):
-            return {
-                    "inverted": True,
-                    "average": (float(1/ticker["bid"]) + float(1/ticker["ask"]) ) / 2,
-                    "notInverted": ticker,
-                    }
-        def augment_ticker(ticker):
-            ticker.update({
-                "inverted": False,
-                "average": (ticker["bid"] + ticker["ask"] ) / 2,
-                })
-
-        if time.time() - self.ticker_cache_timestamp > 5:
-            self.ticker_cache = {}
-            self.ticker_cache_timestamp = time.time()
-        elif not refresh:
-            if (c1, c2, market.__class__) in self.ticker_cache:
-                return self.ticker_cache[(c1, c2, market.__class__)]
-            if (c2, c1, market.__class__) in self.ticker_cache:
-                return invert(self.ticker_cache[(c2, c1, market.__class__)])
+            return Amount(other_currency, 0, linked_to=self, ticker=None, rate=0)
 
-        try:
-            self.ticker_cache[(c1, c2, market.__class__)] = market.fetch_ticker("{}/{}".format(c1, c2))
-            augment_ticker(self.ticker_cache[(c1, c2, market.__class__)])
-        except ccxt.ExchangeError:
-            try:
-                self.ticker_cache[(c2, c1, market.__class__)] = market.fetch_ticker("{}/{}".format(c2, c1))
-                augment_ticker(self.ticker_cache[(c2, c1, market.__class__)])
-            except ccxt.ExchangeError:
-                self.ticker_cache[(c1, c2, market.__class__)] = None
-        return self.get_ticker(c2, market)
+    def as_json(self):
+        return {
+                "currency": self.currency,
+                "value": round(self).value.normalize(),
+                }
+
+    def __round__(self, n=8):
+        return Amount(self.currency, self.value.quantize(D(1)/D(10**n), rounding=ROUND_DOWN))
 
     def __abs__(self):
-        return Amount(self.currency, 0, int_val=abs(self._value))
+        return Amount(self.currency, abs(self.value))
 
     def __add__(self, other):
-        if other.currency != self.currency and other._value * self._value != 0:
+        if other == 0:
+            return self
+        if other.currency != self.currency and other.value * self.value != 0:
             raise Exception("Summing amounts must be done with same currencies")
-        return Amount(self.currency, 0, int_val=self._value + other._value)
+        return Amount(self.currency, self.value + other.value)
 
     def __radd__(self, other):
         if other == 0:
@@ -163,40 +80,62 @@ class Amount:
             return self.__add__(other)
 
     def __sub__(self, other):
-        if other.currency != self.currency and other._value * self._value != 0:
+        if other == 0:
+            return self
+        if other.currency != self.currency and other.value * self.value != 0:
             raise Exception("Summing amounts must be done with same currencies")
-        return Amount(self.currency, 0, int_val=self._value - other._value)
+        return Amount(self.currency, self.value - other.value)
 
-    def __int__(self):
-        return self._value
+    def __rsub__(self, other):
+        if other == 0:
+            return -self
+        else:
+            return -self.__sub__(other)
 
     def __mul__(self, value):
-        if type(value) != int and type(value) != float:
+        if not isinstance(value, (int, float, D)):
             raise TypeError("Amount may only be multiplied by numbers")
-        return Amount(self.currency, 0, int_val=(self._value * value))
+        return Amount(self.currency, self.value * value)
 
     def __rmul__(self, value):
         return self.__mul__(value)
 
     def __floordiv__(self, value):
-        if type(value) != int:
-            raise TypeError("Amount may only be multiplied by integers")
-        return Amount(self.currency, 0, int_val=(self._value // value))
+        if not isinstance(value, (int, float, D)):
+            raise TypeError("Amount may only be divided by numbers")
+        return Amount(self.currency, self.value / value)
 
     def __truediv__(self, value):
         return self.__floordiv__(value)
 
     def __lt__(self, other):
+        if other == 0:
+            return self.value < 0
         if self.currency != other.currency:
             raise Exception("Comparing amounts must be done with same currencies")
-        return self._value < other._value
+        return self.value < other.value
+
+    def __le__(self, other):
+        return self == other or self < other
+
+    def __gt__(self, other):
+        return not self <= other
+
+    def __ge__(self, other):
+        return not self < other
 
     def __eq__(self, other):
         if other == 0:
-            return self._value == 0
+            return self.value == 0
         if self.currency != other.currency:
             raise Exception("Comparing amounts must be done with same currencies")
-        return self._value == other._value
+        return self.value == other.value
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __neg__(self):
+        return Amount(self.currency, - self.value)
 
     def __str__(self):
         if self.linked_to is None:
@@ -211,98 +150,84 @@ class Amount:
             return "Amount({:.8f} {} -> {})".format(self.value, self.currency, repr(self.linked_to))
 
 class Balance:
-    known_balances = {}
-    trades = {}
+    base_keys = ["total", "exchange_total", "exchange_used",
+            "exchange_free", "margin_total", "margin_in_position",
+            "margin_available", "margin_borrowed", "margin_pending_gain"]
 
-    def __init__(self, currency, total_value, free_value, used_value):
+    def __init__(self, currency, hash_):
         self.currency = currency
-        self.total = Amount(currency, total_value)
-        self.free = Amount(currency, free_value)
-        self.used = Amount(currency, used_value)
+        for key in self.base_keys:
+            setattr(self, key, Amount(currency, hash_.get(key, 0)))
 
-    @classmethod
-    def from_hash(cls, currency, hash_):
-        return cls(currency, hash_["total"], hash_["free"], hash_["used"])
+        self.margin_position_type = hash_.get("margin_position_type")
 
-    @classmethod
-    def in_currency(cls, other_currency, market, action="average", type="total"):
-        amounts = {}
-        for currency in cls.known_balances:
-            balance = cls.known_balances[currency]
-            other_currency_amount = getattr(balance, type)\
-                    .in_currency(other_currency, market, action=action)
-            amounts[currency] = other_currency_amount
-        return amounts
+        if hash_.get("margin_borrowed_base_currency") is not None:
+            base_currency = hash_["margin_borrowed_base_currency"]
+            for key in [
+                    "margin_liquidation_price",
+                    "margin_lending_fees",
+                    "margin_pending_base_gain",
+                    "margin_borrowed_base_price"
+                    ]:
+                setattr(self, key, Amount(base_currency, hash_.get(key, 0)))
 
-    @classmethod
-    def currencies(cls):
-        return cls.known_balances.keys()
+    def as_json(self):
+        return dict(map(lambda x: (x, getattr(self, x).as_json()["value"]), self.base_keys))
 
-    @classmethod
-    def _fill_balances(cls, hash_):
-        for key in hash_:
-            if key in ["info", "free", "used", "total"]:
-                continue
-            if hash_[key]["total"] > 0:
-                cls.known_balances[key] = cls.from_hash(key, hash_[key])
-
-    @classmethod
-    def fetch_balances(cls, market):
-        cls._fill_balances(market.fetch_balance())
-        return cls.known_balances
-
-    @classmethod
-    def dispatch_assets(cls, amount):
-        repartition_pertenthousand = Portfolio.repartition_pertenthousand()
-        sum_pertenthousand = sum([v for k, v in repartition_pertenthousand.items()])
-        amounts = {}
-        for currency, ptt in repartition_pertenthousand.items():
-            amounts[currency] = ptt * amount / sum_pertenthousand
-            if currency not in cls.known_balances:
-                cls.known_balances[currency] = cls(currency, 0, 0, 0)
-        return amounts
+    def __repr__(self):
+        if self.exchange_total > 0:
+            if self.exchange_free > 0 and self.exchange_used > 0:
+                exchange = " Exch: [✔{} + ❌{} = {}]".format(str(self.exchange_free), str(self.exchange_used), str(self.exchange_total))
+            elif self.exchange_free > 0:
+                exchange = " Exch: [✔{}]".format(str(self.exchange_free))
+            else:
+                exchange = " Exch: [❌{}]".format(str(self.exchange_used))
+        else:
+            exchange = ""
+
+        if self.margin_total > 0:
+            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: [❌{}]".format(str(self.margin_in_position))
+        elif self.margin_total < 0:
+            margin = " Margin: [{} @@ {}/{}]".format(str(self.margin_total),
+                    str(self.margin_borrowed_base_price),
+                    str(self.margin_lending_fees))
+        else:
+            margin = ""
 
-    @classmethod
-    def prepare_trades(cls, market, base_currency="BTC"):
-        cls.fetch_balances(market)
-        values_in_base = cls.in_currency(base_currency, market)
-        total_base_value = sum(values_in_base.values())
-        new_repartition = cls.dispatch_assets(total_base_value)
-        Trade.compute_trades(values_in_base, new_repartition, market=market)
+        if self.margin_total != 0 and self.exchange_total != 0:
+            total = " Total: [{}]".format(str(self.total))
+        else:
+            total = ""
 
-    def __repr__(self):
-        return "Balance({} [{}/{}/{}])".format(self.currency, str(self.free), str(self.used), str(self.total))
+        return "Balance({}".format(self.currency) + "".join([exchange, margin, total]) + ")"
 
 class Trade:
-    trades = {}
-
-    def __init__(self, value_from, value_to, currency, market=None):
+    def __init__(self, value_from, value_to, currency, market):
         # We have value_from of currency, and want to finish with value_to of
         # that currency. value_* may not be in currency's terms
         self.currency = currency
         self.value_from = value_from
         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
-        assert self.value_from.linked_to is not None and self.value_from.linked_to.currency == self.currency
+        if self.value_from != 0:
+            assert self.value_from.linked_to is not None and self.value_from.linked_to.currency == self.currency
+        elif self.value_from.linked_to is None:
+            self.value_from.linked_to = Amount(self.currency, 0)
         self.base_currency = self.value_from.currency
 
-        if market is not None:
-            self.prepare_order(market)
-
-    @classmethod
-    def compute_trades(cls, values_in_base, new_repartition, market=None):
-        base_currency = sum(values_in_base.values()).currency
-        for currency in Balance.currencies():
-            if currency == base_currency:
-                continue
-            cls.trades[currency] = cls(
-                values_in_base.get(currency, Amount(base_currency, 0)), 
-                new_repartition.get(currency, Amount(base_currency, 0)),
-                currency,
-                market=market
-                )
-        return cls.trades
+    @property
+    def delta(self):
+        return self.value_to - self.value_from
 
     @property
     def action(self):
@@ -311,123 +236,485 @@ class Trade:
         if self.base_currency == self.currency:
             return None
 
-        if self.value_from < self.value_to:
+        if abs(self.value_from) < abs(self.value_to):
+            return "acquire"
+        else:
+            return "dispose"
+
+    def order_action(self):
+        if (self.value_from < self.value_to) != self.inverted:
             return "buy"
         else:
             return "sell"
 
-    def ticker_action(self, inverted):
-        if self.value_from < self.value_to:
-            return "ask" if not inverted else "bid"
+    @property
+    def trade_type(self):
+        if self.value_from + self.value_to < 0:
+            return "short"
         else:
-            return "bid" if not inverted else "ask"
+            return "long"
 
-    def prepare_order(self, market):
-        if self.action is None:
-            return
-        ticker = self.value_from.ticker
-        inverted = ticker["inverted"]
-
-        if not inverted:
-            value_from = self.value_from.linked_to
-            value_to = self.value_to.in_currency(self.currency, market)
-            delta = abs(value_to - value_from)
-            currency = self.base_currency
+    @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), refetch=True)) >= abs(self.delta)
+
+    def filled_amount(self, in_base_currency=False, refetch=False):
+        filled_amount = 0
+        for order in self.orders:
+            filled_amount += order.filled_amount(in_base_currency=in_base_currency, refetch=refetch)
+        return filled_amount
+
+    tick_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"],
+            }
+
+    def tick_actions_recreate(self, tick, default="average"):
+        return ([default] + \
+                [ y[1] for x, y in self.tick_actions.items() if x <= tick and y[1] is not None ])[-1]
+
+    def update_order(self, order, tick):
+        if tick in self.tick_actions:
+            update, compute_value = self.tick_actions[tick]
+        elif tick % 3 == 1:
+            if tick < 20:
+                update = "market_adjust"
+                compute_value = "default"
+            else:
+                update = "market_adjust_eat"
+                compute_value = Computation.eat_several(self.market)
         else:
-            ticker = ticker["notInverted"]
-            delta = abs(self.value_to - self.value_from)
-            currency = self.currency
+            update = "waiting"
+            compute_value = None
 
-        rate = ticker[self.ticker_action(inverted)]
+        if compute_value is not None:
+            order.cancel()
+            new_order = self.prepare_order(compute_value=compute_value)
+        else:
+            new_order = None
 
-        self.orders.append(Order(self.ticker_action(inverted), delta, rate, currency))
+        self.market.report.log_order(order, tick, update=update,
+                compute_value=compute_value, new_order=new_order)
 
-    @classmethod
-    def all_orders(cls):
-        return sum(map(lambda v: v.orders, cls.trades.values()), [])
+        if new_order is not None:
+            new_order.run()
+            self.market.report.log_order(order, tick, new_order=new_order)
 
-    @classmethod
-    def follow_orders(cls, market):
-        orders = cls.all_orders()
-        finished_orders = []
-        while len(orders) != len(finished_orders):
-            time.sleep(30)
-            for order in orders:
-                if order in finished_orders:
-                    continue
-                if order.get_status(market) != "open":
-                    finished_orders.append(order)
-                    print("finished {}".format(order))
-        print("All orders finished")
+    def prepare_order(self, close_if_possible=None, compute_value="default"):
+        if self.action is None:
+            return None
+        ticker = self.market.get_ticker(self.currency, self.base_currency)
+        if ticker is None:
+            self.market.report.log_error("prepare_order",
+                    message="Unknown ticker {}/{}".format(self.currency, self.base_currency))
+            return None
+        self.inverted = ticker["inverted"]
+        if self.inverted:
+            ticker = ticker["original"]
+        rate = Computation.compute_value(ticker, self.order_action(), compute_value=compute_value)
+
+        delta_in_base = abs(self.delta)
+        # 9 BTC's worth of move (10 - 1 or 1 - 10 depending on case)
+
+        if not self.inverted:
+            base_currency = self.base_currency
+            # BTC
+            if self.action == "dispose":
+                filled = self.filled_amount(in_base_currency=False)
+                delta = delta_in_base.in_currency(self.currency, self.market, rate=1/self.value_from.rate)
+                # I have 10 BTC worth of FOO, and I want to sell 9 BTC
+                # worth of it, computed first with rate 10 FOO = 1 BTC.
+                # -> I "sell" "90" FOO at proposed rate "rate".
+
+                delta = delta - filled
+                # I already sold 60 FOO, 30 left
+            else:
+                filled = self.filled_amount(in_base_currency=True)
+                delta = (delta_in_base - filled).in_currency(self.currency, self.market, rate=1/rate)
+                # I want to buy 9 BTC worth of FOO, computed with rate
+                # 10 FOO = 1 BTC
+                # -> I "buy" "9 / rate" FOO at proposed rate "rate"
+
+                # I already bought 3 / rate FOO, 6 / rate left
+        else:
+            base_currency = self.currency
+            # FOO
+            if self.action == "dispose":
+                filled = self.filled_amount(in_base_currency=True)
+                # Base is FOO
+
+                delta = (delta_in_base.in_currency(self.currency, self.market, rate=1/self.value_from.rate)
+                        - filled).in_currency(self.base_currency, self.market, rate=1/rate)
+                # I have 10 BTC worth of FOO, and I want to sell 9 BTC worth of it
+                # computed at rate 1 Foo = 0.01 BTC
+                # Computation says I should sell it at 125 FOO / BTC
+                # -> delta_in_base = 9 BTC
+                # -> delta = (9 * 1/0.01 FOO) * 1/125 = 7.2 BTC
+                # Action: "buy" "7.2 BTC" at rate "125" "FOO" on market
+
+                # I already bought 300/125 BTC, only 600/125 left
+            else:
+                filled = self.filled_amount(in_base_currency=False)
+                # Base is FOO
+
+                delta = delta_in_base
+                # I have 1 BTC worth of FOO, and I want to buy 9 BTC worth of it
+                # At rate 100 Foo / BTC
+                # Computation says I should buy it at 125 FOO / BTC
+                # -> delta_in_base = 9 BTC
+                # Action: "sell" "9 BTC" at rate "125" "FOO" on market
+
+                delta = delta - filled
+                # I already sold 4 BTC, only 5 left
+
+        if close_if_possible is None:
+            close_if_possible = (self.value_to == 0)
+
+        if delta <= 0:
+            self.market.report.log_error("prepare_order", message="Less to do than already filled: {}".format(delta))
+            return None
+
+        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)
+        return order
+
+    def as_json(self):
+        return {
+                "action": self.action,
+                "from": self.value_from.as_json()["value"],
+                "to": self.value_to.as_json()["value"],
+                "currency": self.currency,
+                "base_currency": self.base_currency,
+                }
 
     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)
 
-class Order:
-    DEBUG = True
+    def print_with_order(self, ind=""):
+        self.market.report.print_log("{}{}".format(ind, self))
+        for order in self.orders:
+            self.market.report.print_log("{}\t{}".format(ind, order))
+            for mouvement in order.mouvements:
+                self.market.report.print_log("{}\t\t{}".format(ind, mouvement))
 
-    def __init__(self, action, amount, rate, base_currency):
+class RetryException(Exception):
+    pass
+
+class Order:
+    def __init__(self, action, amount, rate, base_currency, trade_type, market,
+            trade, close_if_possible=False):
         self.action = action
         self.amount = amount
         self.rate = rate
         self.base_currency = base_currency
-        self.result = None
-        self.status = "not run"
+        self.market = market
+        self.trade_type = trade_type
+        self.results = []
+        self.mouvements = []
+        self.status = "pending"
+        self.trade = trade
+        self.close_if_possible = close_if_possible
+        self.id = None
+        self.tries = 0
+        self.start_date = None
+
+    def as_json(self):
+        return {
+                "action": self.action,
+                "trade_type": self.trade_type,
+                "amount": self.amount.as_json()["value"],
+                "currency": self.amount.as_json()["currency"],
+                "base_currency": self.base_currency,
+                "rate": self.rate,
+                "status": self.status,
+                "close_if_possible": self.close_if_possible,
+                "id": self.id,
+                "mouvements": list(map(lambda x: x.as_json(), self.mouvements))
+                }
 
     def __repr__(self):
-        return "Order({} {} at {} {} [{}])".format(
+        return "Order({} {} {} at {} {} [{}]{})".format(
                 self.action,
+                self.trade_type,
                 self.amount,
                 self.rate,
                 self.base_currency,
-                self.status
+                self.status,
+                " ✂" if self.close_if_possible else "",
                 )
 
-    def run(self, market):
+    @property
+    def account(self):
+        if self.trade_type == "long":
+            return "exchange"
+        else:
+            return "margin"
+
+    @property
+    def open(self):
+        return self.status == "open"
+
+    @property
+    def pending(self):
+        return self.status == "pending"
+
+    @property
+    def finished(self):
+        return self.status.startswith("closed") or self.status == "canceled" or self.status == "error"
+
+    @retry((InsufficientFunds, RetryException, InvalidNonce))
+    def run(self):
+        self.tries += 1
         symbol = "{}/{}".format(self.amount.currency, self.base_currency)
-        amount = self.amount.value
+        amount = round(self.amount, self.market.ccxt.order_precision(symbol)).value
 
-        if self.DEBUG:
-            print("market.create_order('{}', 'limit', '{}', {}, price={})".format(
-                symbol, self.action, amount, self.rate))
+        action = "market.ccxt.create_order('{}', 'limit', '{}', {}, price={}, account={})".format(symbol, self.action, amount, self.rate, self.account)
+        if self.market.debug:
+            self.market.report.log_debug_action(action)
+            self.results.append({"debug": True, "id": -1})
         else:
+            self.start_date = datetime.datetime.now()
             try:
-                self.result = market.create_order(symbol, 'limit', self.action, amount, price=self.rate)
-                self.status = "open"
-            except Exception:
-                pass
-
-    def get_status(self, market):
+                self.results.append(self.market.ccxt.create_order(symbol, 'limit', self.action, amount, price=self.rate, account=self.account))
+            except InvalidOrder:
+                # Impossible to honor the order (dust amount)
+                self.status = "closed"
+                self.mark_finished_order()
+                return
+            except InvalidNonce as e:
+                if self.tries < 5:
+                    self.market.report.log_error(action, message="Retrying after invalid nonce", exception=e)
+                    raise e
+                else:
+                    self.market.report.log_error(action, message="Giving up {} after invalid nonce".format(self), exception=e)
+                    self.status = "error"
+                    return
+            except RequestTimeout as e:
+                if not self.retrieve_order():
+                    if self.tries < 5:
+                        self.market.report.log_error(action, message="Retrying after timeout", exception=e)
+                        # We make a specific call in case retrieve_order
+                        # would raise itself
+                        raise RetryException
+                    else:
+                        self.market.report.log_error(action, message="Giving up {} after timeouts".format(self), exception=e)
+                        self.status = "error"
+                        return
+                else:
+                    self.market.report.log_error(action, message="Timeout, found the order")
+            except InsufficientFunds as e:
+                if self.tries < 5:
+                    self.market.report.log_error(action, message="Retrying with reduced amount", exception=e)
+                    self.amount = self.amount * D("0.99")
+                    raise e
+                else:
+                    self.market.report.log_error(action, message="Giving up {}".format(self), exception=e)
+                    self.status = "error"
+                    return
+            except Exception as e:
+                self.status = "error"
+                self.market.report.log_error(action, exception=e)
+                return
+        self.id = self.results[0]["id"]
+        self.status = "open"
+
+    def get_status(self):
+        if self.market.debug:
+            self.market.report.log_debug_action("Getting {} status".format(self))
+            return self.status
         # other states are "closed" and "canceled"
-        if self.status == "open":
-            result = market.fetch_order(self.result['id'])
-            self.status = result["status"]
+        if not self.finished:
+            self.fetch()
         return self.status
 
-@static_var("cache", {})
-def fetch_fees(market):
-    if market.__class__ not in fetch_fees.cache:
-        fetch_fees.cache[market.__class__] = market.fetch_fees()
-    return fetch_fees.cache[market.__class__]
-
-def print_orders(market, base_currency="BTC"):
-    Balance.prepare_trades(market, base_currency=base_currency)
-    for currency, trade in Trade.trades.items():
-        print(trade)
-        for order in trade.orders:
-            print("\t", order, sep="")
-
-def make_orders(market, base_currency="BTC"):
-    Balance.prepare_trades(market, base_currency=base_currency)
-    for currency, trade in Trade.trades.items():
-        print(trade)
-        for order in trade.orders:
-            print("\t", order, sep="")
-            order.run(market)
-
-if __name__ == '__main__':
-    print_orders(market)
+    def mark_disappeared_order(self):
+        if self.status.startswith("closed") and \
+                len(self.mouvements) > 0 and \
+                self.mouvements[-1].total_in_base == 0:
+            self.status = "error_disappeared"
+
+    def mark_finished_order(self):
+        if self.status.startswith("closed") and self.market.debug:
+            self.market.report.log_debug_action("Mark {} as finished".format(self))
+            return
+        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):
+        if self.market.debug:
+            self.market.report.log_debug_action("Fetching {}".format(self))
+            return
+        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.fetch_mouvements()
+
+        self.mark_disappeared_order()
+        self.mark_dust_amount_remaining_order()
+        self.mark_finished_order()
+
+    def mark_dust_amount_remaining_order(self):
+        if self.status == "open" and self.market.ccxt.is_dust_trade(self.remaining_amount().value, self.rate):
+            self.status = "closed_dust_remaining"
+
+    def remaining_amount(self, refetch=False):
+        return self.amount - self.filled_amount(refetch=refetch)
+
+    def filled_amount(self, in_base_currency=False, refetch=False):
+        if refetch and self.status == "open":
+            self.fetch()
+        filled_amount = 0
+        for mouvement in self.mouvements:
+            if in_base_currency:
+                filled_amount += mouvement.total_in_base
+            else:
+                filled_amount += mouvement.total
+        return filled_amount
+
+    def fetch_mouvements(self):
+        try:
+            mouvements = self.market.ccxt.privatePostReturnOrderTrades({"orderNumber": self.id})
+        except ExchangeError:
+            mouvements = []
+        self.mouvements = []
+
+        for mouvement_hash in mouvements:
+            self.mouvements.append(Mouvement(self.amount.currency,
+                self.base_currency, mouvement_hash))
+        self.mouvements.sort(key= lambda x: x.date)
+
+    def cancel(self):
+        if self.market.debug:
+            self.market.report.log_debug_action("Mark {} as cancelled".format(self))
+            self.status = "canceled"
+            return
+        if (self.status == "closed_dust_remaining" or 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()
+
+    def retrieve_order(self):
+        symbol = "{}/{}".format(self.amount.currency, self.base_currency)
+        amount = round(self.amount, self.market.ccxt.order_precision(symbol)).value
+        start_timestamp = self.start_date.timestamp() - 5
+
+        similar_open_orders = self.market.ccxt.fetch_orders(symbol=symbol, since=start_timestamp)
+        for order in similar_open_orders:
+            if (order["info"]["margin"] == 1 and self.account == "exchange") or\
+                    (order["info"]["margin"] != 1 and self.account == "margin"):
+                i_m_tested = True # coverage bug ?!
+                continue
+            if order["info"]["side"] != self.action:
+                continue
+            amount_diff = round(
+                    abs(D(order["info"]["startingAmount"]) - amount),
+                    self.market.ccxt.order_precision(symbol))
+            rate_diff = round(
+                    abs(D(order["info"]["rate"]) - self.rate),
+                    self.market.ccxt.order_precision(symbol))
+            if amount_diff != 0 or rate_diff != 0:
+                continue
+            self.results.append({"id": order["id"]})
+            return True
+
+        similar_trades = self.market.ccxt.fetch_my_trades(symbol=symbol, since=start_timestamp)
+        for order_id in sorted(list(map(lambda x: x["order"], similar_trades))):
+            trades = list(filter(lambda x: x["order"] == order_id, similar_trades))
+            if any(x["timestamp"] < start_timestamp for x in trades):
+                continue
+            if any(x["side"] != self.action for x in trades):
+                continue
+            if any(x["info"]["category"] == "exchange" and self.account == "margin" for x in trades) or\
+                    any(x["info"]["category"] == "marginTrade" and self.account == "exchange" for x in trades):
+                continue
+            trade_sum = sum(D(x["info"]["amount"]) for x in trades)
+            amount_diff = round(abs(trade_sum - amount),
+                    self.market.ccxt.order_precision(symbol))
+            if amount_diff != 0:
+                continue
+            if (self.action == "sell" and any(D(x["info"]["rate"]) < self.rate for x in trades)) or\
+                    (self.action == "buy" and any(D(x["info"]["rate"]) > self.rate for x in trades)):
+                continue
+            self.results.append({"id": order_id})
+            return True
+
+        return False
+
+class Mouvement:
+    def __init__(self, currency, base_currency, hash_):
+        self.currency = currency
+        self.base_currency = base_currency
+        self.id = hash_.get("tradeID")
+        self.action = hash_.get("type")
+        self.fee_rate = D(hash_.get("fee", -1))
+        try:
+            self.date = datetime.datetime.strptime(hash_.get("date", ""), '%Y-%m-%d %H:%M:%S')
+        except ValueError:
+            self.date = None
+        self.rate = D(hash_.get("rate", 0))
+        self.total = Amount(currency, hash_.get("amount", 0))
+        # rate * total = total_in_base
+        self.total_in_base = Amount(base_currency, hash_.get("total", 0))
+
+    def as_json(self):
+        return {
+                "fee_rate": self.fee_rate,
+                "date": self.date,
+                "action": self.action,
+                "total": self.total.value,
+                "currency": self.currency,
+                "total_in_base": self.total_in_base.value,
+                "base_currency": self.base_currency
+                }
+
+    def __repr__(self):
+        if self.fee_rate > 0:
+            fee_rate = " fee: {}%".format(self.fee_rate * 100)
+        else:
+            fee_rate = ""
+        if self.date is None:
+            date = "No date"
+        else:
+            date = self.date
+        return "Mouvement({} ; {} {} ({}){})".format(
+                date, self.action, self.total, self.total_in_base,
+                fee_rate)
+