def _initialize_markets(self, market_names: List[Tuple[str, List[str]]]):
ethereum_rpc_url = global_config_map.get("ethereum_rpc_url").value
# aggregate symbols if there are duplicate markets
market_symbols_map = {}
for market_name, symbols in market_names:
if market_name not in market_symbols_map:
market_symbols_map[market_name] = []
market_symbols_map[market_name] += symbols
for market_name, symbols in market_symbols_map.items():
if global_config_map.get("paper_trade_enabled").value:
self._notify(f"\nPaper trade is enabled for market {market_name}")
try:
market = create_paper_trade_market(market_name, symbols)
except Exception:
raise
paper_trade_account_balance = global_config_map.get("paper_trade_account_balance").value
for asset, balance in paper_trade_account_balance:
market.set_balance(asset, balance)
elif market_name == "ddex" and self.wallet:
market = DDEXMarket(wallet=self.wallet,
ethereum_rpc_url=ethereum_rpc_url,
order_book_tracker_data_source_type=OrderBookTrackerDataSourceType.EXCHANGE_API,
symbols=symbols,
trading_required=self._trading_required)
elif market_name == "idex" and self.wallet:
idex_api_key: str = global_config_map.get("idex_api_key").value
try:
market = IDEXMarket(idex_api_key=idex_api_key,
wallet=self.wallet,
ethereum_rpc_url=ethereum_rpc_url,
order_book_tracker_data_source_type=OrderBookTrackerDataSourceType.EXCHANGE_API,
symbols=symbols,
trading_required=self._trading_required)
except Exception as e:
self.logger().error(str(e))
elif market_name == "binance":
binance_api_key = global_config_map.get("binance_api_key").value
binance_api_secret = global_config_map.get("binance_api_secret").value
market = BinanceMarket(binance_api_key,
binance_api_secret,
order_book_tracker_data_source_type=OrderBookTrackerDataSourceType.EXCHANGE_API,
symbols=symbols,
trading_required=self._trading_required)
elif market_name == "radar_relay" and self.wallet:
market = RadarRelayMarket(wallet=self.wallet,
ethereum_rpc_url=ethereum_rpc_url,
symbols=symbols,
trading_required=self._trading_required)
elif market_name == "bamboo_relay" and self.wallet:
use_coordinator = global_config_map.get("bamboo_relay_use_coordinator").value
pre_emptive_soft_cancels = global_config_map.get("bamboo_relay_pre_emptive_soft_cancels").value
market = BambooRelayMarket(wallet=self.wallet,
ethereum_rpc_url=ethereum_rpc_url,
symbols=symbols,
use_coordinator=use_coordinator,
pre_emptive_soft_cancels=pre_emptive_soft_cancels,
trading_required=self._trading_required)
elif market_name == "coinbase_pro":
coinbase_pro_api_key = global_config_map.get("coinbase_pro_api_key").value
coinbase_pro_secret_key = global_config_map.get("coinbase_pro_secret_key").value
coinbase_pro_passphrase = global_config_map.get("coinbase_pro_passphrase").value
market = CoinbaseProMarket(coinbase_pro_api_key,
coinbase_pro_secret_key,
coinbase_pro_passphrase,
symbols=symbols,
trading_required=self._trading_required)
elif market_name == "huobi":
huobi_api_key = global_config_map.get("huobi_api_key").value
huobi_secret_key = global_config_map.get("huobi_secret_key").value
market = HuobiMarket(huobi_api_key,
huobi_secret_key,
order_book_tracker_data_source_type=OrderBookTrackerDataSourceType.EXCHANGE_API,
symbols=symbols,
trading_required=self._trading_required)
else:
raise ValueError(f"Market name {market_name} is invalid.")
self.markets[market_name]: MarketBase = market
self.markets_recorder = MarketsRecorder(
self.trade_fill_db,
list(self.markets.values()),
in_memory_config_map.get("strategy_file_path").value,
in_memory_config_map.get("strategy").value
)
self.markets_recorder.start()
def start(self):
try:
order_size = pure_market_making_config_map.get("order_amount").value
cancel_order_wait_time = pure_market_making_config_map.get("cancel_order_wait_time").value
bid_place_threshold = pure_market_making_config_map.get("bid_place_threshold").value
ask_place_threshold = pure_market_making_config_map.get("ask_place_threshold").value
expiration_seconds = pure_market_making_config_map.get("expiration_seconds").value
mode = pure_market_making_config_map.get("mode").value
number_of_orders = pure_market_making_config_map.get("number_of_orders").value
order_start_size = pure_market_making_config_map.get("order_start_size").value
order_step_size = pure_market_making_config_map.get("order_step_size").value
order_interval_percent = pure_market_making_config_map.get("order_interval_percent").value
maker_market = pure_market_making_config_map.get("maker_market").value.lower()
raw_maker_trading_pair = pure_market_making_config_map.get("maker_market_trading_pair").value
inventory_skew_enabled = pure_market_making_config_map.get("inventory_skew_enabled").value
inventory_target_base_percent = pure_market_making_config_map.get("inventory_target_base_percent").value
filled_order_replenish_wait_time = pure_market_making_config_map.get("filled_order_replenish_wait_time").value
enable_order_filled_stop_cancellation = pure_market_making_config_map.get(
"enable_order_filled_stop_cancellation").value
best_bid_ask_jump_mode = pure_market_making_config_map.get("best_bid_ask_jump_mode").value
best_bid_ask_jump_orders_depth = pure_market_making_config_map.get("best_bid_ask_jump_orders_depth").value
add_transaction_costs_to_orders = pure_market_making_config_map.get("add_transaction_costs").value
external_pricing_source = pure_market_making_config_map.get("external_pricing_source").value
external_price_source_type = pure_market_making_config_map.get("external_price_source_type").value
external_price_source_exchange = pure_market_making_config_map.get("external_price_source_exchange").value
external_price_source_exchange_trading_pair = pure_market_making_config_map.get(
"external_price_source_exchange_trading_pair").value
external_price_source_feed_base_asset = pure_market_making_config_map.get(
"external_price_source_feed_base_asset").value
external_price_source_feed_quote_asset = pure_market_making_config_map.get(
"external_price_source_feed_quote_asset").value
external_price_source_custom_api = pure_market_making_config_map.get("external_price_source_custom_api").value
pricing_delegate = None
sizing_delegate = None
filter_delegate = PassThroughFilterDelegate()
if mode == "multiple":
pricing_delegate = ConstantMultipleSpreadPricingDelegate(bid_place_threshold,
ask_place_threshold,
order_interval_percent,
number_of_orders)
if inventory_skew_enabled:
sizing_delegate = InventorySkewMultipleSizeSizingDelegate(order_start_size,
order_step_size,
number_of_orders,
inventory_target_base_percent)
else:
sizing_delegate = StaggeredMultipleSizeSizingDelegate(order_start_size,
order_step_size,
number_of_orders)
else: # mode == "single"
pricing_delegate = ConstantSpreadPricingDelegate(bid_place_threshold,
ask_place_threshold)
if inventory_skew_enabled:
sizing_delegate = InventorySkewSingleSizeSizingDelegate(order_size,
inventory_target_base_percent)
else:
sizing_delegate = ConstantSizeSizingDelegate(order_size)
try:
trading_pair: str = self._convert_to_exchange_trading_pair(maker_market, [raw_maker_trading_pair])[0]
maker_assets: Tuple[str, str] = self._initialize_market_assets(maker_market, [trading_pair])[0]
except ValueError as e:
self._notify(str(e))
return
market_names: List[Tuple[str, List[str]]] = [(maker_market, [trading_pair])]
self._initialize_wallet(token_trading_pairs=list(set(maker_assets)))
self._initialize_markets(market_names)
self.assets = set(maker_assets)
maker_data = [self.markets[maker_market], trading_pair] + list(maker_assets)
self.market_trading_pair_tuples = [MarketTradingPairTuple(*maker_data)]
asset_price_delegate = None
if external_pricing_source:
if external_price_source_type == "exchange":
asset_trading_pair: str = self._convert_to_exchange_trading_pair(
external_price_source_exchange, [external_price_source_exchange_trading_pair])[0]
ext_market = create_paper_trade_market(external_price_source_exchange, [asset_trading_pair])
self.markets[external_price_source_exchange]: MarketBase = ext_market
asset_price_delegate = OrderBookAssetPriceDelegate(ext_market, asset_trading_pair)
elif external_price_source_type == "feed":
asset_price_delegate = DataFeedAssetPriceDelegate(external_price_source_feed_base_asset,
external_price_source_feed_quote_asset)
elif external_price_source_type == "custom_api":
asset_price_delegate = APIAssetPriceDelegate(external_price_source_custom_api)
else:
asset_price_delegate = None
strategy_logging_options = PureMarketMakingStrategyV2.OPTION_LOG_ALL
self.strategy = PureMarketMakingStrategyV2(market_infos=[MarketTradingPairTuple(*maker_data)],
pricing_delegate=pricing_delegate,
filter_delegate=filter_delegate,
sizing_delegate=sizing_delegate,
filled_order_replenish_wait_time=filled_order_replenish_wait_time,
enable_order_filled_stop_cancellation=enable_order_filled_stop_cancellation,
cancel_order_wait_time=cancel_order_wait_time,
best_bid_ask_jump_mode=best_bid_ask_jump_mode,
best_bid_ask_jump_orders_depth=best_bid_ask_jump_orders_depth,
add_transaction_costs_to_orders=add_transaction_costs_to_orders,
logging_options=strategy_logging_options,
asset_price_delegate=asset_price_delegate,
expiration_seconds=expiration_seconds)
except Exception as e:
self._notify(str(e))
self.logger().error("Unknown error during initialization.", exc_info=True)
def _initialize_markets(self, market_names: List[Tuple[str, List[str]]]):
ethereum_rpc_url = global_config_map.get("ethereum_rpc_url").value
# aggregate trading_pairs if there are duplicate markets
market_trading_pairs_map = {}
for market_name, trading_pairs in market_names:
if market_name not in market_trading_pairs_map:
market_trading_pairs_map[market_name] = []
market_class: MarketBase = MARKET_CLASSES.get(
market_name, MarketBase)
for trading_pair in trading_pairs:
exchange_trading_pair: str = market_class.convert_to_exchange_trading_pair(
trading_pair)
market_trading_pairs_map[market_name].append(
exchange_trading_pair)
for market_name, trading_pairs in market_trading_pairs_map.items():
if global_config_map.get("paper_trade_enabled").value:
try:
market = create_paper_trade_market(market_name,
trading_pairs)
except Exception:
raise
paper_trade_account_balance = global_config_map.get(
"paper_trade_account_balance").value
for asset, balance in paper_trade_account_balance.items():
market.set_balance(asset, balance)
elif market_name == "binance":
binance_api_key = global_config_map.get(
"binance_api_key").value
binance_api_secret = global_config_map.get(
"binance_api_secret").value
market = BinanceMarket(
binance_api_key,
binance_api_secret,
order_book_tracker_data_source_type=
OrderBookTrackerDataSourceType.EXCHANGE_API,
trading_pairs=trading_pairs,
trading_required=self._trading_required,
)
elif market_name == "radar_relay":
assert self.wallet is not None
market = RadarRelayMarket(
wallet=self.wallet,
ethereum_rpc_url=ethereum_rpc_url,
trading_pairs=trading_pairs,
trading_required=self._trading_required,
)
elif market_name == "bamboo_relay":
assert self.wallet is not None
use_coordinator = global_config_map.get(
"bamboo_relay_use_coordinator").value
pre_emptive_soft_cancels = global_config_map.get(
"bamboo_relay_pre_emptive_soft_cancels").value
market = BambooRelayMarket(
wallet=self.wallet,
ethereum_rpc_url=ethereum_rpc_url,
trading_pairs=trading_pairs,
use_coordinator=use_coordinator,
pre_emptive_soft_cancels=pre_emptive_soft_cancels,
trading_required=self._trading_required,
)
elif market_name == "coinbase_pro":
coinbase_pro_api_key = global_config_map.get(
"coinbase_pro_api_key").value
coinbase_pro_secret_key = global_config_map.get(
"coinbase_pro_secret_key").value
coinbase_pro_passphrase = global_config_map.get(
"coinbase_pro_passphrase").value
market = CoinbaseProMarket(
coinbase_pro_api_key,
coinbase_pro_secret_key,
coinbase_pro_passphrase,
trading_pairs=trading_pairs,
trading_required=self._trading_required)
elif market_name == "huobi":
huobi_api_key = global_config_map.get("huobi_api_key").value
huobi_secret_key = global_config_map.get(
"huobi_secret_key").value
market = HuobiMarket(
huobi_api_key,
huobi_secret_key,
order_book_tracker_data_source_type=
OrderBookTrackerDataSourceType.EXCHANGE_API,
trading_pairs=trading_pairs,
trading_required=self._trading_required)
elif market_name == "liquid":
liquid_api_key = global_config_map.get("liquid_api_key").value
liquid_secret_key = global_config_map.get(
"liquid_secret_key").value
market = LiquidMarket(
liquid_api_key,
liquid_secret_key,
order_book_tracker_data_source_type=
OrderBookTrackerDataSourceType.EXCHANGE_API,
user_stream_tracker_data_source_type=
UserStreamTrackerDataSourceType.EXCHANGE_API,
trading_pairs=trading_pairs,
trading_required=self._trading_required)
elif market_name == "dolomite":
assert self.wallet is not None
is_test_net: bool = global_config_map.get(
"ethereum_chain_name").value == "DOLOMITE_TEST"
market = DolomiteMarket(
wallet=self.wallet,
ethereum_rpc_url=ethereum_rpc_url,
order_book_tracker_data_source_type=
OrderBookTrackerDataSourceType.EXCHANGE_API,
trading_pairs=trading_pairs,
isTestNet=is_test_net,
trading_required=self._trading_required,
)
elif market_name == "bittrex":
bittrex_api_key = global_config_map.get(
"bittrex_api_key").value
bittrex_secret_key = global_config_map.get(
"bittrex_secret_key").value
market = BittrexMarket(
bittrex_api_key,
bittrex_secret_key,
order_book_tracker_data_source_type=
OrderBookTrackerDataSourceType.EXCHANGE_API,
trading_pairs=trading_pairs,
trading_required=self._trading_required)
elif market_name == "kucoin":
kucoin_api_key = global_config_map.get("kucoin_api_key").value
kucoin_secret_key = global_config_map.get(
"kucoin_secret_key").value
kucoin_passphrase = global_config_map.get(
"kucoin_passphrase").value
market = KucoinMarket(
kucoin_api_key,
kucoin_passphrase,
kucoin_secret_key,
order_book_tracker_data_source_type=
OrderBookTrackerDataSourceType.EXCHANGE_API,
trading_pairs=trading_pairs,
trading_required=self._trading_required)
elif market_name == "eterbase":
eterbase_api_key = global_config_map.get(
"eterbase_api_key").value
eterbase_secret_key = global_config_map.get(
"eterbase_secret_key").value
eterbase_account = global_config_map.get(
"eterbase_account").value
market = EterbaseMarket(
eterbase_api_key,
eterbase_secret_key,
trading_pairs=trading_pairs,
trading_required=self._trading_required,
eterbase_account=eterbase_account)
elif market_name == "kraken":
kraken_api_key = global_config_map.get("kraken_api_key").value
kraken_secret_key = global_config_map.get(
"kraken_secret_key").value
market = KrakenMarket(
kraken_api_key,
kraken_secret_key,
order_book_tracker_data_source_type=
OrderBookTrackerDataSourceType.EXCHANGE_API,
trading_pairs=trading_pairs,
trading_required=self._trading_required)
else:
raise ValueError(f"Market name {market_name} is invalid.")
self.markets[market_name]: MarketBase = market
self.markets_recorder = MarketsRecorder(
self.trade_fill_db,
list(self.markets.values()),
self.strategy_file_name,
self.strategy_name,
)
self.markets_recorder.start()
def start(self):
try:
order_amount = c_map.get("order_amount").value
order_refresh_time = c_map.get("order_refresh_time").value
bid_spread = c_map.get("bid_spread").value / Decimal('100')
ask_spread = c_map.get("ask_spread").value / Decimal('100')
order_expiration_time = c_map.get("order_expiration_time").value
order_levels = c_map.get("order_levels").value
order_level_amount = c_map.get("order_level_amount").value
order_level_spread = c_map.get("order_level_spread").value / Decimal(
'100')
exchange = c_map.get("exchange").value.lower()
raw_trading_pair = c_map.get("market").value
inventory_skew_enabled = c_map.get("inventory_skew_enabled").value
inventory_target_base_pct = 0 if c_map.get("inventory_target_base_pct").value is None else \
c_map.get("inventory_target_base_pct").value / Decimal('100')
inventory_range_multiplier = c_map.get(
"inventory_range_multiplier").value
filled_order_delay = c_map.get("filled_order_delay").value
hanging_orders_enabled = c_map.get("hanging_orders_enabled").value
hanging_orders_cancel_pct = c_map.get(
"hanging_orders_cancel_pct").value / Decimal('100')
order_optimization_enabled = c_map.get(
"order_optimization_enabled").value
order_optimization_depth = c_map.get("order_optimization_depth").value
add_transaction_costs_to_orders = c_map.get(
"add_transaction_costs").value
price_source_enabled = c_map.get("price_source_enabled").value
price_source_type = c_map.get("price_source_type").value
price_source_exchange = c_map.get("price_source_exchange").value
price_source_market = c_map.get("price_source_market").value
price_source_custom = c_map.get("price_source_custom").value
pricing_delegate = None
sizing_delegate = None
filter_delegate = PassThroughFilterDelegate()
if order_levels > 1:
pricing_delegate = ConstantMultipleSpreadPricingDelegate(
bid_spread, ask_spread, order_level_spread, order_levels)
if inventory_skew_enabled:
sizing_delegate = InventorySkewMultipleSizeSizingDelegate(
order_amount, order_level_amount, order_levels,
inventory_target_base_pct, inventory_range_multiplier)
else:
sizing_delegate = StaggeredMultipleSizeSizingDelegate(
order_amount, order_level_amount, order_levels)
else: # mode == "single"
pricing_delegate = ConstantSpreadPricingDelegate(
bid_spread, ask_spread)
if inventory_skew_enabled:
sizing_delegate = InventorySkewSingleSizeSizingDelegate(
order_amount, inventory_target_base_pct,
inventory_range_multiplier)
else:
sizing_delegate = ConstantSizeSizingDelegate(order_amount)
try:
trading_pair: str = self._convert_to_exchange_trading_pair(
exchange, [raw_trading_pair])[0]
maker_assets: Tuple[str, str] = self._initialize_market_assets(
exchange, [trading_pair])[0]
except ValueError as e:
self._notify(str(e))
return
market_names: List[Tuple[str,
List[str]]] = [(exchange, [trading_pair])]
self._initialize_wallet(token_trading_pairs=list(set(maker_assets)))
self._initialize_markets(market_names)
self.assets = set(maker_assets)
maker_data = [self.markets[exchange], trading_pair
] + list(maker_assets)
self.market_trading_pair_tuples = [MarketTradingPairTuple(*maker_data)]
asset_price_delegate = None
if price_source_enabled:
if price_source_type == "exchange":
asset_trading_pair: str = self._convert_to_exchange_trading_pair(
price_source_exchange, [price_source_market])[0]
ext_market = create_paper_trade_market(price_source_exchange,
[asset_trading_pair])
self.markets[price_source_exchange]: MarketBase = ext_market
asset_price_delegate = OrderBookAssetPriceDelegate(
ext_market, asset_trading_pair)
elif price_source_type == "custom_api":
asset_price_delegate = APIAssetPriceDelegate(
price_source_custom)
else:
asset_price_delegate = None
strategy_logging_options = PureMarketMakingStrategyV2.OPTION_LOG_ALL
self.strategy = PureMarketMakingStrategyV2(
market_infos=[MarketTradingPairTuple(*maker_data)],
pricing_delegate=pricing_delegate,
filter_delegate=filter_delegate,
sizing_delegate=sizing_delegate,
filled_order_delay=filled_order_delay,
hanging_orders_enabled=hanging_orders_enabled,
order_refresh_time=order_refresh_time,
order_optimization_enabled=order_optimization_enabled,
order_optimization_depth=order_optimization_depth,
add_transaction_costs_to_orders=add_transaction_costs_to_orders,
logging_options=strategy_logging_options,
asset_price_delegate=asset_price_delegate,
expiration_seconds=order_expiration_time,
hanging_orders_cancel_pct=hanging_orders_cancel_pct)
except Exception as e:
self._notify(str(e))
self.logger().error("Unknown error during initialization.",
exc_info=True)
