2019-02-24 18:30:05 +00:00
|
|
|
""" Binance exchange subclass """
|
|
|
|
import logging
|
2021-09-09 07:43:05 +00:00
|
|
|
from datetime import datetime
|
2021-09-16 05:51:21 +00:00
|
|
|
from typing import Any, Dict, List, Optional
|
2019-02-24 18:30:05 +00:00
|
|
|
|
2021-09-16 04:28:10 +00:00
|
|
|
import arrow
|
2019-08-25 07:50:37 +00:00
|
|
|
import ccxt
|
2021-09-09 07:19:24 +00:00
|
|
|
|
2020-09-28 17:39:41 +00:00
|
|
|
from freqtrade.exceptions import (DDosProtection, InsufficientFundsError, InvalidOrderException,
|
|
|
|
OperationalException, TemporaryError)
|
2021-09-08 20:50:30 +00:00
|
|
|
from freqtrade.exchange import Exchange
|
2020-06-28 09:56:29 +00:00
|
|
|
from freqtrade.exchange.common import retrier
|
2021-09-09 07:19:24 +00:00
|
|
|
|
2020-09-28 17:39:41 +00:00
|
|
|
|
2019-02-24 18:30:05 +00:00
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
|
|
|
|
|
|
class Binance(Exchange):
|
|
|
|
|
2019-02-24 19:01:20 +00:00
|
|
|
_ft_has: Dict = {
|
2019-02-24 18:30:05 +00:00
|
|
|
"stoploss_on_exchange": True,
|
2019-03-25 23:49:39 +00:00
|
|
|
"order_time_in_force": ['gtc', 'fok', 'ioc'],
|
2021-09-16 04:28:10 +00:00
|
|
|
"time_in_force_parameter": "timeInForce",
|
2020-12-20 10:44:50 +00:00
|
|
|
"ohlcv_candle_limit": 1000,
|
2019-08-14 17:22:52 +00:00
|
|
|
"trades_pagination": "id",
|
|
|
|
"trades_pagination_arg": "fromId",
|
2020-10-13 18:02:47 +00:00
|
|
|
"l2_limit_range": [5, 10, 20, 50, 100, 500, 1000],
|
2019-02-24 18:30:05 +00:00
|
|
|
}
|
2021-09-09 07:19:24 +00:00
|
|
|
funding_fee_times: List[int] = [0, 8, 16] # hours of the day
|
2021-09-16 05:51:21 +00:00
|
|
|
_funding_interest_rates: Dict = {} # TODO-lev: delete
|
|
|
|
|
|
|
|
def __init__(self, config: Dict[str, Any], validate: bool = True) -> None:
|
|
|
|
super().__init__(config, validate)
|
|
|
|
# TODO-lev: Uncomment once lev-exchange merged in
|
|
|
|
# if self.trading_mode == TradingMode.FUTURES:
|
|
|
|
# self._funding_interest_rates = self._get_funding_interest_rates()
|
2019-02-24 18:30:05 +00:00
|
|
|
|
2020-01-19 18:54:30 +00:00
|
|
|
def stoploss_adjust(self, stop_loss: float, order: Dict) -> bool:
|
|
|
|
"""
|
|
|
|
Verify stop_loss against stoploss-order value (limit or price)
|
|
|
|
Returns True if adjustment is necessary.
|
|
|
|
"""
|
|
|
|
return order['type'] == 'stop_loss_limit' and stop_loss > float(order['info']['stopPrice'])
|
|
|
|
|
2020-06-28 09:56:29 +00:00
|
|
|
@retrier(retries=0)
|
2020-01-19 12:30:56 +00:00
|
|
|
def stoploss(self, pair: str, amount: float, stop_price: float, order_types: Dict) -> Dict:
|
2019-08-25 07:50:37 +00:00
|
|
|
"""
|
|
|
|
creates a stoploss limit order.
|
|
|
|
this stoploss-limit is binance-specific.
|
|
|
|
It may work with a limited number of other exchanges, but this has not been tested yet.
|
|
|
|
"""
|
2020-01-19 12:12:28 +00:00
|
|
|
# Limit price threshold: As limit price should always be below stop-price
|
2020-02-02 09:47:44 +00:00
|
|
|
limit_price_pct = order_types.get('stoploss_on_exchange_limit_ratio', 0.99)
|
|
|
|
rate = stop_price * limit_price_pct
|
2020-01-19 12:12:28 +00:00
|
|
|
|
2019-08-25 07:50:37 +00:00
|
|
|
ordertype = "stop_loss_limit"
|
|
|
|
|
2020-01-12 13:55:05 +00:00
|
|
|
stop_price = self.price_to_precision(pair, stop_price)
|
2019-08-25 07:50:37 +00:00
|
|
|
|
|
|
|
# Ensure rate is less than stop price
|
|
|
|
if stop_price <= rate:
|
|
|
|
raise OperationalException(
|
|
|
|
'In stoploss limit order, stop price should be more than limit price')
|
|
|
|
|
|
|
|
if self._config['dry_run']:
|
2021-04-10 11:50:56 +00:00
|
|
|
dry_order = self.create_dry_run_order(
|
2019-08-25 07:50:37 +00:00
|
|
|
pair, ordertype, "sell", amount, stop_price)
|
|
|
|
return dry_order
|
|
|
|
|
|
|
|
try:
|
2019-08-25 08:08:06 +00:00
|
|
|
params = self._params.copy()
|
|
|
|
params.update({'stopPrice': stop_price})
|
|
|
|
|
2020-01-12 13:55:05 +00:00
|
|
|
amount = self.amount_to_precision(pair, amount)
|
2019-08-25 07:50:37 +00:00
|
|
|
|
2020-01-12 13:55:05 +00:00
|
|
|
rate = self.price_to_precision(pair, rate)
|
2019-08-25 07:50:37 +00:00
|
|
|
|
2020-01-19 13:07:59 +00:00
|
|
|
order = self._api.create_order(symbol=pair, type=ordertype, side='sell',
|
2020-05-13 05:15:18 +00:00
|
|
|
amount=amount, price=rate, params=params)
|
2019-08-25 07:50:37 +00:00
|
|
|
logger.info('stoploss limit order added for %s. '
|
|
|
|
'stop price: %s. limit: %s', pair, stop_price, rate)
|
2021-06-10 18:09:25 +00:00
|
|
|
self._log_exchange_response('create_stoploss_order', order)
|
2019-08-25 07:50:37 +00:00
|
|
|
return order
|
|
|
|
except ccxt.InsufficientFunds as e:
|
2020-08-14 07:57:13 +00:00
|
|
|
raise InsufficientFundsError(
|
2020-06-13 21:35:58 +00:00
|
|
|
f'Insufficient funds to create {ordertype} sell order on market {pair}. '
|
2019-09-01 08:17:17 +00:00
|
|
|
f'Tried to sell amount {amount} at rate {rate}. '
|
2019-08-25 07:50:37 +00:00
|
|
|
f'Message: {e}') from e
|
|
|
|
except ccxt.InvalidOrder as e:
|
2019-09-01 07:08:35 +00:00
|
|
|
# Errors:
|
|
|
|
# `binance Order would trigger immediately.`
|
|
|
|
raise InvalidOrderException(
|
2019-08-25 07:50:37 +00:00
|
|
|
f'Could not create {ordertype} sell order on market {pair}. '
|
2019-09-01 08:17:17 +00:00
|
|
|
f'Tried to sell amount {amount} at rate {rate}. '
|
2019-08-25 07:50:37 +00:00
|
|
|
f'Message: {e}') from e
|
2020-06-28 09:17:06 +00:00
|
|
|
except ccxt.DDoSProtection as e:
|
|
|
|
raise DDosProtection(e) from e
|
2019-08-25 07:50:37 +00:00
|
|
|
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
|
|
|
|
raise TemporaryError(
|
|
|
|
f'Could not place sell order due to {e.__class__.__name__}. Message: {e}') from e
|
|
|
|
except ccxt.BaseError as e:
|
|
|
|
raise OperationalException(e) from e
|
2021-09-09 01:31:04 +00:00
|
|
|
|
2021-09-16 05:51:21 +00:00
|
|
|
def _get_premium_index(self, pair: str, date: datetime) -> float:
|
|
|
|
raise OperationalException(f'_get_premium_index has not been implemented on {self.name}')
|
|
|
|
|
|
|
|
def _get_mark_price(self, pair: str, date: datetime) -> float:
|
|
|
|
raise OperationalException(f'_get_mark_price has not been implemented on {self.name}')
|
|
|
|
|
|
|
|
def _get_funding_interest_rates(self):
|
|
|
|
rates = self._api.fetch_funding_rates()
|
|
|
|
interest_rates = {}
|
|
|
|
for pair, data in rates.items():
|
|
|
|
interest_rates[pair] = data['interestRate']
|
|
|
|
return interest_rates
|
|
|
|
|
2021-09-10 22:28:34 +00:00
|
|
|
def _calculate_funding_rate(self, pair: str, premium_index: float) -> Optional[float]:
|
2021-09-09 07:43:05 +00:00
|
|
|
"""
|
|
|
|
Get's the funding_rate for a pair at a specific date and time in the past
|
|
|
|
"""
|
2021-09-16 05:51:21 +00:00
|
|
|
return (
|
|
|
|
premium_index +
|
|
|
|
max(min(self._funding_interest_rates[pair] - premium_index, 0.0005), -0.0005)
|
|
|
|
)
|
2021-09-09 07:43:05 +00:00
|
|
|
|
2021-09-09 01:31:04 +00:00
|
|
|
def _get_funding_fee(
|
|
|
|
self,
|
2021-09-10 22:28:34 +00:00
|
|
|
pair: str,
|
2021-09-09 01:31:04 +00:00
|
|
|
contract_size: float,
|
|
|
|
mark_price: float,
|
2021-09-10 22:28:34 +00:00
|
|
|
premium_index: Optional[float],
|
2021-09-09 01:31:04 +00:00
|
|
|
) -> float:
|
|
|
|
"""
|
|
|
|
Calculates a single funding fee
|
|
|
|
:param contract_size: The amount/quanity
|
|
|
|
:param mark_price: The price of the asset that the contract is based off of
|
|
|
|
:param funding_rate: the interest rate and the premium
|
|
|
|
- interest rate: 0.03% daily, BNBUSDT, LINKUSDT, and LTCUSDT are 0%
|
|
|
|
- premium: varies by price difference between the perpetual contract and mark price
|
|
|
|
"""
|
2021-09-10 22:28:34 +00:00
|
|
|
if premium_index is None:
|
2021-09-16 05:51:21 +00:00
|
|
|
raise OperationalException("Premium index cannot be None for Binance._get_funding_fee")
|
2021-09-09 01:31:04 +00:00
|
|
|
nominal_value = mark_price * contract_size
|
2021-09-16 04:28:10 +00:00
|
|
|
funding_rate = self._calculate_funding_rate(pair, premium_index)
|
|
|
|
if funding_rate is None:
|
|
|
|
raise OperationalException("Funding rate should never be none on Binance")
|
2021-09-16 05:51:21 +00:00
|
|
|
return nominal_value * funding_rate
|
2021-09-16 04:28:10 +00:00
|
|
|
|
|
|
|
async def _async_get_historic_ohlcv(self, pair: str, timeframe: str,
|
|
|
|
since_ms: int, is_new_pair: bool
|
|
|
|
) -> List:
|
|
|
|
"""
|
|
|
|
Overwrite to introduce "fast new pair" functionality by detecting the pair's listing date
|
|
|
|
Does not work for other exchanges, which don't return the earliest data when called with "0"
|
|
|
|
"""
|
|
|
|
if is_new_pair:
|
|
|
|
x = await self._async_get_candle_history(pair, timeframe, 0)
|
|
|
|
if x and x[2] and x[2][0] and x[2][0][0] > since_ms:
|
|
|
|
# Set starting date to first available candle.
|
|
|
|
since_ms = x[2][0][0]
|
|
|
|
logger.info(f"Candle-data for {pair} available starting with "
|
|
|
|
f"{arrow.get(since_ms // 1000).isoformat()}.")
|
|
|
|
return await super()._async_get_historic_ohlcv(
|
|
|
|
pair=pair, timeframe=timeframe, since_ms=since_ms, is_new_pair=is_new_pair)
|