stable/freqtrade/exchange/__init__.py

689 lines
28 KiB
Python
Raw Normal View History

2017-11-18 07:52:28 +00:00
# pragma pylint: disable=W0603
""" Cryptocurrency Exchanges support """
2017-05-14 12:14:16 +00:00
import logging
import inspect
2017-11-05 14:21:16 +00:00
from random import randint
from typing import List, Dict, Tuple, Any, Optional
2018-04-15 17:39:11 +00:00
from datetime import datetime
from math import floor, ceil
2017-09-01 19:11:46 +00:00
import asyncio
import ccxt
2018-07-31 10:47:32 +00:00
import ccxt.async_support as ccxt_async
2017-10-06 10:22:04 +00:00
import arrow
2018-05-04 10:38:51 +00:00
from freqtrade import constants, OperationalException, DependencyException, TemporaryError
2017-05-12 17:11:56 +00:00
2017-05-14 12:14:16 +00:00
logger = logging.getLogger(__name__)
2017-05-12 17:11:56 +00:00
API_RETRY_COUNT = 4
2017-05-12 17:11:56 +00:00
2017-11-05 14:21:16 +00:00
# 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}'
}
2018-08-18 19:05:38 +00:00
def retrier_async(f):
async def wrapper(*args, **kwargs):
count = kwargs.pop('count', API_RETRY_COUNT)
try:
return await f(*args, **kwargs)
except (TemporaryError, DependencyException) as ex:
logger.warning('%s() returned exception: "%s"', f.__name__, ex)
if count > 0:
count -= 1
kwargs.update({'count': count})
logger.warning('retrying %s() still for %s times', f.__name__, count)
return await wrapper(*args, **kwargs)
else:
logger.warning('Giving up retrying: %s()', f.__name__)
raise ex
return wrapper
def retrier(f):
def wrapper(*args, **kwargs):
count = kwargs.pop('count', API_RETRY_COUNT)
try:
return f(*args, **kwargs)
2018-04-21 20:37:27 +00:00
except (TemporaryError, DependencyException) as ex:
logger.warning('%s() returned exception: "%s"', f.__name__, ex)
if count > 0:
count -= 1
kwargs.update({'count': count})
2018-04-21 20:37:27 +00:00
logger.warning('retrying %s() still for %s times', f.__name__, count)
return wrapper(*args, **kwargs)
else:
logger.warning('Giving up retrying: %s()', f.__name__)
raise ex
return wrapper
2018-06-17 10:41:33 +00:00
class Exchange(object):
2018-06-17 10:41:33 +00:00
# Current selected exchange
2018-06-18 20:07:15 +00:00
_api: ccxt.Exchange = None
2018-07-31 10:47:32 +00:00
_api_async: ccxt_async.Exchange = None
2018-06-18 20:09:46 +00:00
_conf: Dict = {}
2018-06-17 10:41:33 +00:00
# Holds all open sell orders for dry_run
2018-06-18 20:09:46 +00:00
_dry_run_open_orders: Dict[str, Any] = {}
2018-06-17 10:41:33 +00:00
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.
:return: None
"""
2018-06-18 20:09:46 +00:00
self._conf.update(config)
2018-08-19 17:37:48 +00:00
self._cached_ticker: Dict[str, Any] = {}
# Holds last candle refreshed time of each pair
self._pairs_last_refresh_time: Dict[str, int] = {}
# Holds candles
self.klines: Dict[str, Any] = {}
2018-06-17 10:41:33 +00:00
if config['dry_run']:
logger.info('Instance is running with dry_run enabled')
2017-10-01 21:28:09 +00:00
2018-06-17 10:41:33 +00:00
exchange_config = config['exchange']
self._api = self._init_ccxt(exchange_config, ccxt_kwargs=exchange_config.get('ccxt_config'))
self._api_async = self._init_ccxt(exchange_config, ccxt_async,
ccxt_kwargs=exchange_config.get('ccxt_async_config'))
2017-10-01 21:28:09 +00:00
logger.info('Using Exchange "%s"', self.name)
self.markets = self._load_markets()
2018-06-17 10:41:33 +00:00
# Check if all pairs are available
self.validate_pairs(config['exchange']['pair_whitelist'])
self.validate_ordertypes(config.get('order_types', {}))
2018-11-25 20:09:35 +00:00
self.validate_order_time_in_force(config.get('order_time_in_force', {}))
2018-07-09 20:11:12 +00:00
if config.get('ticker_interval'):
# Check if timeframe is available
self.validate_timeframes(config['ticker_interval'])
def __del__(self):
"""
Destructor - clean up async stuff
"""
logger.debug("Exchange object destroyed, closing async loop")
if self._api_async and inspect.iscoroutinefunction(self._api_async.close):
asyncio.get_event_loop().run_until_complete(self._api_async.close())
def _init_ccxt(self, exchange_config: dict, ccxt_module=ccxt,
ccxt_kwargs: dict = None) -> ccxt.Exchange:
2018-06-17 11:09:23 +00:00
"""
Initialize ccxt with given config and return valid
ccxt instance.
"""
# Find matching class for the given exchange name
name = exchange_config['name']
2018-07-31 10:47:32 +00:00
if name not in ccxt_module.exchanges:
2018-06-17 11:09:23 +00:00
raise OperationalException(f'Exchange {name} is not supported')
ex_config = {
2018-06-17 11:09:23 +00:00
'apiKey': exchange_config.get('key'),
'secret': exchange_config.get('secret'),
'password': exchange_config.get('password'),
'uid': exchange_config.get('uid', ''),
'enableRateLimit': exchange_config.get('ccxt_rate_limit', True)
}
if ccxt_kwargs:
logger.info('Applying additional ccxt config: %s', ccxt_kwargs)
ex_config.update(ccxt_kwargs)
try:
api = getattr(ccxt_module, name.lower())(ex_config)
2018-06-17 11:09:23 +00:00
except (KeyError, AttributeError):
raise OperationalException(f'Exchange {name} is not supported')
self.set_sandbox(api, exchange_config, name)
2018-07-27 08:55:36 +00:00
2018-06-17 11:09:23 +00:00
return api
@property
def name(self) -> str:
"""exchange Name (from ccxt)"""
2018-06-18 20:07:15 +00:00
return self._api.name
@property
def id(self) -> str:
"""exchange ccxt id"""
2018-06-18 20:07:15 +00:00
return self._api.id
2017-10-06 10:22:04 +00:00
def set_sandbox(self, api, exchange_config: dict, name: str):
if exchange_config.get('sandbox'):
if api.urls.get('test'):
api.urls['api'] = api.urls['test']
logger.info("Enabled Sandbox API on %s", name)
else:
2018-08-05 13:08:07 +00:00
logger.warning(name, "No Sandbox URL in CCXT, exiting. "
2018-07-29 08:10:55 +00:00
"Please check your config.json")
raise OperationalException(f'Exchange {name} does not provide a sandbox api')
2018-08-10 11:04:43 +00:00
def _load_async_markets(self) -> None:
try:
if self._api_async:
asyncio.get_event_loop().run_until_complete(self._api_async.load_markets())
except ccxt.BaseError as e:
logger.warning('Could not load async markets. Reason: %s', e)
return
def _load_markets(self) -> Dict[str, Any]:
""" Initialize markets both sync and async """
try:
markets = self._api.load_markets()
self._load_async_markets()
return markets
except ccxt.BaseError as e:
logger.warning('Unable to initialize markets. Reason: %s', e)
return {}
2018-06-17 10:41:33 +00:00
def validate_pairs(self, pairs: List[str]) -> None:
"""
Checks if all given pairs are tradable on the current exchange.
Raises OperationalException if one pair is not available.
:param pairs: list of pairs
:return: None
"""
2017-10-06 10:22:04 +00:00
if not self.markets:
logger.warning('Unable to validate pairs (assuming they are correct).')
# return
2018-06-17 10:41:33 +00:00
2018-06-18 20:09:46 +00:00
stake_cur = self._conf['stake_currency']
2018-06-17 10:41:33 +00:00
for pair in pairs:
# Note: ccxt has BaseCurrency/QuoteCurrency format for pairs
# TODO: add a support for having coins in BTC/USDT format
if not pair.endswith(stake_cur):
raise OperationalException(
f'Pair {pair} not compatible with stake_currency: {stake_cur}')
if self.markets and pair not in self.markets:
2018-06-17 10:41:33 +00:00
raise OperationalException(
f'Pair {pair} is not available at {self.name}')
2018-06-17 10:41:33 +00:00
def validate_timeframes(self, timeframe: List[str]) -> None:
"""
Checks if ticker interval from config is a supported timeframe on the exchange
"""
2018-07-05 12:05:31 +00:00
timeframes = self._api.timeframes
if timeframe not in timeframes:
2018-07-05 12:05:31 +00:00
raise OperationalException(
f'Invalid ticker {timeframe}, this Exchange supports {timeframes}')
def validate_ordertypes(self, order_types: Dict) -> None:
"""
Checks if order-types configured in strategy/config are supported
"""
if any(v == 'market' for k, v in order_types.items()):
if not self.exchange_has('createMarketOrder'):
raise OperationalException(
f'Exchange {self.name} does not support market orders.')
2018-11-25 20:09:35 +00:00
def validate_order_time_in_force(self, order_time_in_force: Dict) -> None:
"""
Checks if order time in force configured in strategy/config are supported
"""
if any(v != 'gtc' for k, v in order_time_in_force.items()):
if not self.name == 'Binance':
raise OperationalException(
f'Time in force policies are not supporetd for {self.name} yet.')
2018-06-17 10:41:33 +00:00
def exchange_has(self, endpoint: str) -> bool:
"""
Checks if exchange implements a specific API endpoint.
Wrapper around ccxt 'has' attribute
:param endpoint: Name of endpoint (e.g. 'fetchOHLCV', 'fetchTickers')
:return: bool
"""
2018-06-18 20:07:15 +00:00
return endpoint in self._api.has and self._api.has[endpoint]
2018-06-17 10:41:33 +00:00
def symbol_amount_prec(self, pair, amount: float):
'''
Returns the amount to buy or sell to a precision the Exchange accepts
Rounded down
'''
if self._api.markets[pair]['precision']['amount']:
symbol_prec = self._api.markets[pair]['precision']['amount']
big_amount = amount * pow(10, symbol_prec)
amount = floor(big_amount) / pow(10, symbol_prec)
return amount
def symbol_price_prec(self, pair, price: float):
'''
Returns the price buying or selling with to the precision the Exchange accepts
Rounds up
'''
if self._api.markets[pair]['precision']['price']:
symbol_prec = self._api.markets[pair]['precision']['price']
big_price = price * pow(10, symbol_prec)
price = ceil(big_price) / pow(10, symbol_prec)
return price
def buy(self, pair: str, ordertype: str, amount: float, rate: float, time_in_force='gtc') -> Dict:
2018-06-18 20:09:46 +00:00
if self._conf['dry_run']:
2018-06-17 10:41:33 +00:00
order_id = f'dry_run_buy_{randint(0, 10**6)}'
2018-06-18 20:09:46 +00:00
self._dry_run_open_orders[order_id] = {
2018-06-17 10:41:33 +00:00
'pair': pair,
'price': rate,
'amount': amount,
'type': ordertype,
2018-06-17 10:41:33 +00:00
'side': 'buy',
'remaining': 0.0,
'datetime': arrow.utcnow().isoformat(),
'status': 'closed',
'fee': None
}
return {'id': order_id}
2018-06-06 18:18:16 +00:00
try:
# Set the precision for amount and price(rate) as accepted by the exchange
amount = self.symbol_amount_prec(pair, amount)
2018-11-17 19:09:05 +00:00
rate = self.symbol_price_prec(pair, rate) if ordertype != 'market' else None
if time_in_force == 'gtc':
return self._api.create_order(pair, ordertype, 'buy', amount, rate)
else:
return self._api.create_order(pair, ordertype, 'buy',
amount, rate, {'timeInForce': time_in_force})
2018-06-17 10:41:33 +00:00
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'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'Message: {e}')
2018-06-06 18:18:16 +00:00
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
2018-06-17 10:41:33 +00:00
f'Could not place buy order due to {e.__class__.__name__}. Message: {e}')
2018-06-06 18:18:16 +00:00
except ccxt.BaseError as e:
raise OperationalException(e)
2017-10-06 10:22:04 +00:00
def sell(self, pair: str, ordertype: str, amount: float,
rate: float, time_in_force='gtc') -> Dict:
2018-06-18 20:09:46 +00:00
if self._conf['dry_run']:
2018-06-17 10:41:33 +00:00
order_id = f'dry_run_sell_{randint(0, 10**6)}'
2018-06-18 20:09:46 +00:00
self._dry_run_open_orders[order_id] = {
2018-06-17 10:41:33 +00:00
'pair': pair,
'price': rate,
'amount': amount,
'type': ordertype,
2018-06-17 10:41:33 +00:00
'side': 'sell',
'remaining': 0.0,
'datetime': arrow.utcnow().isoformat(),
'status': 'closed'
}
return {'id': order_id}
2017-10-06 10:22:04 +00:00
2018-06-17 10:41:33 +00:00
try:
# Set the precision for amount and price(rate) as accepted by the exchange
amount = self.symbol_amount_prec(pair, amount)
2018-11-17 19:09:05 +00:00
rate = self.symbol_price_prec(pair, rate) if ordertype != 'market' else None
if time_in_force == 'gtc':
return self._api.create_order(pair, ordertype, 'sell', amount, rate)
else:
return self._api.create_order(pair, ordertype, 'sell',
amount, rate, {'timeInForce': time_in_force})
2018-06-17 10:41:33 +00:00
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)
2017-10-06 10:22:04 +00:00
2018-06-17 10:41:33 +00:00
@retrier
def get_balance(self, currency: str) -> float:
2018-06-18 20:09:46 +00:00
if self._conf['dry_run']:
2018-06-17 10:41:33 +00:00
return 999.9
2018-04-15 17:39:11 +00:00
2018-06-17 10:41:33 +00:00
# ccxt exception is already handled by get_balances
balances = self.get_balances()
balance = balances.get(currency)
if balance is None:
raise TemporaryError(
f'Could not get {currency} balance due to malformed exchange response: {balances}')
return balance['free']
2018-04-15 17:39:11 +00:00
2018-06-17 10:41:33 +00:00
@retrier
def get_balances(self) -> dict:
2018-06-18 20:09:46 +00:00
if self._conf['dry_run']:
2018-06-17 10:41:33 +00:00
return {}
2018-06-17 10:41:33 +00:00
try:
2018-06-18 20:07:15 +00:00
balances = self._api.fetch_balance()
2018-06-17 10:41:33 +00:00
# Remove additional info from ccxt results
balances.pop("info", None)
balances.pop("free", None)
balances.pop("total", None)
balances.pop("used", None)
return balances
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not get balance due to {e.__class__.__name__}. Message: {e}')
except ccxt.BaseError as e:
raise OperationalException(e)
2018-06-17 10:41:33 +00:00
@retrier
def get_tickers(self) -> Dict:
try:
2018-06-18 20:07:15 +00:00
return self._api.fetch_tickers()
2018-06-17 10:41:33 +00:00
except ccxt.NotSupported as e:
raise OperationalException(
2018-06-18 20:07:15 +00:00
f'Exchange {self._api.name} does not support fetching tickers in batch.'
2018-06-17 10:41:33 +00:00
f'Message: {e}')
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not load tickers due to {e.__class__.__name__}. Message: {e}')
except ccxt.BaseError as e:
raise OperationalException(e)
2018-06-17 10:41:33 +00:00
@retrier
def get_ticker(self, pair: str, refresh: Optional[bool] = True) -> dict:
2018-06-18 20:09:46 +00:00
if refresh or pair not in self._cached_ticker.keys():
2018-06-17 10:41:33 +00:00
try:
if pair not in self._api.markets:
raise DependencyException(f"Pair {pair} not available")
2018-06-18 20:07:15 +00:00
data = self._api.fetch_ticker(pair)
2018-06-17 10:41:33 +00:00
try:
2018-06-18 20:09:46 +00:00
self._cached_ticker[pair] = {
2018-06-17 10:41:33 +00:00
'bid': float(data['bid']),
'ask': float(data['ask']),
}
except KeyError:
logger.debug("Could not cache ticker data for %s", pair)
return data
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
2018-08-08 19:55:48 +00:00
f'Could not load ticker due to {e.__class__.__name__}. Message: {e}')
2018-06-17 10:41:33 +00:00
except ccxt.BaseError as e:
raise OperationalException(e)
else:
logger.info("returning cached ticker-data for %s", pair)
2018-06-18 20:09:46 +00:00
return self._cached_ticker[pair]
2018-06-17 10:41:33 +00:00
2018-08-10 09:08:28 +00:00
def get_history(self, pair: str, tick_interval: str,
since_ms: int) -> List:
"""
Gets candle history using asyncio and returns the list of candles.
Handles all async doing.
"""
return asyncio.get_event_loop().run_until_complete(
self._async_get_history(pair=pair, tick_interval=tick_interval,
since_ms=since_ms))
async def _async_get_history(self, pair: str,
tick_interval: str,
since_ms: int) -> List:
# Assume exchange returns 500 candles
_LIMIT = 500
one_call = constants.TICKER_INTERVAL_MINUTES[tick_interval] * 60 * _LIMIT * 1000
logger.debug("one_call: %s", one_call)
input_coroutines = [self._async_get_candle_history(
2018-08-10 09:08:28 +00:00
pair, tick_interval, since) for since in
range(since_ms, arrow.utcnow().timestamp * 1000, one_call)]
2018-08-10 09:08:28 +00:00
tickers = await asyncio.gather(*input_coroutines, return_exceptions=True)
# Combine tickers
data: List = []
2018-08-10 09:08:28 +00:00
for tick in tickers:
if tick[0] == pair:
data.extend(tick[1])
2018-08-18 19:08:59 +00:00
# Sort data again after extending the result - above calls return in "async order" order
data = sorted(data, key=lambda x: x[0])
2018-08-10 09:08:28 +00:00
logger.info("downloaded %s with length %s.", pair, len(data))
return data
def refresh_tickers(self, pair_list: List[str], ticker_interval: str) -> None:
"""
Refresh tickers asyncronously and return the result.
"""
logger.debug("Refreshing klines for %d pairs", len(pair_list))
asyncio.get_event_loop().run_until_complete(
self.async_get_candles_history(pair_list, ticker_interval))
2018-08-10 07:56:54 +00:00
async def async_get_candles_history(self, pairs: List[str],
tick_interval: str) -> List[Tuple[str, List]]:
2018-08-15 10:46:45 +00:00
"""Download ohlcv history for pair-list asyncronously """
input_coroutines = [self._async_get_candle_history(
symbol, tick_interval) for symbol in pairs]
2018-07-31 10:47:32 +00:00
tickers = await asyncio.gather(*input_coroutines, return_exceptions=True)
return tickers
2018-08-18 19:05:38 +00:00
@retrier_async
async def _async_get_candle_history(self, pair: str, tick_interval: str,
since_ms: Optional[int] = None) -> Tuple[str, List]:
2018-07-31 10:47:32 +00:00
try:
# fetch ohlcv asynchronously
2018-08-10 09:08:28 +00:00
logger.debug("fetching %s since %s ...", pair, since_ms)
# Calculating ticker interval in second
interval_in_sec = constants.TICKER_INTERVAL_MINUTES[tick_interval] * 60
# If (last update time) + (interval in second) is greater or equal than now
# that means we don't have to hit the API as there is no new candle
# so we fetch it from local cache
if (not since_ms and
self._pairs_last_refresh_time.get(pair, 0) + interval_in_sec >=
arrow.utcnow().timestamp):
data = self.klines[pair]
2018-08-10 07:48:54 +00:00
logger.debug("Using cached klines data for %s ...", pair)
else:
data = await self._api_async.fetch_ohlcv(pair, timeframe=tick_interval,
since=since_ms)
# Because some exchange sort Tickers ASC and other DESC.
# Ex: Bittrex returns a list of tickers ASC (oldest first, newest last)
# when GDAX returns a list of tickers DESC (newest first, oldest last)
data = sorted(data, key=lambda x: x[0])
# keeping last candle time as last refreshed time of the pair
2018-09-02 17:15:23 +00:00
if data:
self._pairs_last_refresh_time[pair] = data[-1][0] // 1000
# keeping candles in cache
self.klines[pair] = data
logger.debug("done fetching %s ...", pair)
2018-07-31 10:47:32 +00:00
return pair, data
except ccxt.NotSupported as e:
raise OperationalException(
f'Exchange {self._api.name} does not support fetching historical candlestick data.'
f'Message: {e}')
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not load ticker history due to {e.__class__.__name__}. Message: {e}')
except ccxt.BaseError as e:
raise OperationalException(f'Could not fetch ticker data. Msg: {e}')
2018-06-17 10:41:33 +00:00
@retrier
2018-08-02 08:58:04 +00:00
def get_candle_history(self, pair: str, tick_interval: str,
2018-06-17 10:41:33 +00:00
since_ms: Optional[int] = None) -> List[Dict]:
try:
# last item should be in the time interval [now - tick_interval, now]
till_time_ms = arrow.utcnow().shift(
minutes=-constants.TICKER_INTERVAL_MINUTES[tick_interval]
).timestamp * 1000
# it looks as if some exchanges return cached data
# and they update it one in several minute, so 10 mins interval
# is necessary to skeep downloading of an empty array when all
# chached data was already downloaded
till_time_ms = min(till_time_ms, arrow.utcnow().shift(minutes=-10).timestamp * 1000)
data: List[Dict[Any, Any]] = []
while not since_ms or since_ms < till_time_ms:
2018-06-18 20:07:15 +00:00
data_part = self._api.fetch_ohlcv(pair, timeframe=tick_interval, since=since_ms)
2018-06-17 10:41:33 +00:00
# Because some exchange sort Tickers ASC and other DESC.
# Ex: Bittrex returns a list of tickers ASC (oldest first, newest last)
# when GDAX returns a list of tickers DESC (newest first, oldest last)
data_part = sorted(data_part, key=lambda x: x[0])
if not data_part:
break
logger.debug('Downloaded data for %s time range [%s, %s]',
pair,
arrow.get(data_part[0][0] / 1000).format(),
arrow.get(data_part[-1][0] / 1000).format())
data.extend(data_part)
since_ms = data[-1][0] + 1
2018-06-17 10:41:33 +00:00
return data
except ccxt.NotSupported as e:
raise OperationalException(
2018-06-18 20:07:15 +00:00
f'Exchange {self._api.name} does not support fetching historical candlestick data.'
2018-06-17 10:41:33 +00:00
f'Message: {e}')
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not load ticker history due to {e.__class__.__name__}. Message: {e}')
except ccxt.BaseError as e:
raise OperationalException(f'Could not fetch ticker data. Msg: {e}')
2018-06-17 10:41:33 +00:00
@retrier
def cancel_order(self, order_id: str, pair: str) -> None:
2018-06-18 20:09:46 +00:00
if self._conf['dry_run']:
2018-06-17 10:41:33 +00:00
return
try:
2018-06-18 20:07:15 +00:00
return self._api.cancel_order(order_id, pair)
2018-06-17 10:41:33 +00:00
except ccxt.InvalidOrder as e:
raise DependencyException(
f'Could not cancel order. Message: {e}')
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not cancel order due to {e.__class__.__name__}. Message: {e}')
except ccxt.BaseError as e:
raise OperationalException(e)
@retrier
def get_order(self, order_id: str, pair: str) -> Dict:
2018-06-18 20:09:46 +00:00
if self._conf['dry_run']:
order = self._dry_run_open_orders[order_id]
2018-06-17 10:41:33 +00:00
order.update({
'id': order_id
})
return order
try:
2018-06-18 20:07:15 +00:00
return self._api.fetch_order(order_id, pair)
2018-06-17 10:41:33 +00:00
except ccxt.InvalidOrder as e:
raise DependencyException(
f'Could not get order. Message: {e}')
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not get order due to {e.__class__.__name__}. Message: {e}')
except ccxt.BaseError as e:
raise OperationalException(e)
2017-11-11 18:20:16 +00:00
2018-08-05 04:41:06 +00:00
@retrier
def get_order_book(self, pair: str, limit: int = 100) -> dict:
2018-08-07 10:29:37 +00:00
"""
get order book level 2 from exchange
Notes:
20180619: bittrex doesnt support limits -.-
20180619: binance support limits but only on specific range
"""
2018-08-05 04:41:06 +00:00
try:
if self._api.name == 'Binance':
limit_range = [5, 10, 20, 50, 100, 500, 1000]
2018-08-07 10:29:37 +00:00
# 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
2018-08-05 04:41:06 +00:00
return self._api.fetch_l2_order_book(pair, limit)
except ccxt.NotSupported as e:
raise OperationalException(
f'Exchange {self._api.name} does not support fetching order book.'
f'Message: {e}')
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not get order book due to {e.__class__.__name__}. Message: {e}')
except ccxt.BaseError as e:
raise OperationalException(e)
2018-06-17 10:41:33 +00:00
@retrier
def get_trades_for_order(self, order_id: str, pair: str, since: datetime) -> List:
2018-06-18 20:09:46 +00:00
if self._conf['dry_run']:
2018-06-17 10:41:33 +00:00
return []
if not self.exchange_has('fetchMyTrades'):
return []
try:
2018-09-15 18:28:36 +00:00
# Allow 5s offset to catch slight time offsets (discovered in #1185)
my_trades = self._api.fetch_my_trades(pair, since.timestamp() - 5)
2018-06-17 10:41:33 +00:00
matched_trades = [trade for trade in my_trades if trade['order'] == order_id]
2017-11-11 18:20:16 +00:00
2018-06-17 10:41:33 +00:00
return matched_trades
2018-06-17 10:41:33 +00:00
except ccxt.NetworkError as e:
raise TemporaryError(
f'Could not get trades due to networking error. Message: {e}')
except ccxt.BaseError as e:
raise OperationalException(e)
2018-06-17 10:41:33 +00:00
def get_pair_detail_url(self, pair: str) -> str:
try:
2018-06-18 20:07:15 +00:00
url_base = self._api.urls.get('www')
2018-06-17 10:41:33 +00:00
base, quote = pair.split('/')
2018-06-18 20:07:15 +00:00
return url_base + _EXCHANGE_URLS[self._api.id].format(base=base, quote=quote)
2018-06-17 10:41:33 +00:00
except KeyError:
logger.warning('Could not get exchange url for %s', self.name)
2018-06-17 10:41:33 +00:00
return ""
2018-06-17 10:41:33 +00:00
@retrier
def get_markets(self) -> List[dict]:
try:
2018-06-18 20:07:15 +00:00
return self._api.fetch_markets()
2018-06-17 10:41:33 +00:00
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not load markets due to {e.__class__.__name__}. Message: {e}')
except ccxt.BaseError as e:
raise OperationalException(e)
2018-04-21 20:37:27 +00:00
2018-06-17 10:41:33 +00:00
@retrier
def get_fee(self, symbol='ETH/BTC', type='', side='', amount=1,
price=1, taker_or_maker='maker') -> float:
try:
# validate that markets are loaded before trying to get fee
2018-06-18 20:07:15 +00:00
if self._api.markets is None or len(self._api.markets) == 0:
self._api.load_markets()
2018-04-15 17:39:11 +00:00
2018-06-18 20:07:15 +00:00
return self._api.calculate_fee(symbol=symbol, type=type, side=side, amount=amount,
2018-06-17 10:41:33 +00:00
price=price, takerOrMaker=taker_or_maker)['rate']
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not get fee info due to {e.__class__.__name__}. Message: {e}')
except ccxt.BaseError as e:
raise OperationalException(e)