def test_update_secure_config(self):
password = "******"
secrets_manager = ETHKeyFileSecretManger(password)
store_password_verification(secrets_manager)
Security.login(secrets_manager)
binance_config = ClientConfigAdapter(
BinanceConfigMap(binance_api_key=self.api_key, binance_api_secret=self.api_secret)
)
self.async_run_with_timeout(Security.wait_til_decryption_done())
Security.update_secure_config(binance_config)
self.reset_security()
Security.login(secrets_manager)
self.async_run_with_timeout(Security.wait_til_decryption_done(), timeout=2)
binance_loaded_config = Security.decrypted_value(binance_config.connector)
self.assertEqual(binance_config, binance_loaded_config)
binance_config.binance_api_key = "someOtherApiKey"
Security.update_secure_config(binance_config)
self.reset_security()
Security.login(secrets_manager)
self.async_run_with_timeout(Security.wait_til_decryption_done(), timeout=2)
binance_loaded_config = Security.decrypted_value(binance_config.connector)
self.assertEqual(binance_config, binance_loaded_config)
def setUp(self) -> None:
super().setUp()
self.strategy = None
self.markets = {"binance": ExchangeBase(client_config_map=ClientConfigAdapter(ClientConfigMap()))}
self.notifications = []
self.log_records = []
self.base = "ETH"
self.quote = "BTC"
self.strategy_config_map = ClientConfigAdapter(
AvellanedaMarketMakingConfigMap(
exchange="binance",
market=combine_to_hb_trading_pair(self.base, self.quote),
execution_timeframe_mode=FromDateToDateModel(
start_datetime="2021-11-18 15:00:00",
end_datetime="2021-11-18 16:00:00",
),
order_amount=60,
order_refresh_time=60,
hanging_orders_mode=TrackHangingOrdersModel(
hanging_orders_cancel_pct=1,
),
order_levels_mode=MultiOrderLevelModel(
order_levels=4,
level_distances=1,
),
min_spread=2,
risk_factor=1.11,
order_amount_shape_factor=0.33,
)
)
self.raise_exception_for_market_initialization = False
self._logger = None
async def _test_create_arb_proposals(self):
market_info1 = MarketTradingPairTuple(
MockConnector1(
client_config_map=ClientConfigAdapter(ClientConfigMap())),
trading_pair, base, quote)
market_info2 = MarketTradingPairTuple(
MockConnector2(
client_config_map=ClientConfigAdapter(ClientConfigMap())),
trading_pair, base, quote)
arb_proposals = await utils.create_arb_proposals(
market_info1, market_info2, [], [], Decimal("1"))
# there are 2 proposal combination possible - (buy_1, sell_2) and (buy_2, sell_1)
self.assertEqual(2, len(arb_proposals))
# Each proposal has a buy and a sell proposal sides
self.assertNotEqual(arb_proposals[0].first_side.is_buy,
arb_proposals[0].second_side.is_buy)
self.assertNotEqual(arb_proposals[1].first_side.is_buy,
arb_proposals[1].second_side.is_buy)
buy_1_sell_2_profit_pct = (Decimal("100") -
Decimal("105")) / Decimal("105")
self.assertEqual(buy_1_sell_2_profit_pct,
arb_proposals[0].profit_pct())
buy_2_sell_1_profit_pct = (Decimal("104") -
Decimal("103")) / Decimal("103")
self.assertEqual(buy_2_sell_1_profit_pct,
arb_proposals[1].profit_pct())
def migrate_global_config() -> List[str]:
global celo_address
logging.getLogger().info("\nMigrating the global config...")
global_config_path = CONF_DIR_PATH / "conf_global.yml"
errors = []
if global_config_path.exists():
with open(str(global_config_path), "r") as f:
data = yaml.safe_load(f)
del data["template_version"]
client_config_map = ClientConfigAdapter(ClientConfigMap())
_migrate_global_config_modes(client_config_map, data)
data.pop("kraken_api_tier", None)
data.pop("key_file_path", None)
celo_address = data.pop("celo_address", None)
keys = list(data.keys())
for key in keys:
if key in client_config_map.keys():
_migrate_global_config_field(client_config_map, data, key)
for key in data:
logging.getLogger().warning(f"Global ConfigVar {key} was not migrated.")
errors.extend(client_config_map.validate_model())
if len(errors) == 0:
save_to_yml(CLIENT_CONFIG_PATH, client_config_map)
global_config_path.unlink()
logging.getLogger().info("\nSuccessfully migrated the global config.")
else:
errors = [f"client_config_map - {e}" for e in errors]
logging.getLogger().error(f"The migration of the global config map failed with errors: {errors}")
return errors
def test_import_incomplete_config_file_success(
self, status_check_all_mock: AsyncMock,
get_strategy_pydantic_config_cls: MagicMock):
strategy_name = "perpetual_market_making"
strategy_file_name = f"{strategy_name}.yml"
status_check_all_mock.return_value = True
dummy_strategy_config_cls = self.build_dummy_strategy_config_cls(
strategy_name)
get_strategy_pydantic_config_cls.return_value = dummy_strategy_config_cls
cm = ClientConfigAdapter(
dummy_strategy_config_cls(no_default="some value"))
with TemporaryDirectory() as d:
d = Path(d)
import_command.STRATEGIES_CONF_DIR_PATH = d
temp_file_name = d / strategy_file_name
cm_yml_str = cm.generate_yml_output_str_with_comments()
cm_yml_str = cm_yml_str.replace("\nno_default: some value\n", "")
with open(temp_file_name, "w+") as outfile:
outfile.write(cm_yml_str)
self.async_run_with_timeout(
self.app.import_config_file(strategy_file_name))
self.assertEqual(strategy_file_name, self.app.strategy_file_name)
self.assertEqual(strategy_name, self.app.strategy_name)
self.assertTrue(
self.cli_mock_assistant.check_log_called_with(
"\nEnter \"start\" to start market making."))
self.assertNotEqual(cm, self.app.strategy_config_map)
validation_errors = self.app.strategy_config_map.validate_model()
self.assertEqual(1, len(validation_errors))
self.assertEqual("no_default - field required", validation_errors[0])
async def prompt_a_config(
self, # type: HummingbotApplication
model: ClientConfigAdapter,
config: str,
input_value=None,
assign_default=True,
):
config_path = config.split(".")
while len(config_path) != 1:
sub_model_attr = config_path.pop(0)
model = getattr(model, sub_model_attr)
config = config_path[0]
if input_value is None:
prompt = await model.get_client_prompt(config)
if prompt is not None:
if assign_default:
default = model.get_default(config)
default = str(default) if default is not None else ""
self.app.set_text(default)
prompt = f"{prompt} >>> "
client_data = model.get_client_data(config)
input_value = await self.app.prompt(prompt=prompt, is_password=client_data.is_secure)
new_config_value = None
if not self.app.to_stop_config and input_value is not None:
try:
setattr(model, config, input_value)
new_config_value = getattr(model, config)
except ConfigValidationError as e:
self.notify(str(e))
new_config_value = await self.prompt_a_config(model, config)
if not self.app.to_stop_config and isinstance(new_config_value, ClientConfigAdapter):
await self.prompt_for_model_config(new_config_value)
def _migrate_global_config_field(
cm: ClientConfigAdapter, global_config_data: Dict[str, Any], attr: str, cm_attr: Optional[str] = None
):
value = global_config_data.pop(attr)
cm_attr = cm_attr if cm_attr is not None else attr
if value is not None:
cm.setattr_no_validation(cm_attr, value)
async def prompt_for_model_config(
self, # type: HummingbotApplication
config_map: ClientConfigAdapter,
):
for key in config_map.keys():
client_data = config_map.get_client_data(key)
if (
client_data is not None
and (client_data.prompt_on_new or config_map.is_required(key))
):
await self.prompt_a_config(config_map, key)
if self.app.to_stop_config:
break
def build_config_map(cm: ClientConfigAdapter, cs: Dict):
"""This routine can be used in the create command, with slight modifications."""
for key in cm.keys():
client_data = cm.get_client_data(key)
if client_data is not None and client_data.prompt_on_new:
self.assertIsInstance(client_data.prompt(cm), str)
if key == "execution_timeframe_model":
setattr(cm, key,
"daily_between_times") # simulate user input
else:
setattr(cm, key, cs[key])
new_value = getattr(cm, key)
if isinstance(new_value, ClientConfigAdapter):
build_config_map(new_value, cs[key])
def setUp(self):
self.maxDiff = None
self.clock: Clock = Clock(ClockMode.BACKTEST, 1.0,
self.start_timestamp, self.end_timestamp)
self.market_1: MockPaperExchange = MockPaperExchange(
client_config_map=ClientConfigAdapter(ClientConfigMap()))
self.market_2: MockPaperExchange = MockPaperExchange(
client_config_map=ClientConfigAdapter(ClientConfigMap()))
self.market_1.set_balanced_order_book(self.market_1_trading_pairs[0],
1.0, 0.5, 1.5, 0.01, 10)
self.market_2.set_balanced_order_book(self.market_2_trading_pairs[0],
1.0, 0.5, 1.5, 0.005, 5)
self.market_1.set_balance("COINALPHA", 500)
self.market_1.set_balance("WETH", 500)
self.market_2.set_balance("COINALPHA", 500)
self.market_2.set_balance("ETH", 500)
self.market_1.set_quantization_param(
QuantizationParams(self.market_1_trading_pairs[0], 5, 5, 5, 5))
self.market_2.set_quantization_param(
QuantizationParams(self.market_2_trading_pairs[0], 5, 5, 5, 5))
self.market_trading_pair_tuple_1 = MarketTradingPairTuple(
*([self.market_1] + self.market_1_trading_pairs))
self.market_trading_pair_tuple_2 = MarketTradingPairTuple(
*([self.market_2] + self.market_2_trading_pairs))
self.market_pair: ArbitrageMarketPair = ArbitrageMarketPair(
self.market_trading_pair_tuple_1, self.market_trading_pair_tuple_2)
self.logging_options: int = ArbitrageStrategy.OPTION_LOG_ALL
self.strategy: ArbitrageStrategy = ArbitrageStrategy()
self.strategy.init_params(
[self.market_pair],
min_profitability=Decimal("0.03"),
logging_options=self.logging_options,
secondary_to_primary_quote_conversion_rate=Decimal("0.95"))
self.clock.add_iterator(self.market_1)
self.clock.add_iterator(self.market_2)
self.clock.add_iterator(self.strategy)
self.market_1_order_fill_logger: EventLogger = EventLogger()
self.market_2_order_fill_logger: EventLogger = EventLogger()
self.market_1.add_listener(MarketEvent.OrderFilled,
self.market_1_order_fill_logger)
self.market_2.add_listener(MarketEvent.OrderFilled,
self.market_2_order_fill_logger)
def test_create_paper_trade_market_for_connector_using_generic_tracker(
self):
paper_exchange = create_paper_trade_market(
exchange_name="binance",
client_config_map=ClientConfigAdapter(ClientConfigMap()),
trading_pairs=["COINALPHA-HBOT"])
self.assertEqual(BinanceAPIOrderBookDataSource,
type(paper_exchange.order_book_tracker.data_source))
paper_exchange = create_paper_trade_market(
exchange_name="kucoin",
client_config_map=ClientConfigAdapter(ClientConfigMap()),
trading_pairs=["COINALPHA-HBOT"])
self.assertEqual(KucoinAPIOrderBookDataSource,
type(paper_exchange.order_book_tracker.data_source))
def setUp(self):
self.clock: Clock = Clock(ClockMode.REALTIME)
self.stack: contextlib.ExitStack = contextlib.ExitStack()
self.amm_1: MockAMM = MockAMM(
name="onion",
client_config_map=ClientConfigAdapter(ClientConfigMap()))
self.amm_1.set_balance(BASE_ASSET, 500)
self.amm_1.set_balance(QUOTE_ASSET, 500)
self.market_info_1 = MarketTradingPairTuple(self.amm_1, TRADING_PAIR, BASE_ASSET, QUOTE_ASSET)
self.amm_2: MockAMM = MockAMM(
name="garlic",
client_config_map=ClientConfigAdapter(ClientConfigMap()))
self.amm_2.set_balance(BASE_ASSET, 500)
self.amm_2.set_balance(QUOTE_ASSET, 500)
self.market_info_2 = MarketTradingPairTuple(self.amm_2, TRADING_PAIR, BASE_ASSET, QUOTE_ASSET)
# Set some default prices.
self.amm_1.set_prices(TRADING_PAIR, True, 101)
self.amm_1.set_prices(TRADING_PAIR, False, 100)
self.amm_2.set_prices(TRADING_PAIR, True, 105)
self.amm_2.set_prices(TRADING_PAIR, False, 104)
self.strategy = AmmArbStrategy()
self.strategy.init_params(
self.market_info_1,
self.market_info_2,
min_profitability=Decimal("0.01"),
order_amount=Decimal("1"),
market_1_slippage_buffer=Decimal("0.001"),
market_2_slippage_buffer=Decimal("0.002"),
)
self.rate_source: FixedRateSource = FixedRateSource()
self.strategy.rate_source = self.rate_source
self.clock.add_iterator(self.amm_1)
self.clock.add_iterator(self.amm_2)
self.clock.add_iterator(self.strategy)
self.market_order_fill_logger: EventLogger = EventLogger()
self.amm_1.add_listener(MarketEvent.OrderFilled, self.market_order_fill_logger)
self.amm_2.add_listener(MarketEvent.OrderFilled, self.market_order_fill_logger)
self.rate_source.add_rate("ETH-USDT", Decimal(3000))
self.stack.enter_context(self.clock)
self.stack.enter_context(patch(
"hummingbot.client.config.trade_fee_schema_loader.TradeFeeSchemaLoader.configured_schema_for_exchange",
return_value=TradeFeeSchema()
))
self.clock_task: asyncio.Task = safe_ensure_future(self.clock.run())
def create_market(trading_pairs: List[str], mid_price, balances: Dict[str, int]) -> \
(MockPaperExchange, Dict[str, MarketTradingPairTuple]):
"""
Create a BacktestMarket and marketinfo dictionary to be used by the liquidity mining strategy
"""
market: MockPaperExchange = MockPaperExchange(
client_config_map=ClientConfigAdapter(ClientConfigMap())
)
market_infos: Dict[str, MarketTradingPairTuple] = {}
for trading_pair in trading_pairs:
base_asset = trading_pair.split("-")[0]
quote_asset = trading_pair.split("-")[1]
market.set_balanced_order_book(trading_pair=trading_pair,
mid_price=mid_price,
min_price=1,
max_price=200,
price_step_size=1,
volume_step_size=10)
market.set_quantization_param(QuantizationParams(trading_pair, 6, 6, 6, 6))
market_infos[trading_pair] = MarketTradingPairTuple(market, trading_pair, base_asset, quote_asset)
for asset, value in balances.items():
market.set_balance(asset, value)
return market, market_infos
def setUpClass(cls):
cls.ev_loop = asyncio.get_event_loop()
cls.trading_pair = "COINALPHA-HBOT"
cls.limit_orders: List[LimitOrder] = [
LimitOrder(client_order_id=f"LIMIT//-{i}-{int(time.time()*1e6)}",
trading_pair=cls.trading_pair,
is_buy=True if i % 2 == 0 else False,
base_currency=cls.trading_pair.split("-")[0],
quote_currency=cls.trading_pair.split("-")[1],
price=Decimal(f"{100 - i}") if i %
2 == 0 else Decimal(f"{100 + i}"),
quantity=Decimal(f"{10 * (i + 1)}"),
creation_timestamp=int(time.time() * 1e6))
for i in range(20)
]
cls.market_orders: List[MarketOrder] = [
MarketOrder(order_id=f"MARKET//-{i}-{int(time.time()*1e3)}",
trading_pair=cls.trading_pair,
is_buy=True if i % 2 == 0 else False,
base_asset=cls.trading_pair.split("-")[0],
quote_asset=cls.trading_pair.split("-")[1],
amount=float(f"{10 * (i + 1)}"),
timestamp=time.time()) for i in range(20)
]
cls.market: MockPaperExchange = MockPaperExchange(
client_config_map=ClientConfigAdapter(ClientConfigMap()))
cls.market_info: MarketTradingPairTuple = MarketTradingPairTuple(
cls.market, cls.trading_pair, *cls.trading_pair.split("-"))
def setUp(self) -> None:
np.random.seed(self.INITIAL_RANDOM_SEED)
trade_fee_schema = TradeFeeSchema(
maker_percent_fee_decimal=Decimal("0.25"),
taker_percent_fee_decimal=Decimal("0.25"))
client_config_map = ClientConfigAdapter(ClientConfigMap())
self.market: MockPaperExchange = MockPaperExchange(
client_config_map, trade_fee_schema)
self.market_info: MarketTradingPairTuple = MarketTradingPairTuple(
self.market, self.trading_pair, *self.trading_pair.split("-"))
self.market.set_balanced_order_book(trading_pair=self.trading_pair,
mid_price=self.initial_mid_price,
min_price=1,
max_price=200,
price_step_size=1,
volume_step_size=10)
self.market.set_balance("COINALPHA", 1)
self.market.set_balance("HBOT", 500)
self.market.set_quantization_param(
QuantizationParams(self.trading_pair.split("-")[0], 6, 6, 6, 6))
self.price_delegate = OrderBookAssetPriceDelegate(
self.market_info.market, self.trading_pair)
self.indicator = TradingIntensityIndicator(
order_book=self.market_info.order_book,
price_delegate=self.price_delegate,
sampling_length=self.BUFFER_LENGTH)
def non_trading_connector_instance_with_default_configuration(
self,
trading_pairs: Optional[List[str]] = None) -> 'ConnectorBase':
from hummingbot.client.config.config_helpers import ClientConfigAdapter
from hummingbot.client.hummingbot_application import HummingbotApplication
trading_pairs = trading_pairs or []
connector_class = getattr(importlib.import_module(self.module_path()),
self.class_name())
kwargs = {}
if isinstance(self.config_keys, Dict):
kwargs = {
key: (config.value or "")
for key, config in self.config_keys.items()
} # legacy
elif self.config_keys is not None:
kwargs = {
traverse_item.attr: traverse_item.value.get_secret_value()
if isinstance(traverse_item.value, SecretStr) else
traverse_item.value or ""
for traverse_item in ClientConfigAdapter(
self.config_keys).traverse()
if traverse_item.attr != "connector"
}
kwargs = self.conn_init_parameters(kwargs)
kwargs = self.add_domain_parameter(kwargs)
kwargs.update(trading_pairs=trading_pairs, trading_required=False)
kwargs["client_config_map"] = HummingbotApplication.main_application(
).client_config_map
connector = connector_class(**kwargs)
return connector
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.listening_task = None
self.mocking_assistant = NetworkMockingAssistant()
client_config_map = ClientConfigAdapter(ClientConfigMap())
self.connector = OkxExchange(
client_config_map=client_config_map,
okx_api_key="",
okx_secret_key="",
okx_passphrase="",
trading_pairs=[self.trading_pair],
trading_required=False,
)
self.data_source = OkxAPIOrderBookDataSource(
trading_pairs=[self.trading_pair],
connector=self.connector,
api_factory=self.connector._web_assistants_factory)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.resume_test_event = asyncio.Event()
self.connector._set_trading_pair_symbol_map(
bidict(
{f"{self.base_asset}-{self.quote_asset}": self.trading_pair}))
def setUp(self):
self.log_records = []
self.start: pd.Timestamp = pd.Timestamp("2019-01-01", tz="UTC")
self.end: pd.Timestamp = pd.Timestamp("2019-01-01 01:00:00", tz="UTC")
self.start_timestamp: float = self.start.timestamp()
self.end_timestamp: float = self.end.timestamp()
self.connector_name: str = "mock_paper_exchange"
self.trading_pair: str = "HBOT-USDT"
self.base_asset, self.quote_asset = self.trading_pair.split("-")
self.base_balance: int = 500
self.quote_balance: int = 5000
self.initial_mid_price: int = 100
self.clock_tick_size = 1
self.clock: Clock = Clock(ClockMode.BACKTEST, self.clock_tick_size,
self.start_timestamp, self.end_timestamp)
self.connector: MockPaperExchange = MockPaperExchange(
client_config_map=ClientConfigAdapter(ClientConfigMap()))
self.connector.set_balanced_order_book(trading_pair=self.trading_pair,
mid_price=100,
min_price=50,
max_price=150,
price_step_size=1,
volume_step_size=10)
self.connector.set_balance(self.base_asset, self.base_balance)
self.connector.set_balance(self.quote_asset, self.quote_balance)
self.connector.set_quantization_param(
QuantizationParams(self.trading_pair, 6, 6, 6, 6))
self.clock.add_iterator(self.connector)
ScriptStrategyBase.markets = {self.connector_name: {self.trading_pair}}
self.strategy = ScriptStrategyBase(
{self.connector_name: self.connector})
self.strategy.logger().setLevel(1)
self.strategy.logger().addHandler(self)
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.listening_task = None
self.mocking_assistant = NetworkMockingAssistant()
self.client_config_map = ClientConfigAdapter(ClientConfigMap())
self.connector = BitmartExchange(
client_config_map=self.client_config_map,
bitmart_api_key="",
bitmart_secret_key="",
bitmart_memo="",
trading_pairs=[self.trading_pair],
trading_required=False,
)
self.data_source = BitmartAPIOrderBookDataSource(
trading_pairs=[self.trading_pair],
connector=self.connector,
api_factory=self.connector._web_assistants_factory)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.connector._set_trading_pair_symbol_map(
bidict({self.ex_trading_pair: self.trading_pair}))
def test_import_config_file_success(
self, status_check_all_mock: AsyncMock,
get_strategy_pydantic_config_cls: MagicMock):
strategy_name = "perpetual_market_making"
strategy_file_name = f"{strategy_name}.yml"
status_check_all_mock.return_value = True
dummy_strategy_config_cls = self.build_dummy_strategy_config_cls(
strategy_name)
get_strategy_pydantic_config_cls.return_value = dummy_strategy_config_cls
cm = ClientConfigAdapter(
dummy_strategy_config_cls(no_default="some value"))
with TemporaryDirectory() as d:
d = Path(d)
import_command.STRATEGIES_CONF_DIR_PATH = d
temp_file_name = d / strategy_file_name
save_to_yml(temp_file_name, cm)
self.async_run_with_timeout(
self.app.import_config_file(strategy_file_name))
self.assertEqual(strategy_file_name, self.app.strategy_file_name)
self.assertEqual(strategy_name, self.app.strategy_name)
self.assertTrue(
self.cli_mock_assistant.check_log_called_with(
"\nEnter \"start\" to start market making."))
self.assertEqual(cm, self.app.strategy_config_map)
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.async_task = None
self.mocking_assistant = NetworkMockingAssistant()
client_config_map = ClientConfigAdapter(ClientConfigMap())
self.connector = KucoinExchange(client_config_map=client_config_map,
kucoin_api_key="",
kucoin_passphrase="",
kucoin_secret_key="",
trading_pairs=[],
trading_required=False)
self.ob_data_source = KucoinAPIOrderBookDataSource(
trading_pairs=[self.trading_pair],
connector=self.connector,
api_factory=self.connector._web_assistants_factory)
self.ob_data_source.logger().setLevel(1)
self.ob_data_source.logger().addHandler(self)
self.connector._set_trading_pair_symbol_map(
bidict({self.trading_pair: self.trading_pair}))
def store_binance_config(self) -> ClientConfigAdapter:
config_map = ClientConfigAdapter(
BinanceConfigMap(binance_api_key=self.api_key, binance_api_secret=self.api_secret)
)
file_path = get_connector_config_yml_path(self.connector)
save_to_yml(file_path, config_map)
return config_map
def test_connector_config_maps(self):
connector_exceptions = [
"mock_paper_exchange", "mock_pure_python_paper_exchange",
"paper_trade", "celo"
]
type_dirs = [
cast(DirEntry, f)
for f in scandir(f"{root_path() / 'hummingbot' / 'connector'}")
if f.is_dir()
]
for type_dir in type_dirs:
connector_dirs = [
cast(DirEntry, f) for f in scandir(type_dir.path)
if f.is_dir() and exists(join(f.path, "__init__.py"))
]
for connector_dir in connector_dirs:
if connector_dir.name.startswith(
"_") or connector_dir.name in connector_exceptions:
continue
util_module_path: str = (
f"hummingbot.connector.{type_dir.name}.{connector_dir.name}.{connector_dir.name}_utils"
)
util_module = importlib.import_module(util_module_path)
connector_config = getattr(util_module, "KEYS")
self.assertIsInstance(connector_config, BaseConnectorConfigMap)
for el in ClientConfigAdapter(connector_config).traverse():
if el.attr == "connector":
self.assertEqual(el.value, connector_dir.name)
elif el.client_field_data.is_secure:
self.assertEqual(el.type_, SecretStr)
else:
self.assertEqual(el.type_, str)
def test_show_ticker(self, notify_mock):
self.client_config_map.db_mode = DBSqliteMode()
captures = []
notify_mock.side_effect = lambda s: captures.append(s)
exchange_name = "paper"
exchange = MockPaperExchange(
client_config_map=ClientConfigAdapter(ClientConfigMap()))
self.app.markets[exchange_name] = exchange
trading_pair = "BTC-USDT"
exchange.set_balanced_order_book(
trading_pair,
mid_price=10,
min_price=8.5,
max_price=11.5,
price_step_size=1,
volume_step_size=1,
)
self.async_run_with_timeout(
self.app.show_ticker(exchange=exchange_name, live=False))
self.assertEqual(1, len(captures))
df_str_expected = (
" Market: mock_paper_exchange"
"\n+------------+------------+-------------+--------------+"
"\n| Best Bid | Best Ask | Mid Price | Last Trade |"
"\n|------------+------------+-------------+--------------|"
"\n| 9.5 | 10.5 | 10 | nan |"
"\n+------------+------------+-------------+--------------+")
self.assertEqual(df_str_expected, captures[0])
def migrate_xemm_confs(conf, new_path) -> List[str]:
if "active_order_canceling" in conf:
if conf["active_order_canceling"]:
conf["order_refresh_mode"] = {}
else:
conf["order_refresh_mode"] = {
"cancel_order_threshold": conf["cancel_order_threshold"],
"limit_order_min_expiration": conf["limit_order_min_expiration"]
}
conf.pop("active_order_canceling")
conf.pop("cancel_order_threshold")
conf.pop("limit_order_min_expiration")
if "use_oracle_conversion_rate" in conf:
if conf["use_oracle_conversion_rate"]:
conf["conversion_rate_mode"] = {}
else:
conf["conversion_rate_mode"] = {
"taker_to_maker_base_conversion_rate": conf["taker_to_maker_base_conversion_rate"],
"taker_to_maker_quote_conversion_rate": conf["taker_to_maker_quote_conversion_rate"]
}
conf.pop("use_oracle_conversion_rate")
conf.pop("taker_to_maker_base_conversion_rate")
conf.pop("taker_to_maker_quote_conversion_rate")
if "template_version" in conf:
conf.pop("template_version")
try:
config_map = ClientConfigAdapter(CrossExchangeMarketMakingConfigMap(**conf))
save_to_yml(new_path, config_map)
errors = []
except Exception as e:
logging.getLogger().error(str(e))
errors = [str(e)]
return errors
def test_get_last_price(self, mock_api, connector_creator_mock):
client_config_map = ClientConfigAdapter(ClientConfigMap())
connector = BinanceExchange(
client_config_map,
binance_api_key="",
binance_api_secret="",
trading_pairs=[],
trading_required=False)
connector._set_trading_pair_symbol_map(bidict({f"{self.binance_ex_trading_pair}": self.trading_pair}))
connector_creator_mock.return_value = connector
url = web_utils.public_rest_url(path_url=CONSTANTS.TICKER_PRICE_CHANGE_PATH_URL)
regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?"))
mock_response: Dict[str, Any] = {
# truncated response
"symbol": self.binance_ex_trading_pair,
"lastPrice": "1",
}
mock_api.get(regex_url, body=ujson.dumps(mock_response))
result = self.async_run_with_timeout(market_price.get_last_price(
exchange="binance",
trading_pair=self.trading_pair,
))
self.assertEqual(result, Decimal("1.0"))
def setUpClass(cls) -> None:
super().setUpClass()
GatewayHttpClient.__instance = None
cls._db_path = realpath(
join(__file__, "../fixtures/gateway_evm_amm_fixture.db"))
cls._http_player = HttpPlayer(cls._db_path)
cls._clock: Clock = Clock(ClockMode.REALTIME)
cls._client_config_map = ClientConfigAdapter(ClientConfigMap())
cls._connector: GatewayEVMAMM = GatewayEVMAMM(
client_config_map=cls._client_config_map,
connector_name="uniswap",
chain="ethereum",
network="ropsten",
wallet_address="0x5821715133bB451bDE2d5BC6a4cE3430a4fdAF92",
trading_pairs=["DAI-WETH"],
trading_required=True)
cls._clock.add_iterator(cls._connector)
cls._patch_stack = ExitStack()
cls._patch_stack.enter_context(cls._http_player.patch_aiohttp_client())
cls._patch_stack.enter_context(
patch(
"hummingbot.core.gateway.gateway_http_client.GatewayHttpClient._http_client",
return_value=ClientSession()))
cls._patch_stack.enter_context(cls._clock)
GatewayHttpClient.get_instance(client_config_map=cls._client_config_map
).base_url = "https://localhost:5000"
ev_loop.run_until_complete(cls.wait_til_ready())
def setUp(self):
self.maxDiff = None
self.clock: Clock = Clock(ClockMode.BACKTEST, 1.0,
self.start_timestamp, self.end_timestamp)
self.market: MockPaperExchange = MockPaperExchange(
client_config_map=ClientConfigAdapter(ClientConfigMap()))
self.market.set_balanced_order_book(self.trading_pair, 10, 5, 15, 0.1,
1)
self.market.set_balance(self.base_asset, 500)
self.market.set_balance(self.quote_asset, 500)
self.market.set_quantization_param(
QuantizationParams(self.trading_pair, 5, 5, 5, 5))
self.market_info = MarketTradingPairTuple(self.market,
self.trading_pair,
self.base_asset,
self.quote_asset)
self.logging_options: int = CeloArbStrategy.OPTION_LOG_ALL
self.strategy = CeloArbStrategy()
self.strategy.init_params(self.market_info,
min_profitability=Decimal("0.01"),
order_amount=Decimal("1"),
celo_slippage_buffer=Decimal("0.001"),
logging_options=self.logging_options,
hb_app_notification=False,
mock_celo_cli_mode=True)
self.clock.add_iterator(self.market)
self.clock.add_iterator(self.strategy)
self.market_order_fill_logger: EventLogger = EventLogger()
self.market.add_listener(MarketEvent.OrderFilled,
self.market_order_fill_logger)
CeloCLI.unlock_account(TEST_ADDRESS, TEST_PASSWORD)
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.listening_task: Optional[asyncio.Task] = None
self.mocking_assistant = NetworkMockingAssistant()
self.throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
self.mock_time_provider = MagicMock()
self.mock_time_provider.time.return_value = 1000
self.auth = KucoinAuth(
self.api_key,
self.api_passphrase,
self.api_secret_key,
time_provider=self.mock_time_provider)
client_config_map = ClientConfigAdapter(ClientConfigMap())
self.connector = KucoinExchange(
client_config_map=client_config_map,
kucoin_api_key="",
kucoin_passphrase="",
kucoin_secret_key="",
trading_pairs=[],
trading_required=False)
self.data_source = KucoinAPIUserStreamDataSource(
auth=self.auth,
trading_pairs=[self.trading_pair],
connector=self.connector,
api_factory=self.connector._web_assistants_factory)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
def setUpClass(cls) -> None:
super().setUpClass()
cls._db_path = realpath(
join(__file__, "../fixtures/gateway_evm_amm_lp_fixture.db"))
cls._http_player = HttpPlayer(cls._db_path)
cls._clock: Clock = Clock(ClockMode.REALTIME)
cls._client_config_map = ClientConfigAdapter(ClientConfigMap())
cls._connector: GatewayEVMAMMLP = GatewayEVMAMMLP(
client_config_map=cls._client_config_map,
connector_name="uniswapLP",
chain="ethereum",
network="kovan",
wallet_address="0xefb7be8631d154d4c0ad8676fec0897b2894fe8f",
trading_pairs=["COIN1-COIN3"],
trading_required=True)
cls._clock.add_iterator(cls._connector)
cls._patch_stack = ExitStack()
cls._patch_stack.enter_context(cls._http_player.patch_aiohttp_client())
cls._patch_stack.enter_context(
patch(
"hummingbot.core.gateway.gateway_http_client.GatewayHttpClient._http_client",
return_value=ClientSession()))
cls._patch_stack.enter_context(cls._clock)
GatewayHttpClient.get_instance(client_config_map=cls._client_config_map
).base_url = "https://localhost:5000"
ev_loop.run_until_complete(cls.wait_til_ready())
