X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=portfolio.py;h=eb3390ed70d2c156f90002afa994e91a14ddf651;hb=2033e7fef780298be2ec15455a0ec1d26515de55;hp=576a2286847abacabe7525161bf9e11be4170e91;hpb=cfab619d9223fc824649a6fe16863931f5e43891;p=perso%2FImmae%2FProjets%2FCryptomonnaies%2FCryptoportfolio%2FTrader.git

diff --git a/portfolio.py b/portfolio.py
index 576a228..eb3390e 100644
--- a/portfolio.py
+++ b/portfolio.py
@@ -1,53 +1,55 @@
-import ccxt
 import time
-# Put your poloniex api key in market.py
-from market import market
+from datetime import datetime, timedelta
+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 retry import retry
+import requests
 
-# 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
+# FIXME: correctly handle web call timeouts
 
 class Portfolio:
     URL = "https://cryptoportfolio.io/wp-content/uploads/portfolio/json/cryptoportfolio.json"
     liquidities = {}
     data = None
+    last_date = None
 
     @classmethod
-    def repartition_pertenthousand(cls, liquidity="medium"):
-        cls.parse_cryptoportfolio()
-        liquidities = cls.liquidities[liquidity]
-        last_date = sorted(liquidities.keys())[-1]
-        return liquidities[last_date]
+    def wait_for_recent(cls, market, delta=4):
+        cls.repartition(market, refetch=True)
+        while cls.last_date is None or datetime.now() - cls.last_date > timedelta(delta):
+            time.sleep(30)
+            market.report.print_log("Attempt to fetch up-to-date cryptoportfolio")
+            cls.repartition(market, refetch=True)
 
     @classmethod
-    def get_cryptoportfolio(cls):
-        import json
-        import urllib3
-        urllib3.disable_warnings()
-        http = urllib3.PoolManager()
+    def repartition(cls, market, liquidity="medium", refetch=False):
+        cls.parse_cryptoportfolio(market, refetch=refetch)
+        liquidities = cls.liquidities[liquidity]
+        return liquidities[cls.last_date]
 
+    @classmethod
+    def get_cryptoportfolio(cls, market):
         try:
-            r = http.request("GET", cls.URL)
-        except Exception:
+            r = requests.get(cls.URL)
+            market.report.log_http_request(r.request.method,
+                    r.request.url, r.request.body, r.request.headers, r)
+        except Exception as e:
+            market.report.log_error("get_cryptoportfolio", exception=e)
             return
         try:
-            cls.data = json.loads(r.data)
-        except json.JSONDecodeError:
+            cls.data = r.json(parse_int=D, parse_float=D)
+        except (JSONDecodeError, SimpleJSONDecodeError):
             cls.data = None
 
     @classmethod
-    def parse_cryptoportfolio(cls):
-        if cls.data is None:
-            cls.get_cryptoportfolio()
+    def parse_cryptoportfolio(cls, market, refetch=False):
+        if refetch or cls.data is None:
+            cls.get_cryptoportfolio(market)
 
         def filter_weights(weight_hash):
-            if weight_hash[1] == 0:
+            if weight_hash[1][0] == 0:
                 return False
             if weight_hash[0] == "_row":
                 return False
@@ -55,19 +57,18 @@ class Portfolio:
 
         def clean_weights(i):
             def clean_weights_(h):
-                if type(h[1][i]) == str:
-                    return [h[0], h[1][i]]
+                if h[0].endswith("s"):
+                    return [h[0][0:-1], (h[1][i], "short")]
                 else:
-                    return [h[0], int(h[1][i] * 10000)]
+                    return [h[0], (h[1][i], "long")]
             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(
+                date = datetime.strptime(weights_hash["_row"][i], "%Y-%m-%d")
+                weights[date] = dict(filter(
                         filter_weights,
                         map(clean_weights(i), weights_hash.items())))
             return weights
@@ -79,47 +80,73 @@ class Portfolio:
                 "medium": medium_liquidity,
                 "high":   high_liquidity,
                 }
+        cls.last_date = max(max(medium_liquidity.keys()), max(high_liquidity.keys()))
 
-class Amount:
-    MAX_DIGITS = 18
+class Computation:
+    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 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)
 
-    def __init__(self, currency, value, int_val=None, linked_to=None, ticker=None):
+class Amount:
+    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 = Trade.get_ticker(self.currency, 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 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:
@@ -128,40 +155,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:
@@ -176,142 +225,78 @@ class Amount:
             return "Amount({:.8f} {} -> {})".format(self.value, self.currency, repr(self.linked_to))
 
 class Balance:
-    known_balances = {}
+    base_keys = ["total", "exchange_total", "exchange_used",
+            "exchange_free", "margin_total", "margin_borrowed",
+            "margin_free"]
 
-    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)
-
-    @classmethod
-    def from_hash(cls, currency, hash_):
-        return cls(currency, hash_["total"], hash_["free"], hash_["used"])
+        for key in self.base_keys:
+            setattr(self, key, Amount(currency, hash_.get(key, 0)))
 
-    @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
+        self.margin_position_type = hash_.get("margin_position_type")
 
-    @classmethod
-    def currencies(cls):
-        return cls.known_balances.keys()
+        if hash_.get("margin_borrowed_base_currency") is not None:
+            base_currency = hash_["margin_borrowed_base_currency"]
+            for key in [
+                    "margin_liquidation_price",
+                    "margin_pending_gain",
+                    "margin_lending_fees",
+                    "margin_borrowed_base_price"
+                    ]:
+                setattr(self, key, Amount(base_currency, hash_.get(key, 0)))
 
-    @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])
+    def as_json(self):
+        return dict(map(lambda x: (x, getattr(self, x).as_json()["value"]), self.base_keys))
 
-    @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_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))
+            else:
+                margin = " Margin: [borrowed {}]".format(str(self.margin_borrowed))
+        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
         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.market = market
-            self.prepare_order(market)
-
-    fees_cache = {}
-    @classmethod
-    def fetch_fees(cls, market):
-        if market.__class__ not in cls.fees_cache:
-            cls.fees_cache[market.__class__] = market.fetch_fees()
-        return cls.fees_cache[market.__class__]
-
-    ticker_cache = {}
-    ticker_cache_timestamp = time.time()
-    @classmethod
-    def get_ticker(cls, c1, c2, market, refresh=False):
-        def invert(ticker):
-            return {
-                    "inverted": True,
-                    "average": (float(1/ticker["bid"]) + float(1/ticker["ask"]) ) / 2,
-                    "original": ticker,
-                    }
-        def augment_ticker(ticker):
-            ticker.update({
-                "inverted": False,
-                "average": (ticker["bid"] + ticker["ask"] ) / 2,
-                })
-
-        if time.time() - cls.ticker_cache_timestamp > 5:
-            cls.ticker_cache = {}
-            cls.ticker_cache_timestamp = time.time()
-        elif not refresh:
-            if (c1, c2, market.__class__) in cls.ticker_cache:
-                return cls.ticker_cache[(c1, c2, market.__class__)]
-            if (c2, c1, market.__class__) in cls.ticker_cache:
-                return invert(cls.ticker_cache[(c2, c1, market.__class__)])
-
-        try:
-            cls.ticker_cache[(c1, c2, market.__class__)] = market.fetch_ticker("{}/{}".format(c1, c2))
-            augment_ticker(cls.ticker_cache[(c1, c2, market.__class__)])
-        except ccxt.ExchangeError:
-            try:
-                cls.ticker_cache[(c2, c1, market.__class__)] = market.fetch_ticker("{}/{}".format(c2, c1))
-                augment_ticker(cls.ticker_cache[(c2, c1, market.__class__)])
-            except ccxt.ExchangeError:
-                cls.ticker_cache[(c1, c2, market.__class__)] = None
-        return cls.get_ticker(c1, c2, 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 action(self):
         if self.value_from == self.value_to:
@@ -319,54 +304,149 @@ class Trade:
         if self.base_currency == self.currency:
             return None
 
-        if self.value_from < self.value_to:
-            return "buy"
+        if abs(self.value_from) < abs(self.value_to):
+            return "acquire"
         else:
-            return "sell"
+            return "dispose"
 
     def order_action(self, inverted):
-        if self.value_from < self.value_to:
-            return "ask" if not inverted else "bid"
+        if (self.value_from < self.value_to) != inverted:
+            return "buy"
         else:
-            return "bid" if not inverted else "ask"
+            return "sell"
 
-    def prepare_order(self, market):
+    @property
+    def trade_type(self):
+        if self.value_from + self.value_to < 0:
+            return "short"
+        else:
+            return "long"
+
+    def filled_amount(self, in_base_currency=False):
+        filled_amount = 0
+        for order in self.orders:
+            filled_amount += order.filled_amount(in_base_currency=in_base_currency)
+        return filled_amount
+
+    def update_order(self, order, tick):
+        new_order = None
+        if tick in [0, 1, 3, 4, 6]:
+            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"
+
+        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)
+
+    def prepare_order(self, close_if_possible=None, compute_value="default"):
         if self.action is None:
-            return
-        ticker = self.value_from.ticker
+            return None
+        ticker = self.market.get_ticker(self.currency, self.base_currency)
         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
-        else:
+        if inverted:
             ticker = ticker["original"]
-            delta = abs(self.value_to - self.value_from)
-            currency = self.currency
-
-        rate = ticker[self.order_action(inverted)]
+        rate = Computation.compute_value(ticker, self.order_action(inverted), compute_value=compute_value)
 
-        self.orders.append(Order(self.order_action(inverted), delta, rate, currency))
+        #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)
+        # 9 BTC's worth of move (10 - 1 or 1 - 10 depending on case)
 
-    @classmethod
-    def all_orders(cls):
-        return sum(map(lambda v: v.orders, cls.trades.values()), [])
+        if not 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
 
-    @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")
+        order = Order(self.order_action(inverted),
+            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(
@@ -375,61 +455,223 @@ class Trade:
                 self.currency,
                 self.action)
 
-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 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.fetch_cache_timestamp = None
+        self.tries = 0
+
+    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 == "closed" or self.status == "canceled" or self.status == "error"
+
+    @retry(InsufficientFunds)
+    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))
+        if self.market.debug:
+            self.market.report.log_debug_action("market.ccxt.create_order('{}', 'limit', '{}', {}, price={}, account={})".format(
+                symbol, self.action, amount, self.rate, self.account))
+            self.results.append({"debug": True, "id": -1})
         else:
+            action = "market.ccxt.create_order('{}', 'limit', '{}', {}, price={}, account={})".format(symbol, self.action, amount, self.rate, self.account)
             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 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()
+            if self.finished:
+                self.mark_finished_order()
         return self.status
 
-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_finished_order(self):
+        if self.market.debug:
+            self.market.report.log_debug_action("Mark {} as finished".format(self))
+            return
+        if self.status == "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):
+        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)
+
+        self.status = result["status"]
+        # Time at which the order started
+        self.timestamp = result["datetime"]
+        self.fetch_mouvements()
+
+        # 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):
+        if 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))
+
+    def cancel(self):
+        if self.market.debug:
+            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)
+
+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.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)
+