X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=portfolio.py;h=e98689ee4c2599fc63f77b6236057e9df0b2519e;hb=5a72ded790f8b5e7c9b38a3cc91c12fbfb6cb97a;hp=b0f9256e5222ee75a3e43c09ad5b7f5d8fe2c720;hpb=089d5d9df3d9d93e3ce789be16ee6cdd99dc2b52;p=perso%2FImmae%2FProjets%2FCryptomonnaies%2FCryptoportfolio%2FTrader.git

diff --git a/portfolio.py b/portfolio.py
index b0f9256..e98689e 100644
--- a/portfolio.py
+++ b/portfolio.py
@@ -1,17 +1,13 @@
-import ccxt
 import time
+from datetime import datetime
+from decimal import Decimal as D, ROUND_DOWN
 # Put your poloniex api key in market.py
-from market import market
+from json import JSONDecodeError
+import requests
+import helper as h
+from store import *
 
-# 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"
@@ -19,26 +15,21 @@ class Portfolio:
     data = None
 
     @classmethod
-    def repartition_pertenthousand(cls, liquidity="medium"):
+    def repartition(cls, liquidity="medium"):
         cls.parse_cryptoportfolio()
         liquidities = cls.liquidities[liquidity]
-        last_date = sorted(liquidities.keys())[-1]
-        return liquidities[last_date]
+        cls.last_date = sorted(liquidities.keys())[-1]
+        return liquidities[cls.last_date]
 
     @classmethod
     def get_cryptoportfolio(cls):
-        import json
-        import urllib3
-        urllib3.disable_warnings()
-        http = urllib3.PoolManager()
-
         try:
-            r = http.request("GET", cls.URL)
+            r = requests.get(cls.URL)
         except Exception:
             return
         try:
-            cls.data = json.loads(r.data)
-        except json.JSONDecodeError:
+            cls.data = r.json(parse_int=D, parse_float=D)
+        except JSONDecodeError:
             cls.data = None
 
     @classmethod
@@ -47,7 +38,7 @@ class Portfolio:
             cls.get_cryptoportfolio()
 
         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,15 +46,13 @@ 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"])):
@@ -80,46 +69,63 @@ class Portfolio:
                 "high":   high_liquidity,
                 }
 
-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"],
+            }
 
-    def __init__(self, currency, value, int_val=None, linked_to=None, ticker=None):
+    @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)
+
+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 = h.get_ticker(self.currency, other_currency, market)
         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 __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.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 +134,56 @@ 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)
-
-    def __int__(self):
-        return self._value
+        return Amount(self.currency, self.value - other.value)
 
     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,70 +198,59 @@ class Amount:
             return "Amount({:.8f} {} -> {})".format(self.value, self.currency, repr(self.linked_to))
 
 class Balance:
-    known_balances = {}
 
-    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"])
-
-    @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
-
-    @classmethod
-    def currencies(cls):
-        return cls.known_balances.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])
+        for key in ["total",
+                "exchange_total", "exchange_used", "exchange_free",
+                "margin_total", "margin_borrowed", "margin_free"]:
+            setattr(self, key, Amount(currency, hash_.get(key, 0)))
+
+        self.margin_position_type = hash_.get("margin_position_type")
+
+        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 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):
         # We have value_from of currency, and want to finish with value_to of
         # that currency. value_* may not be in currency's terms
@@ -249,67 +260,12 @@ class Trade:
         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
 
-    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
-                )
-            cls.trades[currency].prepare_order()
-        return cls.trades
-
     @property
     def action(self):
         if self.value_from == self.value_to:
@@ -317,54 +273,125 @@ 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):
+    @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]:
+            print("{}, tick {}, waiting".format(order, tick))
+        elif tick == 2:
+            new_order = self.prepare_order(compute_value=lambda x, y: (x[y] + x["average"]) / 2)
+            print("{}, tick {}, cancelling and adjusting to {}".format(order, tick, new_order))
+        elif tick ==5:
+            new_order = self.prepare_order(compute_value=lambda x, y: (x[y]*2 + x["average"]) / 3)
+            print("{}, tick {}, cancelling and adjusting to {}".format(order, tick, new_order))
+        elif tick >= 7:
+            if tick == 7:
+                print("{}, tick {}, fallbacking to market value".format(order, tick))
+            if (tick - 7) % 3 == 0:
+                new_order = self.prepare_order(compute_value="default")
+                print("{}, tick {}, market value, cancelling and adjusting to {}".format(order, tick, new_order))
+
+        if new_order is not None:
+            order.cancel()
+            new_order.run()
+
+    def prepare_order(self, compute_value="default"):
         if self.action is None:
-            return
-        ticker = self.value_from.ticker
+            return None
+        ticker = h.get_ticker(self.currency, self.base_currency, self.market)
         inverted = ticker["inverted"]
-
-        if not inverted:
-            value_from = self.value_from.linked_to
-            value_to = self.value_to.in_currency(self.currency, self.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 = Computation.compute_value(ticker, self.order_action(inverted), compute_value=compute_value)
 
-        rate = ticker[self.order_action(inverted)]
+        delta_in_base = abs(self.value_from - self.value_to)
+        # 9 BTC's worth of move (10 - 1 or 1 - 10 depending on case)
 
-        self.orders.append(Order(self.order_action(inverted), delta, rate, currency))
-
-    @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
+
+        close_if_possible = (self.value_to == 0)
+
+        if delta <= 0:
+            print("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 __repr__(self):
         return "Trade({} -> {} in {}, {})".format(
@@ -373,61 +400,159 @@ class Trade:
                 self.currency,
                 self.action)
 
-class Order:
-    DEBUG = True
+    def print_with_order(self):
+        print(self)
+        for order in self.orders:
+            print("\t", order, sep="")
 
-    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
 
     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"
+
+    def run(self):
         symbol = "{}/{}".format(self.amount.currency, self.base_currency)
-        amount = self.amount.value
+        amount = round(self.amount, self.market.order_precision(symbol)).value
 
-        if self.DEBUG:
-            print("market.create_order('{}', 'limit', '{}', {}, price={})".format(
-                symbol, self.action, amount, self.rate))
+        if TradeStore.debug:
+            print("market.create_order('{}', 'limit', '{}', {}, price={}, account={})".format(
+                symbol, self.action, amount, self.rate, self.account))
+            self.results.append({"debug": True, "id": -1})
         else:
             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.create_order(symbol, 'limit', self.action, amount, price=self.rate, account=self.account))
+            except Exception as e:
+                self.status = "error"
+                print("error when running market.create_order('{}', 'limit', '{}', {}, price={}, account={})".format(
+                    symbol, self.action, amount, self.rate, self.account))
+                self.error_message = str("{}: {}".format(e.__class__.__name__, e))
+                print(self.error_message)
+                return
+        self.id = self.results[0]["id"]
+        self.status = "open"
+
+    def get_status(self):
+        if TradeStore.debug:
+            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 mark_finished_order(self):
+        if TradeStore.debug:
+            return
+        if self.status == "closed":
+            if self.trade_type == "short" and self.action == "buy" and self.close_if_possible:
+                self.market.close_margin_position(self.amount.currency, self.base_currency)
 
-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)
+    def fetch(self, force=False):
+        if TradeStore.debug or (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.fetch_order(self.id)
+        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):
+        mouvements = self.market.privatePostReturnOrderTrades({"orderNumber": self.id})
+        self.mouvements = []
+
+        for mouvement_hash in mouvements:
+            self.mouvements.append(Mouvement(self.amount.currency,
+                self.base_currency, mouvement_hash))
+
+    def cancel(self):
+        if TradeStore.debug:
+            self.status = "canceled"
+            return
+        self.market.cancel_order(self.id)
+        self.fetch()
 
-if __name__ == '__main__':
-    print_orders(market)
+class Mouvement:
+    def __init__(self, currency, base_currency, hash_):
+        self.currency = currency
+        self.base_currency = base_currency
+        self.id = hash_["id"]
+        self.action = hash_["type"]
+        self.fee_rate = D(hash_["fee"])
+        self.date = datetime.strptime(hash_["date"], '%Y-%m-%d %H:%M:%S')
+        self.rate = D(hash_["rate"])
+        self.total = Amount(currency, hash_["amount"])
+        # rate * total = total_in_base
+        self.total_in_base = Amount(base_currency, hash_["total"])
+
+if __name__ == '__main__': # pragma: no cover
+    from market import market
+    h.print_orders(market)