def test_empty_maker_orderbook(self):
self.clock.remove_iterator(self.strategy)
self.clock.remove_iterator(self.maker_market)
self.maker_market: MockPaperExchange = MockPaperExchange()
# Orderbook is empty
self.maker_market.new_empty_order_book(self.maker_trading_pairs[0])
self.market_pair: CrossExchangeMarketPair = CrossExchangeMarketPair(
MarketTradingPairTuple(self.maker_market, *self.maker_trading_pairs),
MarketTradingPairTuple(self.taker_market, *self.taker_trading_pairs),
)
self.strategy: CrossExchangeMarketMakingStrategy = CrossExchangeMarketMakingStrategy()
self.strategy.init_params(
[self.market_pair],
order_amount=1,
min_profitability=Decimal("0.005"),
logging_options=self.logging_options,
adjust_order_enabled=False
)
self.maker_market.set_balance("COINALPHA", 5)
self.maker_market.set_balance("WETH", 5)
self.maker_market.set_balance("QETH", 5)
self.maker_market.set_quantization_param(QuantizationParams(self.maker_trading_pairs[0], 4, 4, 4, 4))
self.clock.add_iterator(self.strategy)
self.clock.add_iterator(self.maker_market)
self.clock.backtest_til(self.start_timestamp + 5)
self.assertEqual(1, len(self.strategy.active_bids))
self.assertEqual(1, len(self.strategy.active_asks))
bid_order: LimitOrder = self.strategy.active_bids[0][1]
ask_order: LimitOrder = self.strategy.active_asks[0][1]
# Places orders based on taker orderbook
self.assertEqual(Decimal("0.9945"), bid_order.price)
self.assertEqual(Decimal("1.006"), ask_order.price)
self.assertAlmostEqual(Decimal("1"), round(bid_order.quantity, 4))
self.assertAlmostEqual(Decimal("1"), round(ask_order.quantity, 4))
def test_with_conversion(self):
self.clock.remove_iterator(self.strategy)
self.market_pair: CrossExchangeMarketPair = CrossExchangeMarketPair(
MarketTradingPairTuple(self.maker_market,
*["COINALPHA-QETH", "COINALPHA", "QETH"]),
MarketTradingPairTuple(self.taker_market,
*self.taker_trading_pairs),
)
self.maker_data: MockOrderBookLoader = MockOrderBookLoader(
"COINALPHA-QETH", "COINALPHA", "QETH")
self.maker_data.set_balanced_order_book(1.05, 0.55, 1.55, 0.01, 10)
self.maker_market.add_data(self.maker_data)
self.strategy: CrossExchangeMarketMakingStrategy = CrossExchangeMarketMakingStrategy(
[self.market_pair],
Decimal("0.01"),
order_size_portfolio_ratio_limit=Decimal("0.3"),
logging_options=self.logging_options)
self.clock.add_iterator(self.strategy)
self.clock.backtest_til(self.start_timestamp + 5)
self.assertEqual(1, len(self.strategy.active_bids))
self.assertEqual(1, len(self.strategy.active_asks))
bid_order: LimitOrder = self.strategy.active_bids[0][1]
ask_order: LimitOrder = self.strategy.active_asks[0][1]
self.assertAlmostEqual(Decimal("1.0417"), round(bid_order.price, 4))
self.assertAlmostEqual(Decimal("1.0637"), round(ask_order.price, 4))
self.assertAlmostEqual(Decimal("2.9286"), round(bid_order.quantity, 4))
self.assertAlmostEqual(Decimal("2.9286"), round(ask_order.quantity, 4))
def test_with_conversion(self):
self.clock.remove_iterator(self.strategy)
self.market_pair: CrossExchangeMarketPair = CrossExchangeMarketPair(
MarketTradingPairTuple(self.maker_market,
*["COINALPHA-QETH", "COINALPHA", "QETH"]),
MarketTradingPairTuple(self.taker_market,
*self.trading_pairs_taker),
)
self.maker_market.set_balanced_order_book("COINALPHA-QETH", 1.05, 0.55,
1.55, 0.01, 10)
config_map_raw = deepcopy(self.config_map_raw)
config_map_raw.min_profitability = Decimal("1")
config_map_raw.order_size_portfolio_ratio_limit = Decimal("30")
config_map_raw.conversion_rate_mode.taker_to_maker_base_conversion_rate = Decimal(
"0.95")
config_map = ClientConfigAdapter(config_map_raw)
self.strategy: CrossExchangeMarketMakingStrategy = CrossExchangeMarketMakingStrategy(
)
self.strategy.init_params(
config_map=config_map,
market_pairs=[self.market_pair],
logging_options=self.logging_options,
)
self.clock.add_iterator(self.strategy)
self.clock.backtest_til(self.start_timestamp + 5)
self.assertEqual(1, len(self.strategy.active_bids))
self.assertEqual(1, len(self.strategy.active_asks))
bid_order: LimitOrder = self.strategy.active_bids[0][1]
ask_order: LimitOrder = self.strategy.active_asks[0][1]
self.assertAlmostEqual(Decimal("1.0417"), round(bid_order.price, 4))
self.assertAlmostEqual(Decimal("1.0636"), round(ask_order.price, 4))
self.assertAlmostEqual(Decimal("2.9286"), round(bid_order.quantity, 4))
self.assertAlmostEqual(Decimal("2.9286"), round(ask_order.quantity, 4))
def test_with_adjust_orders_disabled(self):
self.clock.remove_iterator(self.strategy)
self.clock.remove_iterator(self.maker_market)
self.maker_market: MockPaperExchange = MockPaperExchange()
self.maker_market.set_balanced_order_book(self.maker_trading_pairs[0], 1.0, 0.5, 1.5, 0.1, 10)
self.taker_market.set_balanced_order_book(self.taker_trading_pairs[0], 1.0, 0.5, 1.5, 0.001, 20)
self.market_pair: CrossExchangeMarketPair = CrossExchangeMarketPair(
MarketTradingPairTuple(self.maker_market, *self.maker_trading_pairs),
MarketTradingPairTuple(self.taker_market, *self.taker_trading_pairs),
)
self.strategy: CrossExchangeMarketMakingStrategy = CrossExchangeMarketMakingStrategy()
self.strategy.init_params(
[self.market_pair],
order_size_portfolio_ratio_limit=Decimal("0.3"),
min_profitability=Decimal("0.005"),
logging_options=self.logging_options,
adjust_order_enabled=False
)
self.maker_market.set_balance("COINALPHA", 5)
self.maker_market.set_balance("WETH", 5)
self.maker_market.set_balance("QETH", 5)
self.maker_market.set_quantization_param(QuantizationParams(self.maker_trading_pairs[0], 4, 4, 4, 4))
self.clock.add_iterator(self.strategy)
self.clock.add_iterator(self.maker_market)
self.clock.backtest_til(self.start_timestamp + 5)
self.assertEqual(1, len(self.strategy.active_bids))
self.assertEqual(1, len(self.strategy.active_asks))
bid_order: LimitOrder = self.strategy.active_bids[0][1]
ask_order: LimitOrder = self.strategy.active_asks[0][1]
self.assertEqual(Decimal("0.9945"), bid_order.price)
self.assertEqual(Decimal("1.006"), ask_order.price)
self.assertAlmostEqual(Decimal("3"), round(bid_order.quantity, 4))
self.assertAlmostEqual(Decimal("3"), round(ask_order.quantity, 4))
def test_with_adjust_orders_enabled(self):
self.clock.remove_iterator(self.strategy)
self.clock.remove_iterator(self.maker_market)
self.maker_market: BacktestMarket = BacktestMarket()
self.maker_data: MockOrderBookLoader = MockOrderBookLoader(*self.maker_trading_pairs)
self.maker_data.set_balanced_order_book(1.0, 0.5, 1.5, 0.1, 10)
self.maker_market.add_data(self.maker_data)
self.market_pair: CrossExchangeMarketPair = CrossExchangeMarketPair(
MarketTradingPairTuple(self.maker_market, *self.maker_trading_pairs),
MarketTradingPairTuple(self.taker_market, *self.taker_trading_pairs),
)
self.strategy: CrossExchangeMarketMakingStrategy = CrossExchangeMarketMakingStrategy(
[self.market_pair],
order_size_portfolio_ratio_limit=Decimal("0.3"),
min_profitability=Decimal("0.005"),
logging_options=self.logging_options,
)
self.maker_market.set_balance("COINALPHA", 5)
self.maker_market.set_balance("WETH", 5)
self.maker_market.set_balance("QETH", 5)
self.maker_market.set_quantization_param(QuantizationParams(self.maker_trading_pairs[0], 4, 4, 4, 4))
self.clock.add_iterator(self.strategy)
self.clock.add_iterator(self.maker_market)
self.clock.backtest_til(self.start_timestamp + 5)
self.assertEqual(1, len(self.strategy.active_bids))
self.assertEqual(1, len(self.strategy.active_asks))
bid_order: LimitOrder = self.strategy.active_bids[0][1]
ask_order: LimitOrder = self.strategy.active_asks[0][1]
# place above top bid (at 0.95)
self.assertAlmostEqual(Decimal("0.9501"), bid_order.price)
# place below top ask (at 1.05)
self.assertAlmostEqual(Decimal("1.049"), ask_order.price)
self.assertAlmostEqual(Decimal("3"), round(bid_order.quantity, 4))
self.assertAlmostEqual(Decimal("3"), round(ask_order.quantity, 4))
def setUp(self):
self.clock: Clock = Clock(ClockMode.BACKTEST, 1.0,
self.start_timestamp, self.end_timestamp)
self.min_profitbality = 0.005
self.maker_market: BacktestMarket = BacktestMarket()
self.taker_market: BacktestMarket = BacktestMarket()
self.maker_data: MockOrderBookLoader = MockOrderBookLoader(
*self.maker_symbols)
self.taker_data: MockOrderBookLoader = MockOrderBookLoader(
*self.taker_symbols)
self.maker_data.set_balanced_order_book(1.0, 0.5, 1.5, 0.01, 10)
self.taker_data.set_balanced_order_book(1.0, 0.5, 1.5, 0.001, 4)
self.maker_market.add_data(self.maker_data)
self.taker_market.add_data(self.taker_data)
self.maker_market.set_balance("COINALPHA", 5)
self.maker_market.set_balance("WETH", 5)
self.maker_market.set_balance("QETH", 5)
self.taker_market.set_balance("COINALPHA", 5)
self.taker_market.set_balance("ETH", 5)
self.maker_market.set_quantization_param(
QuantizationParams(self.maker_symbols[0], 5, 5, 5, 5))
self.taker_market.set_quantization_param(
QuantizationParams(self.taker_symbols[0], 5, 5, 5, 5))
self.market_pair: CrossExchangeMarketPair = CrossExchangeMarketPair(
MarketTradingPairTuple(self.maker_market, *self.maker_symbols),
MarketTradingPairTuple(self.taker_market, *self.taker_symbols),
)
logging_options: int = (
CrossExchangeMarketMakingStrategy.OPTION_LOG_ALL
& (~CrossExchangeMarketMakingStrategy.OPTION_LOG_NULL_ORDER_SIZE))
self.strategy: CrossExchangeMarketMakingStrategy = CrossExchangeMarketMakingStrategy(
[self.market_pair],
order_size_portfolio_ratio_limit=0.3,
min_profitability=self.min_profitbality,
logging_options=logging_options,
)
self.strategy_with_top_depth_tolerance: CrossExchangeMarketMakingStrategy = CrossExchangeMarketMakingStrategy(
[self.market_pair],
order_size_portfolio_ratio_limit=0.3,
min_profitability=self.min_profitbality,
logging_options=logging_options,
top_depth_tolerance=1)
self.logging_options = logging_options
self.clock.add_iterator(self.maker_market)
self.clock.add_iterator(self.taker_market)
self.clock.add_iterator(self.strategy)
self.maker_order_fill_logger: EventLogger = EventLogger()
self.taker_order_fill_logger: EventLogger = EventLogger()
self.cancel_order_logger: EventLogger = EventLogger()
self.maker_market.add_listener(MarketEvent.OrderFilled,
self.maker_order_fill_logger)
self.taker_market.add_listener(MarketEvent.OrderFilled,
self.taker_order_fill_logger)
self.maker_market.add_listener(MarketEvent.OrderCancelled,
self.cancel_order_logger)
def setUp(self):
self.clock: Clock = Clock(ClockMode.BACKTEST, 1.0, self.start_timestamp, self.end_timestamp)
self.min_profitbality = Decimal("0.005")
self.maker_market: MockPaperExchange = MockPaperExchange()
self.taker_market: MockPaperExchange = MockPaperExchange()
self.maker_market.set_balanced_order_book(self.maker_trading_pairs[0], 1.0, 0.5, 1.5, 0.01, 10)
self.taker_market.set_balanced_order_book(self.taker_trading_pairs[0], 1.0, 0.5, 1.5, 0.001, 4)
self.maker_market.set_balance("COINALPHA", 5)
self.maker_market.set_balance("WETH", 5)
self.maker_market.set_balance("QETH", 5)
self.taker_market.set_balance("COINALPHA", 5)
self.taker_market.set_balance("ETH", 5)
self.maker_market.set_quantization_param(QuantizationParams(self.maker_trading_pairs[0], 5, 5, 5, 5))
self.taker_market.set_quantization_param(QuantizationParams(self.taker_trading_pairs[0], 5, 5, 5, 5))
self.market_pair: CrossExchangeMarketPair = CrossExchangeMarketPair(
MarketTradingPairTuple(self.maker_market, *self.maker_trading_pairs),
MarketTradingPairTuple(self.taker_market, *self.taker_trading_pairs),
)
logging_options: int = (
CrossExchangeMarketMakingStrategy.OPTION_LOG_ALL
& (~CrossExchangeMarketMakingStrategy.OPTION_LOG_NULL_ORDER_SIZE)
)
self.strategy: CrossExchangeMarketMakingStrategy = CrossExchangeMarketMakingStrategy()
self.strategy.init_params(
[self.market_pair],
order_size_portfolio_ratio_limit=Decimal("0.3"),
min_profitability=Decimal(self.min_profitbality),
logging_options=logging_options,
slippage_buffer=Decimal("0"),
)
self.strategy_with_top_depth_tolerance: CrossExchangeMarketMakingStrategy = CrossExchangeMarketMakingStrategy()
self.strategy_with_top_depth_tolerance.init_params(
[self.market_pair],
order_size_portfolio_ratio_limit=Decimal("0.3"),
min_profitability=Decimal(self.min_profitbality),
logging_options=logging_options,
top_depth_tolerance=1,
slippage_buffer=Decimal("0"),
)
self.logging_options = logging_options
self.clock.add_iterator(self.maker_market)
self.clock.add_iterator(self.taker_market)
self.clock.add_iterator(self.strategy)
self.maker_order_fill_logger: EventLogger = EventLogger()
self.taker_order_fill_logger: EventLogger = EventLogger()
self.cancel_order_logger: EventLogger = EventLogger()
self.maker_order_created_logger: EventLogger = EventLogger()
self.taker_order_created_logger: EventLogger = EventLogger()
self.maker_market.add_listener(MarketEvent.OrderFilled, self.maker_order_fill_logger)
self.taker_market.add_listener(MarketEvent.OrderFilled, self.taker_order_fill_logger)
self.maker_market.add_listener(MarketEvent.OrderCancelled, self.cancel_order_logger)
self.maker_market.add_listener(MarketEvent.BuyOrderCreated, self.maker_order_created_logger)
self.maker_market.add_listener(MarketEvent.SellOrderCreated, self.maker_order_created_logger)
self.taker_market.add_listener(MarketEvent.BuyOrderCreated, self.taker_order_created_logger)
self.taker_market.add_listener(MarketEvent.SellOrderCreated, self.taker_order_created_logger)
def setUp(self):
self.clock: Clock = Clock(ClockMode.BACKTEST, 1.0, self.start_timestamp, self.end_timestamp)
self.maker_market: BacktestMarket = BacktestMarket()
self.taker_market: BacktestMarket = BacktestMarket()
self.maker_data: MockOrderBookLoader = MockOrderBookLoader(*self.maker_symbols)
self.taker_data: MockOrderBookLoader = MockOrderBookLoader(*self.taker_symbols)
self.maker_data.set_balanced_order_book(1.0, 0.5, 1.5, 0.01, 10)
self.taker_data.set_balanced_order_book(1.0, 0.5, 1.5, 0.001, 3)
self.maker_market.add_data(self.maker_data)
self.taker_market.add_data(self.taker_data)
self.maker_market.set_balance("COINALPHA", 5)
self.maker_market.set_balance("WETH", 5)
self.taker_market.set_balance("COINALPHA", 5)
self.taker_market.set_balance("ETH", 5)
self.maker_market.set_quantization_param(
QuantizationParams(
self.maker_symbols[0], 5, 5, 5, 5
)
)
self.taker_market.set_quantization_param(
QuantizationParams(
self.taker_symbols[0], 5, 5, 5, 5
)
)
self.market_pair: CrossExchangeMarketPair = CrossExchangeMarketPair(
*(
[self.maker_market] + self.maker_symbols +
[self.taker_market] + self.taker_symbols +
[2]
)
)
logging_options: int = (CrossExchangeMarketMakingStrategy.OPTION_LOG_ALL &
(~CrossExchangeMarketMakingStrategy.OPTION_LOG_NULL_ORDER_SIZE))
self.strategy: CrossExchangeMarketMakingStrategy = CrossExchangeMarketMakingStrategy(
[self.market_pair],
0.003,
order_size_portfolio_ratio_limit=0.3,
logging_options=logging_options
)
self.clock.add_iterator(self.maker_market)
self.clock.add_iterator(self.taker_market)
self.clock.add_iterator(self.strategy)
self.maker_order_fill_logger: EventLogger = EventLogger()
self.taker_order_fill_logger: EventLogger = EventLogger()
self.cancel_order_logger: EventLogger = EventLogger()
self.maker_market.add_listener(MarketEvent.OrderFilled, self.maker_order_fill_logger)
self.taker_market.add_listener(MarketEvent.OrderFilled, self.taker_order_fill_logger)
self.maker_market.add_listener(MarketEvent.OrderCancelled, self.cancel_order_logger)
def test_with_adjust_orders_enabled(self):
self.clock.remove_iterator(self.strategy)
self.clock.remove_iterator(self.maker_market)
self.maker_market: MockPaperExchange = MockPaperExchange(
client_config_map=ClientConfigAdapter(ClientConfigMap()))
self.maker_market.set_balanced_order_book(self.trading_pairs_maker[0],
1.0, 0.5, 1.5, 0.1, 10)
self.market_pair: CrossExchangeMarketPair = CrossExchangeMarketPair(
MarketTradingPairTuple(self.maker_market,
*self.trading_pairs_maker),
MarketTradingPairTuple(self.taker_market,
*self.trading_pairs_taker),
)
config_map_raw = deepcopy(self.config_map_raw)
config_map_raw.order_size_portfolio_ratio_limit = Decimal("30")
config_map_raw.min_profitability = Decimal("0.5")
config_map_raw.adjust_order_enabled = True
config_map = ClientConfigAdapter(config_map_raw)
self.strategy: CrossExchangeMarketMakingStrategy = CrossExchangeMarketMakingStrategy(
)
self.strategy.init_params(
config_map=config_map,
market_pairs=[self.market_pair],
logging_options=self.logging_options,
)
self.maker_market.set_balance("COINALPHA", 5)
self.maker_market.set_balance("WETH", 5)
self.maker_market.set_balance("QETH", 5)
self.maker_market.set_quantization_param(
QuantizationParams(self.trading_pairs_maker[0], 4, 4, 4, 4))
self.clock.add_iterator(self.strategy)
self.clock.add_iterator(self.maker_market)
self.clock.backtest_til(self.start_timestamp + 5)
self.assertEqual(1, len(self.strategy.active_bids))
self.assertEqual(1, len(self.strategy.active_asks))
bid_order: LimitOrder = self.strategy.active_bids[0][1]
ask_order: LimitOrder = self.strategy.active_asks[0][1]
# place above top bid (at 0.95)
self.assertAlmostEqual(Decimal("0.9501"), bid_order.price)
# place below top ask (at 1.05)
self.assertAlmostEqual(Decimal("1.049"), ask_order.price)
self.assertAlmostEqual(Decimal("3"), round(bid_order.quantity, 4))
self.assertAlmostEqual(Decimal("3"), round(ask_order.quantity, 4))
def test_profitability_with_conversion(self):
self.clock.remove_iterator(self.strategy)
self.market_pair: CrossExchangeMarketPair = CrossExchangeMarketPair(
*(
[self.maker_market] + ["COINALPHA-QETH", "COINALPHA", "QETH"] +
[self.taker_market] + self.taker_symbols +
[2]
)
)
self.maker_data: MockOrderBookLoader = MockOrderBookLoader("COINALPHA-QETH", "COINALPHA", "QETH")
self.maker_data.set_balanced_order_book(1.05263, 0.55, 1.55, 0.01, 10)
self.maker_market.add_data(self.maker_data)
self.strategy: CrossExchangeMarketMakingStrategy = CrossExchangeMarketMakingStrategy(
[self.market_pair],
0.01,
order_size_portfolio_ratio_limit=0.3,
logging_options=self.logging_options
)
self.clock.add_iterator(self.strategy)
self.clock.backtest_til(self.start_timestamp + 5)
self.assertEqual(0, len(self.strategy.active_bids))
self.assertEqual(0, len(self.strategy.active_asks))
self.assertEqual((False, False), self.strategy.has_market_making_profit_potential(
self.market_pair,
self.maker_data.order_book,
self.taker_data.order_book
))
self.clock.remove_iterator(self.strategy)
self.strategy: CrossExchangeMarketMakingStrategy = CrossExchangeMarketMakingStrategy(
[self.market_pair],
0.003,
order_size_portfolio_ratio_limit=0.3,
logging_options=self.logging_options
)
self.clock.add_iterator(self.strategy)
self.clock.backtest_til(self.start_timestamp + 10)
self.assertEqual(1, len(self.strategy.active_bids))
self.assertEqual(1, len(self.strategy.active_asks))
self.assertEqual((True, True), self.strategy.has_market_making_profit_potential(
self.market_pair,
self.maker_data.order_book,
self.taker_data.order_book
))
def setUp(self):
self.clock: Clock = Clock(ClockMode.BACKTEST, 1.0,
self.start_timestamp, self.end_timestamp)
self.min_profitability = Decimal("0.005")
self.maker_market: MockPaperExchange = MockPaperExchange(
client_config_map=ClientConfigAdapter(ClientConfigMap()))
self.taker_market: MockPaperExchange = MockPaperExchange(
client_config_map=ClientConfigAdapter(ClientConfigMap()))
self.maker_market.set_balanced_order_book(self.trading_pairs_maker[0],
1.0, 0.5, 1.5, 0.01, 10)
self.taker_market.set_balanced_order_book(self.trading_pairs_taker[0],
1.0, 0.5, 1.5, 0.001, 4)
self.maker_market.set_balance("COINALPHA", 5)
self.maker_market.set_balance("WETH", 5)
self.maker_market.set_balance("QETH", 5)
self.taker_market.set_balance("COINALPHA", 5)
self.taker_market.set_balance("ETH", 5)
self.maker_market.set_quantization_param(
QuantizationParams(self.trading_pairs_maker[0], 5, 5, 5, 5))
self.taker_market.set_quantization_param(
QuantizationParams(self.trading_pairs_taker[0], 5, 5, 5, 5))
self.market_pair: CrossExchangeMarketPair = CrossExchangeMarketPair(
MarketTradingPairTuple(self.maker_market,
*self.trading_pairs_maker),
MarketTradingPairTuple(self.taker_market,
*self.trading_pairs_taker),
)
self.config_map_raw = CrossExchangeMarketMakingConfigMap(
maker_market=self.exchange_name_maker,
taker_market=self.exchange_name_taker,
maker_market_trading_pair=self.trading_pairs_maker[0],
taker_market_trading_pair=self.trading_pairs_taker[0],
min_profitability=Decimal(self.min_profitability),
slippage_buffer=Decimal("0"),
order_amount=Decimal("0"),
# Default values folllow
order_size_taker_volume_factor=Decimal("25"),
order_size_taker_balance_factor=Decimal("99.5"),
order_size_portfolio_ratio_limit=Decimal("30"),
adjust_order_enabled=True,
anti_hysteresis_duration=60.0,
order_refresh_mode=ActiveOrderRefreshMode(),
top_depth_tolerance=Decimal(0),
conversion_rate_mode=TakerToMakerConversionRateMode(),
)
self.config_map_raw.conversion_rate_mode.taker_to_maker_base_conversion_rate = Decimal(
"1.0")
self.config_map_raw.conversion_rate_mode.taker_to_maker_quote_conversion_rate = Decimal(
"1.0")
self.config_map = ClientConfigAdapter(self.config_map_raw)
config_map_with_top_depth_tolerance_raw = deepcopy(self.config_map_raw)
config_map_with_top_depth_tolerance_raw.top_depth_tolerance = Decimal(
"1")
config_map_with_top_depth_tolerance = ClientConfigAdapter(
config_map_with_top_depth_tolerance_raw)
logging_options: int = (
CrossExchangeMarketMakingStrategy.OPTION_LOG_ALL
& (~CrossExchangeMarketMakingStrategy.OPTION_LOG_NULL_ORDER_SIZE))
self.strategy: CrossExchangeMarketMakingStrategy = CrossExchangeMarketMakingStrategy(
)
self.strategy.init_params(
config_map=self.config_map,
market_pairs=[self.market_pair],
logging_options=logging_options,
)
self.strategy_with_top_depth_tolerance: CrossExchangeMarketMakingStrategy = CrossExchangeMarketMakingStrategy(
)
self.strategy_with_top_depth_tolerance.init_params(
config_map=config_map_with_top_depth_tolerance,
market_pairs=[self.market_pair],
logging_options=logging_options,
)
self.logging_options = logging_options
self.clock.add_iterator(self.maker_market)
self.clock.add_iterator(self.taker_market)
self.clock.add_iterator(self.strategy)
self.maker_order_fill_logger: EventLogger = EventLogger()
self.taker_order_fill_logger: EventLogger = EventLogger()
self.cancel_order_logger: EventLogger = EventLogger()
self.maker_order_created_logger: EventLogger = EventLogger()
self.taker_order_created_logger: EventLogger = EventLogger()
self.maker_market.add_listener(MarketEvent.OrderFilled,
self.maker_order_fill_logger)
self.taker_market.add_listener(MarketEvent.OrderFilled,
self.taker_order_fill_logger)
self.maker_market.add_listener(MarketEvent.OrderCancelled,
self.cancel_order_logger)
self.maker_market.add_listener(MarketEvent.BuyOrderCreated,
self.maker_order_created_logger)
self.maker_market.add_listener(MarketEvent.SellOrderCreated,
self.maker_order_created_logger)
self.taker_market.add_listener(MarketEvent.BuyOrderCreated,
self.taker_order_created_logger)
self.taker_market.add_listener(MarketEvent.SellOrderCreated,
self.taker_order_created_logger)