Merge branch 'develop' into feature/volume-precision-pairlist

freqtrade/exchange/__init__.py

@@ -1,2 +1,3 @@
 from freqtrade.exchange.exchange import Exchange  # noqa: F401
 from freqtrade.exchange.kraken import Kraken  # noqa: F401
+from freqtrade.exchange.binance import Binance  # noqa: F401

freqtrade/exchange/binance.py

@@ -0,0 +1,26 @@
+""" Binance exchange subclass """
+import logging
+from typing import Dict
+
+from freqtrade.exchange import Exchange
+
+logger = logging.getLogger(__name__)
+
+
+class Binance(Exchange):
+
+    _ft_has: Dict = {
+        "stoploss_on_exchange": True,
+    }
+
+    def get_order_book(self, pair: str, limit: int = 100) -> dict:
+        """
+        get order book level 2 from exchange
+
+        20180619: binance support limits but only on specific range
+        """
+        limit_range = [5, 10, 20, 50, 100, 500, 1000]
+        # get next-higher step in the limit_range list
+        limit = min(list(filter(lambda x: limit <= x, limit_range)))
+
+        return super().get_order_book(pair, limit)

freqtrade/exchange/exchange.py

@@ -24,7 +24,7 @@ API_RETRY_COUNT = 4
 # Urls to exchange markets, insert quote and base with .format()
 _EXCHANGE_URLS = {
     ccxt.bittrex.__name__: '/Market/Index?MarketName={quote}-{base}',
-    ccxt.binance.__name__: '/tradeDetail.html?symbol={base}_{quote}'
+    ccxt.binance.__name__: '/tradeDetail.html?symbol={base}_{quote}',
 }
 
 
@@ -69,11 +69,17 @@ class Exchange(object):
     _conf: Dict = {}
     _params: Dict = {}
 
+    # Dict to specify which options each exchange implements
+    # TODO: this should be merged with attributes from subclasses
+    # To avoid having to copy/paste this to all subclasses.
+    _ft_has = {
+        "stoploss_on_exchange": False,
+    }
+
     def __init__(self, config: dict) -> None:
         """
         Initializes this module with the given config,
-        it does basic validation whether the specified
-        exchange and pairs are valid.
+        it does basic validation whether the specified exchange and pairs are valid.
         :return: None
         """
         self._conf.update(config)
@@ -236,11 +242,11 @@ class Exchange(object):
                 raise OperationalException(
                     f'Exchange {self.name} does not support market orders.')
 
-        if order_types.get('stoploss_on_exchange'):
-            if self.name != 'Binance':
-                raise OperationalException(
-                    'On exchange stoploss is not supported for %s.' % self.name
-                )
+        if (order_types.get("stoploss_on_exchange")
+                and not self._ft_has.get("stoploss_on_exchange", False)):
+            raise OperationalException(
+                'On exchange stoploss is not supported for %s.' % self.name
+            )
 
     def validate_order_time_in_force(self, order_time_in_force: Dict) -> None:
         """
@@ -282,104 +288,96 @@ class Exchange(object):
             price = ceil(big_price) / pow(10, symbol_prec)
         return price
 
-    def buy(self, pair: str, ordertype: str, amount: float,
-            rate: float, time_in_force) -> Dict:
-        if self._conf['dry_run']:
-            order_id = f'dry_run_buy_{randint(0, 10**6)}'
-            self._dry_run_open_orders[order_id] = {
-                'pair': pair,
-                'price': rate,
-                'amount': amount,
-                'type': ordertype,
-                'side': 'buy',
-                'remaining': 0.0,
-                'datetime': arrow.utcnow().isoformat(),
-                'status': 'closed',
-                'fee': None
-            }
-            return {'id': order_id}
+    def dry_run_order(self, pair: str, ordertype: str, side: str, amount: float,
+                      rate: float, params: Dict = {}) -> Dict[str, Any]:
+        order_id = f'dry_run_{side}_{randint(0, 10**6)}'
+        dry_order = {  # TODO: additional entry should be added for stoploss limit
+            "id": order_id,
+            'pair': pair,
+            'price': rate,
+            'amount': amount,
+            "cost": amount * rate,
+            'type': ordertype,
+            'side': 'buy',
+            'remaining': amount,
+            'datetime': arrow.utcnow().isoformat(),
+            'status': "open",
+            'fee': None,
+            "info": {}
+        }
+        self._store_dry_order(dry_order)
+        return dry_order
 
+    def _store_dry_order(self, dry_order: Dict) -> None:
+        closed_order = dry_order.copy()
+        if closed_order["type"] in ["market", "limit"]:
+            closed_order.update({
+                "status": "closed",
+                "filled": closed_order["amount"],
+                "remaining": 0
+                })
+        self._dry_run_open_orders[closed_order["id"]] = closed_order
+
+    def create_order(self, pair: str, ordertype: str, side: str, amount: float,
+                     rate: float, params: Dict = {}) -> Dict:
         try:
             # Set the precision for amount and price(rate) as accepted by the exchange
             amount = self.symbol_amount_prec(pair, amount)
             rate = self.symbol_price_prec(pair, rate) if ordertype != 'market' else None
 
-            params = self._params.copy()
-            if time_in_force != 'gtc':
-                params.update({'timeInForce': time_in_force})
-
-            return self._api.create_order(pair, ordertype, 'buy',
+            return self._api.create_order(pair, ordertype, side,
                                           amount, rate, params)
 
         except ccxt.InsufficientFunds as e:
             raise DependencyException(
-                f'Insufficient funds to create limit buy order on market {pair}.'
-                f'Tried to buy amount {amount} at rate {rate} (total {rate*amount}).'
+                f'Insufficient funds to create {ordertype} {side} order on market {pair}.'
+                f'Tried to {side} amount {amount} at rate {rate} (total {rate*amount}).'
                 f'Message: {e}')
         except ccxt.InvalidOrder as e:
             raise DependencyException(
-                f'Could not create limit buy order on market {pair}.'
-                f'Tried to buy amount {amount} at rate {rate} (total {rate*amount}).'
+                f'Could not create {ordertype} {side} order on market {pair}.'
+                f'Tried to {side} amount {amount} at rate {rate} (total {rate*amount}).'
                 f'Message: {e}')
         except (ccxt.NetworkError, ccxt.ExchangeError) as e:
             raise TemporaryError(
-                f'Could not place buy order due to {e.__class__.__name__}. Message: {e}')
+                f'Could not place {side} order due to {e.__class__.__name__}. Message: {e}')
         except ccxt.BaseError as e:
             raise OperationalException(e)
 
+    def buy(self, pair: str, ordertype: str, amount: float,
+            rate: float, time_in_force) -> Dict:
+
+        if self._conf['dry_run']:
+            dry_order = self.dry_run_order(pair, ordertype, "buy", amount, rate)
+            return dry_order
+
+        params = self._params.copy()
+        if time_in_force != 'gtc':
+            params.update({'timeInForce': time_in_force})
+
+        return self.create_order(pair, ordertype, 'buy', amount, rate, params)
+
     def sell(self, pair: str, ordertype: str, amount: float,
              rate: float, time_in_force='gtc') -> Dict:
+
         if self._conf['dry_run']:
-            order_id = f'dry_run_sell_{randint(0, 10**6)}'
-            self._dry_run_open_orders[order_id] = {
-                'pair': pair,
-                'price': rate,
-                'amount': amount,
-                'type': ordertype,
-                'side': 'sell',
-                'remaining': 0.0,
-                'datetime': arrow.utcnow().isoformat(),
-                'status': 'closed'
-            }
-            return {'id': order_id}
+            dry_order = self.dry_run_order(pair, ordertype, "sell", amount, rate)
+            return dry_order
 
-        try:
-            # Set the precision for amount and price(rate) as accepted by the exchange
-            amount = self.symbol_amount_prec(pair, amount)
-            rate = self.symbol_price_prec(pair, rate) if ordertype != 'market' else None
+        params = self._params.copy()
+        if time_in_force != 'gtc':
+            params.update({'timeInForce': time_in_force})
 
-            params = self._params.copy()
-            if time_in_force != 'gtc':
-                params.update({'timeInForce': time_in_force})
-
-            return self._api.create_order(pair, ordertype, 'sell',
-                                          amount, rate, params)
-
-        except ccxt.InsufficientFunds as e:
-            raise DependencyException(
-                f'Insufficient funds to create limit sell order on market {pair}.'
-                f'Tried to sell amount {amount} at rate {rate} (total {rate*amount}).'
-                f'Message: {e}')
-        except ccxt.InvalidOrder as e:
-            raise DependencyException(
-                f'Could not create limit sell order on market {pair}.'
-                f'Tried to sell amount {amount} at rate {rate} (total {rate*amount}).'
-                f'Message: {e}')
-        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not place sell order due to {e.__class__.__name__}. Message: {e}')
-        except ccxt.BaseError as e:
-            raise OperationalException(e)
+        return self.create_order(pair, ordertype, 'sell', amount, rate, params)
 
     def stoploss_limit(self, pair: str, amount: float, stop_price: float, rate: float) -> Dict:
         """
         creates a stoploss limit order.
         NOTICE: it is not supported by all exchanges. only binance is tested for now.
+        TODO: implementation maybe needs to be moved to the binance subclass
         """
+        ordertype = "stop_loss_limit"
 
-        # Set the precision for amount and price(rate) as accepted by the exchange
-        amount = self.symbol_amount_prec(pair, amount)
-        rate = self.symbol_price_prec(pair, rate)
         stop_price = self.symbol_price_prec(pair, stop_price)
 
         # Ensure rate is less than stop price
@@ -388,50 +386,17 @@ class Exchange(object):
                 'In stoploss limit order, stop price should be more than limit price')
 
         if self._conf['dry_run']:
-            order_id = f'dry_run_buy_{randint(0, 10**6)}'
-            self._dry_run_open_orders[order_id] = {
-                'info': {},
-                'id': order_id,
-                'pair': pair,
-                'price': stop_price,
-                'amount': amount,
-                'type': 'stop_loss_limit',
-                'side': 'sell',
-                'remaining': amount,
-                'datetime': arrow.utcnow().isoformat(),
-                'status': 'open',
-                'fee': None
-            }
-            return self._dry_run_open_orders[order_id]
+            dry_order = self.dry_run_order(
+                pair, ordertype, "sell", amount, stop_price)
+            return dry_order
 
-        try:
+        params = self._params.copy()
+        params.update({'stopPrice': stop_price})
 
-            params = self._params.copy()
-            params.update({'stopPrice': stop_price})
-
-            order = self._api.create_order(pair, 'stop_loss_limit', 'sell',
-                                           amount, rate, params)
-            logger.info('stoploss limit order added for %s. '
-                        'stop price: %s. limit: %s' % (pair, stop_price, rate))
-            return order
-
-        except ccxt.InsufficientFunds as e:
-            raise DependencyException(
-                f'Insufficient funds to place stoploss limit order on market {pair}. '
-                f'Tried to put a stoploss amount {amount} with '
-                f'stop {stop_price} and limit {rate} (total {rate*amount}).'
-                f'Message: {e}')
-        except ccxt.InvalidOrder as e:
-            raise DependencyException(
-                f'Could not place stoploss limit order on market {pair}.'
-                f'Tried to place stoploss amount {amount} with '
-                f'stop {stop_price} and limit {rate} (total {rate*amount}).'
-                f'Message: {e}')
-        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not place stoploss limit order due to {e.__class__.__name__}. Message: {e}')
-        except ccxt.BaseError as e:
-            raise OperationalException(e)
+        order = self.create_order(pair, ordertype, 'sell', amount, rate, params)
+        logger.info('stoploss limit order added for %s. '
+                    'stop price: %s. limit: %s' % (pair, stop_price, rate))
+        return order
 
     @retrier
     def get_balance(self, currency: str) -> float:
@@ -578,7 +543,7 @@ class Exchange(object):
         interval_in_sec = constants.TICKER_INTERVAL_MINUTES[ticker_interval] * 60
 
         return not ((self._pairs_last_refresh_time.get((pair, ticker_interval), 0)
-                    + interval_in_sec) >= arrow.utcnow().timestamp)
+                     + interval_in_sec) >= arrow.utcnow().timestamp)
 
     @retrier_async
     async def _async_get_candle_history(self, pair: str, tick_interval: str,
@@ -637,9 +602,6 @@ class Exchange(object):
     def get_order(self, order_id: str, pair: str) -> Dict:
         if self._conf['dry_run']:
             order = self._dry_run_open_orders[order_id]
-            order.update({
-                'id': order_id
-            })
             return order
         try:
             return self._api.fetch_order(order_id, pair)
@@ -659,18 +621,8 @@ class Exchange(object):
 
         Notes:
         20180619: bittrex doesnt support limits -.-
-        20180619: binance support limits but only on specific range
         """
         try:
-            if self._api.name == 'Binance':
-                limit_range = [5, 10, 20, 50, 100, 500, 1000]
-                # get next-higher step in the limit_range list
-                limit = min(list(filter(lambda x: limit <= x, limit_range)))
-                # above script works like loop below (but with slightly better performance):
-                #   for limitx in limit_range:
-                #        if limit <= limitx:
-                #           limit = limitx
-                #           break
 
             return self._api.fetch_l2_order_book(pair, limit)
         except ccxt.NotSupported as e:
@@ -702,16 +654,6 @@ class Exchange(object):
         except ccxt.BaseError as e:
             raise OperationalException(e)
 
-    def get_pair_detail_url(self, pair: str) -> str:
-        try:
-            url_base = self._api.urls.get('www')
-            base, quote = pair.split('/')
-
-            return url_base + _EXCHANGE_URLS[self._api.id].format(base=base, quote=quote)
-        except KeyError:
-            logger.warning('Could not get exchange url for %s', self.name)
-            return ""
-
     @retrier
     def get_markets(self) -> List[dict]:
         try: