def validate_exchange(cls, v: str, field: Field):
"""Used for client-friendly error output."""
ret = validate_exchange(v)
if ret is not None:
raise ValueError(ret)
if field.name == "maker_market_trading_pair":
cls.__fields__[
"maker_market"].type_ = ClientConfigEnum( # rebuild the exchanges enum
value="Exchanges", # noqa: F821
names={
e: e
for e in
AllConnectorSettings.get_connector_settings().keys()
},
type=str,
)
if field.name == "taker_market_trading_pair":
cls.__fields__[
"taker_market"].type_ = ClientConfigEnum( # rebuild the exchanges enum
value="Exchanges", # noqa: F821
names={
e: e
for e in
AllConnectorSettings.get_connector_settings().keys()
},
type=str,
)
return v
def build_perpetual_trade_fee(
exchange: str,
is_maker: bool,
position_action: PositionAction,
base_currency: str,
quote_currency: str,
order_type: OrderType,
order_side: TradeType,
amount: Decimal,
price: Decimal = Decimal("NaN"),
) -> TradeFeeBase:
"""
WARNING: Do not use this method for order sizing. Use the `BudgetChecker` instead.
Uses the exchange's `TradeFeeSchema` to build a `TradeFee`, given the trade parameters.
"""
if exchange not in AllConnectorSettings.get_connector_settings():
raise Exception(
f"Invalid connector. {exchange} does not exist in AllConnectorSettings"
)
trade_fee_schema = AllConnectorSettings.get_connector_settings(
)[exchange].trade_fee_schema
trade_fee_schema = _superimpose_overrides(exchange, trade_fee_schema)
percent = trade_fee_schema.maker_percent_fee_decimal if is_maker else trade_fee_schema.taker_percent_fee_decimal
fee_cls = (AddedToCostTradeFee if position_action == PositionAction.OPEN
or trade_fee_schema.percent_fee_token is not None else
DeductedFromReturnsTradeFee)
fixed_fees = trade_fee_schema.maker_fixed_fees if is_maker else trade_fee_schema.taker_fixed_fees
trade_fee = fee_cls(percent, trade_fee_schema.percent_fee_token,
fixed_fees)
return trade_fee
async def update_exchanges(
self,
client_config_map: ClientConfigMap,
reconnect: bool = False,
exchanges: Optional[List[str]] = None) -> Dict[str, Optional[str]]:
exchanges = exchanges or []
tasks = []
# Update user balances
if len(exchanges) == 0:
exchanges = [
cs.name for cs in
AllConnectorSettings.get_connector_settings().values()
]
exchanges: List[str] = [
cs.name
for cs in AllConnectorSettings.get_connector_settings().values()
if not cs.use_ethereum_wallet and cs.name in exchanges
and not cs.name.endswith("paper_trade")
]
if reconnect:
self._markets.clear()
for exchange in exchanges:
tasks.append(
self.update_exchange_balance(exchange, client_config_map))
results = await safe_gather(*tasks)
return {ex: err_msg for ex, err_msg in zip(exchanges, results)}
def configured_schema_for_exchange(cls,
exchange_name: str) -> TradeFeeSchema:
if exchange_name not in AllConnectorSettings.get_connector_settings():
raise Exception(
f"Invalid connector. {exchange_name} does not exist in AllConnectorSettings"
)
trade_fee_schema = AllConnectorSettings.get_connector_settings(
)[exchange_name].trade_fee_schema
trade_fee_schema = cls._superimpose_overrides(exchange_name,
trade_fee_schema)
return trade_fee_schema
def connector_keys():
from hummingbot.client.settings import AllConnectorSettings
all_keys = {}
for connector_setting in AllConnectorSettings.get_connector_settings(
).values():
all_keys.update(connector_setting.config_keys)
return all_keys
def validate_connector(value: str) -> Optional[str]:
"""
Restrict valid derivatives to the connector file names
"""
from hummingbot.client.settings import AllConnectorSettings
if value not in AllConnectorSettings.get_connector_settings() and value != "celo":
return f"Invalid connector, please choose value from {AllConnectorSettings.get_connector_settings().keys()}"
async def fetch_all(self):
for conn_setting in AllConnectorSettings.get_connector_settings(
).values():
if conn_setting.base_name().endswith("paper_trade"):
if conn_setting.parent_name in self.trading_pairs:
self.trading_pairs[conn_setting.base_name(
)] = self.trading_pairs[conn_setting.parent_name]
continue
exchange_name = conn_setting.parent_name
else:
exchange_name = conn_setting.base_name()
module_name = f"{exchange_name}_connector" if conn_setting.type is ConnectorType.Connector \
else f"{exchange_name}_api_order_book_data_source"
module_path = f"hummingbot.connector.{conn_setting.type.name.lower()}." \
f"{exchange_name}.{module_name}"
class_name = "".join([o.capitalize() for o in exchange_name.split("_")]) + \
"APIOrderBookDataSource" if conn_setting.type is not ConnectorType.Connector \
else "".join([o.capitalize() for o in exchange_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_last_price(exchange: str,
trading_pair: str) -> Optional[Decimal]:
if exchange in AllConnectorSettings.get_connector_settings():
conn_setting = AllConnectorSettings.get_connector_settings()[exchange]
if AllConnectorSettings.get_connector_settings()[exchange].type in [
ConnectorType.Exchange, ConnectorType.Derivative
]:
try:
connector = conn_setting.non_trading_connector_instance_with_default_configuration(
)
last_prices = await connector.get_last_traded_prices(
trading_pairs=[trading_pair])
if last_prices:
return Decimal(str(last_prices[trading_pair]))
except ModuleNotFoundError:
pass
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
AllConnectorSettings.get_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 get_last_price(exchange: str, trading_pair: str) -> Optional[Decimal]:
if exchange in AllConnectorSettings.get_connector_settings():
conn_setting = AllConnectorSettings.get_connector_settings()[exchange]
if AllConnectorSettings.get_connector_settings()[exchange].type in (ConnectorType.Exchange, ConnectorType.Derivative):
module_name = f"{conn_setting.base_name()}_api_order_book_data_source"
class_name = "".join([o.capitalize() for o in conn_setting.base_name().split("_")]) + \
"APIOrderBookDataSource"
module_path = f"hummingbot.connector.{conn_setting.type.name.lower()}." \
f"{conn_setting.base_name()}.{module_name}"
module = getattr(importlib.import_module(module_path), class_name)
args = {"trading_pairs": [trading_pair]}
if conn_setting.is_sub_domain:
args["domain"] = conn_setting.domain_parameter
last_prices = await module.get_last_traded_prices(**args)
if last_prices:
return Decimal(str(last_prices[trading_pair]))
def fee_overrides_dict():
all_dict = {}
# all_connector_types = get_exchanges_and_derivatives()
for name in AllConnectorSettings.get_connector_settings().keys():
all_dict.update({
f"{name}_percent_fee_token":
new_fee_config_var(f"{name}_percent_fee_token", type_str="str")
})
all_dict.update({
f"{name}_maker_percent_fee":
new_fee_config_var(f"{name}_maker_percent_fee", type_str="decimal")
})
all_dict.update({
f"{name}_taker_percent_fee":
new_fee_config_var(f"{name}_taker_percent_fee", type_str="decimal")
})
fee_application = f"{name}_buy_percent_fee_deducted_from_returns"
all_dict.update({
fee_application:
new_fee_config_var(fee_application, type_str="bool")
})
all_dict.update({
f"{name}_maker_fixed_fees":
new_fee_config_var(f"{name}_maker_fixed_fees", type_str="list")
})
all_dict.update({
f"{name}_taker_fixed_fees":
new_fee_config_var(f"{name}_taker_fixed_fees", type_str="list")
})
return all_dict
def __init__(self, hummingbot_application):
super(HummingbotCompleter, self).__init__()
self.hummingbot_application = hummingbot_application
self._path_completer = WordCompleter(file_name_list(str(STRATEGIES_CONF_DIR_PATH), "yml"))
self._command_completer = WordCompleter(self.parser.commands, ignore_case=True)
self._exchange_completer = WordCompleter(sorted(AllConnectorSettings.get_connector_settings().keys()), ignore_case=True)
self._spot_exchange_completer = WordCompleter(sorted(AllConnectorSettings.get_exchange_names()), ignore_case=True)
self._exchange_amm_completer = WordCompleter(sorted(AllConnectorSettings.get_exchange_names().union(AllConnectorSettings.get_gateway_evm_amm_connector_names())), ignore_case=True)
self._evm_amm_lp_completer = WordCompleter(sorted(AllConnectorSettings.get_gateway_evm_amm_lp_connector_names()), ignore_case=True)
self._trading_timeframe_completer = WordCompleter(["infinite", "from_date_to_date", "daily_between_times"], ignore_case=True)
self._derivative_completer = WordCompleter(AllConnectorSettings.get_derivative_names(), ignore_case=True)
self._derivative_exchange_completer = WordCompleter(AllConnectorSettings.get_derivative_names().difference(AllConnectorSettings.get_derivative_dex_names()), 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(["create", "config", "connect", "connector-tokens", "generate-certs", "status", "test-connection", "start", "stop"], ignore_case=True)
self._gateway_connect_completer = WordCompleter(GATEWAY_CONNECTORS, ignore_case=True)
self._gateway_connector_tokens_completer = WordCompleter(sorted(AllConnectorSettings.get_gateway_evm_amm_connector_names()), ignore_case=True)
self._gateway_config_completer = WordCompleter(hummingbot_application.gateway_config_keys, ignore_case=True)
self._strategy_completer = WordCompleter(STRATEGIES, ignore_case=True)
self._py_file_completer = WordCompleter(file_name_list(str(PMM_SCRIPTS_PATH), "py"))
self._script_strategy_completer = WordCompleter(file_name_list(str(SCRIPT_STRATEGIES_PATH), "py"))
self._rate_oracle_completer = WordCompleter([r.name for r in RateOracleSource], ignore_case=True)
self._gateway_networks = []
self._list_gateway_wallets_parameters = {"wallets": [], "chain": ""}
def _initialize_markets(self, market_names: List[Tuple[str, List[str]]]):
# aggregate trading_pairs if there are duplicate markets
for market_name, trading_pairs in market_names:
if market_name not in self.market_trading_pairs_map:
self.market_trading_pairs_map[market_name] = []
for hb_trading_pair in trading_pairs:
self.market_trading_pairs_map[market_name].append(hb_trading_pair)
for connector_name, trading_pairs in self.market_trading_pairs_map.items():
conn_setting = AllConnectorSettings.get_connector_settings()[connector_name]
if connector_name.endswith("paper_trade") and conn_setting.type == ConnectorType.Exchange:
connector = create_paper_trade_market(conn_setting.parent_name, self.client_config_map, trading_pairs)
paper_trade_account_balance = self.client_config_map.paper_trade.paper_trade_account_balance
if paper_trade_account_balance is not None:
for asset, balance in paper_trade_account_balance.items():
connector.set_balance(asset, balance)
else:
keys = Security.api_keys(connector_name)
init_params = conn_setting.conn_init_parameters(keys)
init_params.update(trading_pairs=trading_pairs, trading_required=self._trading_required)
connector_class = get_connector_class(connector_name)
read_only_config = ReadOnlyClientConfigAdapter.lock_config(self.client_config_map)
connector = connector_class(read_only_config, **init_params)
self.markets[connector_name] = connector
self.markets_recorder = MarketsRecorder(
self.trade_fill_db,
list(self.markets.values()),
self.strategy_file_name,
self.strategy_name,
)
self.markets_recorder.start()
def connect_market(exchange, **api_details):
connector = None
conn_setting = AllConnectorSettings.get_connector_settings()[exchange]
if not conn_setting.use_ethereum_wallet:
connector_class = get_connector_class(exchange)
init_params = conn_setting.conn_init_parameters(api_details)
connector = connector_class(**init_params)
return connector
def create_paper_trade_market(exchange_name: str, trading_pairs: List[str]):
obt_class = get_order_book_tracker_class(exchange_name)
conn_setting = AllConnectorSettings.get_connector_settings()[exchange_name]
obt_params = {"trading_pairs": trading_pairs}
obt_kwargs = conn_setting.add_domain_parameter(obt_params)
obt_obj = obt_class(**obt_kwargs)
return PaperTradeExchange(obt_obj,
get_connector_class(exchange_name))
def get_order_book_tracker(connector_name: str, trading_pairs: List[str]) -> OrderBookTracker:
conn_setting = AllConnectorSettings.get_connector_settings()[connector_name]
try:
connector_instance = conn_setting.non_trading_connector_instance_with_default_configuration(
trading_pairs=trading_pairs)
return connector_instance.order_book_tracker
except Exception as exception:
raise Exception(f"Connector {connector_name} OrderBookTracker class not found ({exception})")
async def api_keys(cls, exchange):
await cls.wait_til_decryption_done()
exchange_configs = [
c for c in global_config_map.values()
if c.key in AllConnectorSettings.get_connector_settings()
[exchange].config_keys and c.key in cls._secure_configs
]
return {c.key: cls.decrypted_value(c.key) for c in exchange_configs}
def _trading_pair_completer(self) -> Completer:
trading_pair_fetcher = TradingPairFetcher.get_instance()
market = ""
for exchange in sorted(list(AllConnectorSettings.get_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 and market else []
return WordCompleter(trading_pairs, ignore_case=True, sentence=True)
def _initialize_markets(self, market_names: List[Tuple[str, List[str]]]):
# aggregate trading_pairs if there are duplicate markets
for market_name, trading_pairs in market_names:
if market_name not in self.market_trading_pairs_map:
self.market_trading_pairs_map[market_name] = []
for hb_trading_pair in trading_pairs:
self.market_trading_pairs_map[market_name].append(
hb_trading_pair)
for connector_name, trading_pairs in self.market_trading_pairs_map.items(
):
conn_setting = AllConnectorSettings.get_connector_settings(
)[connector_name]
if connector_name.endswith(
"paper_trade"
) and conn_setting.type == ConnectorType.Exchange:
connector = create_paper_trade_market(conn_setting.parent_name,
trading_pairs)
paper_trade_account_balance = global_config_map.get(
"paper_trade_account_balance").value
if paper_trade_account_balance is not None:
for asset, balance in paper_trade_account_balance.items():
connector.set_balance(asset, balance)
else:
Security.update_config_map(global_config_map)
keys = {
key: config.value
for key, config in global_config_map.items()
if key in conn_setting.config_keys
}
init_params = conn_setting.conn_init_parameters(keys)
init_params.update(trading_pairs=trading_pairs,
trading_required=self._trading_required)
if conn_setting.use_ethereum_wallet:
ethereum_rpc_url = global_config_map.get(
"ethereum_rpc_url").value
# Todo: Hard coded this execption for now until we figure out how to handle all ethereum connectors.
if connector_name in [
"balancer", "uniswap", "uniswap_v3",
"perpetual_finance"
]:
private_key = get_eth_wallet_private_key()
init_params.update(wallet_private_key=private_key,
ethereum_rpc_url=ethereum_rpc_url)
connector_class = get_connector_class(connector_name)
connector = connector_class(**init_params)
self.markets[connector_name] = connector
self.markets_recorder = MarketsRecorder(
self.trade_fill_db,
list(self.markets.values()),
self.strategy_file_name,
self.strategy_name,
)
self.markets_recorder.start()
def connect_market(exchange, **api_details):
connector = None
conn_setting = AllConnectorSettings.get_connector_settings()[exchange]
if api_details or conn_setting.uses_gateway_generic_connector():
connector_class = get_connector_class(exchange)
init_params = conn_setting.conn_init_parameters(api_details)
init_params.update(trading_pairs=gateway_connector_trading_pairs(
conn_setting.name))
connector = connector_class(**init_params)
return connector
def get_order_book_tracker_class(connector_name: str) -> Callable:
conn_setting = AllConnectorSettings.get_connector_settings()[connector_name]
module_name = f"{conn_setting.base_name()}_order_book_tracker"
class_name = "".join([o.capitalize() for o in module_name.split("_")])
try:
mod = __import__(f'hummingbot.connector.{conn_setting.type.name.lower()}.{conn_setting.base_name()}.'
f'{module_name}',
fromlist=[class_name])
return getattr(mod, class_name)
except Exception:
pass
raise Exception(f"Connector {connector_name} OrderBookTracker class not found")
async def connect_exchange(self, # type: HummingbotApplication
exchange):
self.app.clear_input()
self.placeholder_mode = True
self.app.hide_input = True
if exchange == "kraken":
self._notify("Reminder: Please ensure your Kraken API Key Nonce Window is at least 10.")
exchange_configs = [c for c in global_config_map.values()
if c.key in AllConnectorSettings.get_connector_settings()[exchange].config_keys and c.is_connect_key]
to_connect = True
if Security.encrypted_file_exists(exchange_configs[0].key):
await Security.wait_til_decryption_done()
api_key_config = [c for c in exchange_configs if "api_key" in c.key]
if api_key_config:
api_key_config = api_key_config[0]
api_key = Security.decrypted_value(api_key_config.key)
prompt = f"Would you like to replace your existing {exchange} API key {api_key} (Yes/No)? >>> "
else:
prompt = f"Would you like to replace your existing {exchange_configs[0].key} (Yes/No)? >>> "
answer = await self.app.prompt(prompt=prompt)
if self.app.to_stop_config:
self.app.to_stop_config = False
return
if answer.lower() not in ("yes", "y"):
to_connect = False
if to_connect:
for config in exchange_configs:
await self.prompt_a_config(config)
if self.app.to_stop_config:
self.app.to_stop_config = False
return
Security.update_secure_config(config.key, config.value)
api_keys = await Security.api_keys(exchange)
network_timeout = float(global_config_map["other_commands_timeout"].value)
try:
err_msg = await asyncio.wait_for(
UserBalances.instance().add_exchange(exchange, **api_keys), network_timeout
)
except asyncio.TimeoutError:
self._notify("\nA network error prevented the connection to complete. See logs for more details.")
self.placeholder_mode = False
self.app.hide_input = False
self.app.change_prompt(prompt=">>> ")
raise
if err_msg is None:
self._notify(f"\nYou are now connected to {exchange}.")
else:
self._notify(f"\nError: {err_msg}")
self.placeholder_mode = False
self.app.hide_input = False
self.app.change_prompt(prompt=">>> ")
async def exchange_balances_extra_df(
self, # type: HummingbotApplication
exchange: str,
ex_balances: Dict[str, Decimal],
ex_avai_balances: Dict[str, Decimal]):
conn_setting = AllConnectorSettings.get_connector_settings()[exchange]
total_col_name = f"Total ({RateOracle.global_token_symbol})"
allocated_total = Decimal("0")
rows = []
for token, bal in ex_balances.items():
avai = Decimal(ex_avai_balances.get(
token.upper(),
0)) if ex_avai_balances is not None else Decimal(0)
# show zero balances if it is a gateway connector (the user manually
# chose to show those values with 'gateway connector-tokens')
if conn_setting.uses_gateway_generic_connector():
if bal == Decimal(0):
allocated = "0%"
else:
allocated = f"{(bal - avai) / bal:.0%}"
else:
# the exchange is CEX. Only show balance if non-zero.
if bal == Decimal(0):
continue
allocated = f"{(bal - avai) / bal:.0%}"
rate = await RateOracle.global_rate(token)
rate = Decimal("0") if rate is None else rate
global_value = rate * bal
allocated_total += rate * (bal - avai)
rows.append({
"Asset":
token.upper(),
"Total":
round(bal, 4),
total_col_name:
PerformanceMetrics.smart_round(global_value),
"sum_not_for_show":
global_value,
"Allocated":
allocated,
})
df = pd.DataFrame(data=rows,
columns=[
"Asset", "Total", total_col_name,
"sum_not_for_show", "Allocated"
])
df.sort_values(by=["Asset"], inplace=True)
return df, allocated_total
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(AllConnectorSettings.get_connector_settings().keys()), ignore_case=True)
self._spot_completer = WordCompleter(sorted(AllConnectorSettings.get_exchange_names().union(SPOT_PROTOCOL_CONNECTOR)), ignore_case=True)
self._spot_exchange_completer = WordCompleter(sorted(AllConnectorSettings.get_exchange_names()), ignore_case=True)
self._trading_timeframe_completer = WordCompleter(["infinite", "from_date_to_date", "daily_between_times"], ignore_case=True)
self._derivative_completer = WordCompleter(AllConnectorSettings.get_derivative_names(), ignore_case=True)
self._derivative_exchange_completer = WordCompleter(AllConnectorSettings.get_derivative_names().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 fetch_all(self):
for conn_setting in AllConnectorSettings.get_connector_settings(
).values():
if conn_setting.base_name().endswith("paper_trade"):
if conn_setting.parent_name in self.trading_pairs:
self.trading_pairs[conn_setting.base_name(
)] = self.trading_pairs[conn_setting.parent_name]
continue
exchange_name = conn_setting.parent_name
else:
exchange_name = conn_setting.base_name()
module_name = f"{exchange_name}_api_order_book_data_source"
module_path = f"hummingbot.connector.{conn_setting.type.name.lower()}." \
f"{exchange_name}.{module_name}" if not conn_setting.uses_gateway_generic_connector() \
else conn_setting.module_path()
class_name = "".join([o.capitalize() for o in exchange_name.split("_")]) + \
"APIOrderBookDataSource" if not conn_setting.uses_gateway_generic_connector() \
else conn_setting.class_name()
# XXX(martin_kou): Some connectors, e.g. uniswap v3, aren't completed yet. Ignore if you can't find the
# data source module for them.
try:
module = getattr(importlib.import_module(module_path),
class_name)
except ModuleNotFoundError:
continue
args = {}
args = conn_setting.add_domain_parameter(args)
if conn_setting.uses_gateway_generic_connector():
connector_params = conn_setting.name.split("_")
safe_ensure_future(
self.call_fetch_pairs(
module.fetch_trading_pairs(connector_params[1],
connector_params[2]),
conn_setting.name))
else:
safe_ensure_future(
self.call_fetch_pairs(module.fetch_trading_pairs(**args),
conn_setting.name))
self.ready = True
def fee_overrides_dict() -> Dict[str, ConfigVar]:
all_configs: Dict[str, ConfigVar] = {}
for name in AllConnectorSettings.get_connector_settings().keys():
all_configs.update({
f"{name}_percent_fee_token":
new_fee_config_var(f"{name}_percent_fee_token", type_str="str"),
f"{name}_maker_percent_fee":
new_fee_config_var(f"{name}_maker_percent_fee",
type_str="decimal"),
f"{name}_taker_percent_fee":
new_fee_config_var(f"{name}_taker_percent_fee",
type_str="decimal"),
f"{name}_buy_percent_fee_deducted_from_returns":
new_fee_config_var(f"{name}_buy_percent_fee_deducted_from_returns",
type_str="bool"),
f"{name}_maker_fixed_fees":
new_fee_config_var(f"{name}_maker_fixed_fees", type_str="list"),
f"{name}_taker_fixed_fees":
new_fee_config_var(f"{name}_taker_fixed_fees", type_str="list"),
})
return all_configs
def get_order_book_tracker(connector_name: str, trading_pairs: List[str]) -> OrderBookTracker:
conn_setting = AllConnectorSettings.get_connector_settings()[connector_name]
tracker_params = {"trading_pairs": trading_pairs}
tracker_kwargs = conn_setting.add_domain_parameter(tracker_params)
module_name = f"{conn_setting.base_name()}_order_book_tracker"
class_name = "".join([o.capitalize() for o in module_name.split("_")])
try:
mod = importlib.import_module(f'hummingbot.connector.{conn_setting.type.name.lower()}.'
f'{conn_setting.base_name()}.{module_name}')
tracker_class = getattr(mod, class_name)
return tracker_class(**tracker_kwargs)
except ModuleNotFoundError:
module_name = f"{conn_setting.base_name()}_api_order_book_data_source"
class_name = f"{conn_setting.base_name().capitalize()}APIOrderBookDataSource"
mod = importlib.import_module(f'hummingbot.connector.{conn_setting.type.name.lower()}.'
f'{conn_setting.base_name()}.{module_name}')
data_source_class = getattr(mod, class_name)
data_source = data_source_class(**tracker_kwargs)
return OrderBookTracker(data_source=data_source, **tracker_kwargs)
except Exception as exception:
raise Exception(f"Connector {connector_name} OrderBookTracker class not found ({exception})")
def connect_market(exchange, client_config_map: ClientConfigMap,
**api_details):
connector = None
conn_setting = AllConnectorSettings.get_connector_settings()[exchange]
if api_details or conn_setting.uses_gateway_generic_connector():
connector_class = get_connector_class(exchange)
init_params = conn_setting.conn_init_parameters(api_details)
# collect trading pairs from the gateway connector settings
trading_pairs: List[str] = gateway_connector_trading_pairs(
conn_setting.name)
# collect unique trading pairs that are for balance reporting only
config: Optional[Dict[
str,
str]] = GatewayConnectionSetting.get_connector_spec_from_market_name(
conn_setting.name)
if config is not None:
existing_pairs = set(
flatten([x.split("-") for x in trading_pairs]))
other_tokens: Set[str] = set(
config.get("tokens", "").split(","))
other_tokens.discard("")
tokens: List[str] = [
t for t in other_tokens if t not in existing_pairs
]
if tokens != [""]:
trading_pairs.append("-".join(tokens))
read_only_client_config = ReadOnlyClientConfigAdapter.lock_config(
client_config_map)
init_params.update(
trading_pairs=gateway_connector_trading_pairs(
conn_setting.name),
client_config_map=read_only_client_config,
)
connector = connector_class(**init_params)
return connector
def _all_connector_settings(self) -> Dict[str, ConnectorSetting]:
# Method created to enabling patching in unit tests
return AllConnectorSettings.get_connector_settings()
from typing import TYPE_CHECKING, Optional
from hummingbot.client.settings import AllConnectorSettings, GLOBAL_CONFIG_PATH
from hummingbot.client.config.security import Security
from hummingbot.core.utils.async_utils import safe_ensure_future
from hummingbot.client.config.global_config_map import global_config_map
from hummingbot.user.user_balances import UserBalances
from hummingbot.client.config.config_helpers import save_to_yml
from hummingbot.connector.other.celo.celo_cli import CeloCLI
from hummingbot.connector.connector_status import get_connector_status
if TYPE_CHECKING:
from hummingbot.client.hummingbot_application import HummingbotApplication
OPTIONS = {
cs.name
for cs in AllConnectorSettings.get_connector_settings().values()
if not cs.use_ethereum_wallet
}.union({"ethereum", "celo"})
class ConnectCommand:
def connect(
self, # type: HummingbotApplication
option: str):
if option is None:
safe_ensure_future(self.show_connections())
elif option == "ethereum":
safe_ensure_future(self.connect_ethereum())
elif option == "celo":
safe_ensure_future(self.connect_celo())
else:
