async def get_current_balances(
self, # type: HummingbotApplication
market: str):
if market in self.markets and self.markets[market].ready:
return self.markets[market].get_all_balances()
elif "Paper" in market:
paper_balances = global_config_map[
"paper_trade_account_balance"].value
if paper_balances is None:
return {}
return {
token: Decimal(str(bal))
for token, bal in paper_balances.items()
}
elif "perpetual_finance" == market:
return await UserBalances.xdai_balances()
else:
gateway_eth_connectors = [
cs.name for cs in CONNECTOR_SETTINGS.values() if
cs.use_ethereum_wallet and cs.type == ConnectorType.Connector
]
if market in gateway_eth_connectors:
return await UserBalances.instance().eth_n_erc20_balances()
else:
await UserBalances.instance().update_exchange_balance(market)
return UserBalances.instance().all_balances(market)
async def fetch_all(self):
tasks = []
fetched_connectors = []
for conn_setting in CONNECTOR_SETTINGS.values():
module_name = f"{conn_setting.base_name()}_connector" if conn_setting.type is ConnectorType.Connector \
else f"{conn_setting.base_name()}_api_order_book_data_source"
module_path = f"hummingbot.connector.{conn_setting.type.name.lower()}." \
f"{conn_setting.base_name()}.{module_name}"
class_name = "".join([o.capitalize() for o in conn_setting.base_name().split("_")]) + \
"APIOrderBookDataSource" if conn_setting.type is not ConnectorType.Connector \
else "".join([o.capitalize() for o in conn_setting.base_name().split("_")]) + "Connector"
module = getattr(importlib.import_module(module_path), class_name)
args = {}
args = conn_setting.add_domain_parameter(args)
tasks.append(
asyncio.wait_for(asyncio.shield(
module.fetch_trading_pairs(**args)),
timeout=3))
fetched_connectors.append(conn_setting.name)
results = await safe_gather(*tasks, return_exceptions=True)
self.trading_pairs = dict(zip(fetched_connectors, results))
# In case trading pair fetching returned timeout, using empty list
for connector, result in self.trading_pairs.items():
if isinstance(result, asyncio.TimeoutError):
self.trading_pairs[connector] = []
self.ready = True
def __init__(self, hummingbot_application):
super(HummingbotCompleter, self).__init__()
self.hummingbot_application = hummingbot_application
self._path_completer = WordCompleter(
file_name_list(CONF_FILE_PATH, "yml"))
self._command_completer = WordCompleter(self.parser.commands,
ignore_case=True)
self._exchange_completer = WordCompleter(sorted(
CONNECTOR_SETTINGS.keys()),
ignore_case=True)
self._spot_completer = WordCompleter(sorted(
EXCHANGES.union(SPOT_PROTOCOL_CONNECTOR)),
ignore_case=True)
self._spot_exchange_completer = WordCompleter(sorted(EXCHANGES),
ignore_case=True)
self._derivative_completer = WordCompleter(DERIVATIVES,
ignore_case=True)
self._derivative_exchange_completer = WordCompleter(
DERIVATIVES.difference(DERIVATIVE_PROTOCOL_CONNECTOR),
ignore_case=True)
self._connect_option_completer = WordCompleter(CONNECT_OPTIONS,
ignore_case=True)
self._export_completer = WordCompleter(["keys", "trades"],
ignore_case=True)
self._balance_completer = WordCompleter(["limit", "paper"],
ignore_case=True)
self._history_completer = WordCompleter(
["--days", "--verbose", "--precision"], ignore_case=True)
self._gateway_completer = WordCompleter(
["generate_certs", "list-configs", "update"], ignore_case=True)
self._strategy_completer = WordCompleter(STRATEGIES, ignore_case=True)
self._py_file_completer = WordCompleter(
file_name_list(SCRIPTS_PATH, "py"))
self._rate_oracle_completer = WordCompleter(
[r.name for r in RateOracleSource], ignore_case=True)
async def gas_price_update_loop(self):
while True:
try:
url = ETH_GASSTATION_API_URL.format(self.api_key)
async with aiohttp.ClientSession() as client:
response = await client.get(url=url)
if response.status != 200:
raise IOError(f"Error fetching current gas prices. "
f"HTTP status is {response.status}.")
resp_data: Dict[str, Any] = await response.json()
for key, value in resp_data.items():
if key in GasLevel.__members__:
self._gas_prices[GasLevel[key]] = Decimal(
str(value)) / Decimal("10")
prices_str = ', '.join([
k.name + ': ' + str(v)
for k, v in self._gas_prices.items()
])
self.logger().info(f"Gas levels: [{prices_str}]")
for name, con_setting in CONNECTOR_SETTINGS.items():
if con_setting.use_eth_gas_lookup:
self._gas_limits[name] = get_gas_limit(name)
self.logger().info(
f"{name} Gas estimate:"
f" limit = {self._gas_limits[name]:.0f},"
f" price = {self.gas_level.name},"
f" estimated cost = {get_gas_price(False) * self._gas_limits[name]:.5f} ETH"
)
await asyncio.sleep(self.refresh_time)
except asyncio.CancelledError:
raise
except Exception:
self.logger().network("Unexpected error running logging task.",
exc_info=True)
await asyncio.sleep(self.refresh_time)
def _trading_pair_completer(self) -> Completer:
trading_pair_fetcher = TradingPairFetcher.get_instance()
for exchange in sorted(list(CONNECTOR_SETTINGS.keys()), key=len, reverse=True):
if exchange in self.prompt_text:
market = exchange
break
trading_pairs = trading_pair_fetcher.trading_pairs.get(market, []) if trading_pair_fetcher.ready else []
return WordCompleter(trading_pairs, ignore_case=True, sentence=True)
async def update_exchanges(
self,
reconnect: bool = False,
exchanges: List[str] = []) -> Dict[str, Optional[str]]:
tasks = []
# Update user balances, except connectors that use Ethereum wallet.
if len(exchanges) == 0:
exchanges = [cs.name for cs in CONNECTOR_SETTINGS.values()]
exchanges = [
cs.name for cs in CONNECTOR_SETTINGS.values()
if not cs.use_ethereum_wallet and cs.name in exchanges
]
if reconnect:
self._markets.clear()
for exchange in exchanges:
tasks.append(self.update_exchange_balance(exchange))
results = await safe_gather(*tasks)
return {ex: err_msg for ex, err_msg in zip(exchanges, results)}
def fee_overrides_dict():
all_dict = {}
# all_connector_types = get_exchanges_and_derivatives()
for name, setting in CONNECTOR_SETTINGS.items():
key_suffix = None
if setting.fee_type is TradeFeeType.Percent:
key_suffix = "fee"
elif setting.fee_type is TradeFeeType.FlatFee:
key_suffix = "fee_amount"
maker_key = f"{name}_maker_{key_suffix}"
taker_key = f"{name}_taker_{key_suffix}"
all_dict.update({maker_key: new_fee_config_var(maker_key)})
all_dict.update({taker_key: new_fee_config_var(taker_key)})
return all_dict
def __init__(self, hummingbot_application):
super(HummingbotCompleter, self).__init__()
self.hummingbot_application = hummingbot_application
self._path_completer = WordCompleter(file_name_list(CONF_FILE_PATH, "yml"))
self._command_completer = WordCompleter(self.parser.commands, ignore_case=True)
self._connector_completer = WordCompleter(CONNECTOR_SETTINGS.keys(), ignore_case=True)
self._exchange_completer = WordCompleter(EXCHANGES, ignore_case=True)
self._derivative_completer = WordCompleter(DERIVATIVES, ignore_case=True)
self._connect_option_completer = WordCompleter(CONNECT_OPTIONS, ignore_case=True)
self._export_completer = WordCompleter(["keys", "trades"], ignore_case=True)
self._balance_completer = WordCompleter(["limit", "paper"], ignore_case=True)
self._history_completer = WordCompleter(["--days", "--verbose", "--precision"], ignore_case=True)
self._strategy_completer = WordCompleter(STRATEGIES, ignore_case=True)
self._py_file_completer = WordCompleter(file_name_list(SCRIPTS_PATH, "py"))
async def fetch_all(self):
for conn_setting in CONNECTOR_SETTINGS.values():
module_name = f"{conn_setting.base_name()}_connector" if conn_setting.type is ConnectorType.Connector \
else f"{conn_setting.base_name()}_api_order_book_data_source"
module_path = f"hummingbot.connector.{conn_setting.type.name.lower()}." \
f"{conn_setting.base_name()}.{module_name}"
class_name = "".join([o.capitalize() for o in conn_setting.base_name().split("_")]) + \
"APIOrderBookDataSource" if conn_setting.type is not ConnectorType.Connector \
else "".join([o.capitalize() for o in conn_setting.base_name().split("_")]) + "Connector"
module = getattr(importlib.import_module(module_path), class_name)
args = {}
args = conn_setting.add_domain_parameter(args)
safe_ensure_future(
self.call_fetch_pairs(module.fetch_trading_pairs(**args),
conn_setting.name))
self.ready = True
async def get_current_balances(self, # type: HummingbotApplication
market: str):
paper_trade_suffix = '_PaperTrade'
if market in self.markets and self.markets[market].ready:
return self.markets[market].get_all_balances()
elif paper_trade_suffix in market:
return self.markets[market[:-len(paper_trade_suffix)]].get_all_balances()
elif "perpetual_finance" == market:
return await UserBalances.xdai_balances()
else:
gateway_eth_connectors = [cs.name for cs in CONNECTOR_SETTINGS.values() if cs.use_ethereum_wallet and
cs.type == ConnectorType.Connector]
if market in gateway_eth_connectors:
return await UserBalances.instance().eth_n_erc20_balances()
else:
await UserBalances.instance().update_exchange_balance(market)
return UserBalances.instance().all_balances(market)
async def fetch_all(self):
tasks = []
fetched_connectors = []
for conn_setting in CONNECTOR_SETTINGS.values():
module_name = f"{conn_setting.base_name()}_utils" if conn_setting.type is ConnectorType.Connector \
else f"{conn_setting.base_name()}_api_order_book_data_source"
module_path = f"hummingbot.connector.{conn_setting.type.name.lower()}." \
f"{conn_setting.base_name()}.{module_name}"
if conn_setting.type is ConnectorType.Connector:
module = importlib.import_module(module_path)
else:
class_name = "".join([o.capitalize() for o in conn_setting.base_name().split("_")]) + \
"APIOrderBookDataSource"
module = getattr(importlib.import_module(module_path),
class_name)
args = {}
args = conn_setting.add_domain_parameter(args)
tasks.append(module.fetch_trading_pairs(**args))
fetched_connectors.append(conn_setting.name)
results = await safe_gather(*tasks, return_exceptions=True)
self.trading_pairs = dict(zip(fetched_connectors, results))
self.ready = True
from hummingbot.client.command.connect_command import OPTIONS as CONNECT_OPTIONS
from hummingbot.core.rate_oracle.rate_oracle import RateOracleSource
def file_name_list(path, file_extension):
if not exists(path):
return []
return sorted([
f for f in listdir(path)
if isfile(join(path, f)) and f.endswith(file_extension)
])
SPOT_PROTOCOL_CONNECTOR = {
x.name
for x in CONNECTOR_SETTINGS.values() if x.type == ConnectorType.Connector
}
DERIVATIVE_PROTOCOL_CONNECTOR = {
x.name
for x in CONNECTOR_SETTINGS.values()
if x.type == ConnectorType.Derivative and not x.centralised
}
class HummingbotCompleter(Completer):
def __init__(self, hummingbot_application):
super(HummingbotCompleter, self).__init__()
self.hummingbot_application = hummingbot_application
self._path_completer = WordCompleter(
file_name_list(CONF_FILE_PATH, "yml"))
self._command_completer = WordCompleter(self.parser.commands,
