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()
async def update_exchange_balance(
self, exchange_name: str,
client_config_map: ClientConfigMap) -> Optional[str]:
is_gateway_market = self.is_gateway_market(exchange_name)
if is_gateway_market and exchange_name in self._markets:
# we want to refresh gateway connectors always, since the applicable tokens change over time.
# doing this will reinitialize and fetch balances for active trading pair
del self._markets[exchange_name]
if exchange_name in self._markets:
return await self._update_balances(self._markets[exchange_name])
else:
await Security.wait_til_decryption_done()
api_keys = Security.api_keys(
exchange_name) if not is_gateway_market else {}
return await self.add_exchange(exchange_name, client_config_map,
**api_keys)
def test_login(self):
password = "******"
secrets_manager = ETHKeyFileSecretManger(password)
store_password_verification(secrets_manager)
Security.login(secrets_manager)
config_map = self.store_binance_config()
self.async_run_with_timeout(Security.wait_til_decryption_done(), timeout=2)
self.assertTrue(Security.is_decryption_done())
self.assertTrue(Security.any_secure_configs())
self.assertTrue(Security.connector_config_file_exists(self.connector))
api_keys = Security.api_keys(self.connector)
expected_keys = api_keys_from_connector_config_map(config_map)
self.assertEqual(expected_keys, api_keys)
