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_symbols), ) 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], 0.01, order_size_portfolio_ratio_limit=0.3, logging_options=self.logging_options) self.maker_market.set_quantization_param( QuantizationParams(self.maker_symbols[0], 2, 2, 2, 2)) self.taker_market.set_quantization_param( QuantizationParams(self.taker_symbols[0], 2, 2, 2, 2)) 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 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.order_fill_logger: EventLogger = EventLogger() self.cancel_order_logger: EventLogger = EventLogger() self.clock: Clock = Clock(ClockMode.BACKTEST, 1, self.start_timestamp, self.end_timestamp) self.spot_connector: BacktestMarket = BacktestMarket() self.spot_obook: MockOrderBookLoader = MockOrderBookLoader(self.trading_pair, self.base_asset, self.quote_asset) self.spot_obook.set_balanced_order_book(mid_price=100, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.spot_connector.add_data(self.spot_obook) self.spot_connector.set_balance("HBOT", 500) self.spot_connector.set_balance("ETH", 5000) self.spot_connector.set_quantization_param( QuantizationParams( self.trading_pair, 6, 6, 6, 6 ) ) self.spot_market_info = MarketTradingPairTuple(self.spot_connector, self.trading_pair, self.base_asset, self.quote_asset) self.perp_connector: MockPerpConnector = MockPerpConnector() self.perp_obook: MockOrderBookLoader = MockOrderBookLoader(self.trading_pair, self.base_asset, self.quote_asset) self.perp_obook.set_balanced_order_book(mid_price=110, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.perp_connector.add_data(self.perp_obook) self.perp_connector.set_balance("HBOT", 500) self.perp_connector.set_balance("ETH", 5000) self.perp_connector.set_quantization_param( QuantizationParams( self.trading_pair, 6, 6, 6, 6 ) ) self.perp_market_info = MarketTradingPairTuple(self.perp_connector, self.trading_pair, self.base_asset, self.quote_asset) self.clock.add_iterator(self.spot_connector) self.clock.add_iterator(self.perp_connector) self.spot_connector.add_listener(MarketEvent.OrderFilled, self.order_fill_logger) self.spot_connector.add_listener(MarketEvent.OrderCancelled, self.cancel_order_logger) self.perp_connector.add_listener(MarketEvent.OrderFilled, self.order_fill_logger) self.perp_connector.add_listener(MarketEvent.OrderCancelled, self.cancel_order_logger) self.strategy = SpotPerpetualArbitrageStrategy( self.spot_market_info, self.perp_market_info, order_amount=Decimal("1"), derivative_leverage=5, min_divergence=Decimal("0.05"), min_convergence=Decimal("0.01") )
def setUp(self): self.maxDiff = None self.clock: Clock = Clock(ClockMode.BACKTEST, 1.0, self.start_timestamp, self.end_timestamp) self.market_1: BacktestMarket = BacktestMarket() self.market_2: BacktestMarket = BacktestMarket() self.market_1_data: MockOrderBookLoader = MockOrderBookLoader(*self.market_1_trading_pairs) self.market_2_data: MockOrderBookLoader = MockOrderBookLoader(*self.market_2_trading_pairs) self.market_1_data.set_balanced_order_book(1.0, 0.5, 1.5, 0.01, 10) self.market_2_data.set_balanced_order_book(1.0, 0.5, 1.5, 0.005, 5) self.market_1.add_data(self.market_1_data) self.market_2.add_data(self.market_2_data) 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.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 setUp(self): self.clock: Clock = Clock(ClockMode.BACKTEST, 1.0, self.start_timestamp, self.end_timestamp) self.market_1: BacktestMarket = BacktestMarket() self.market_2: BacktestMarket = BacktestMarket() self.market_1_data: MockOrderBookLoader = MockOrderBookLoader( *self.market_1_symbols) self.market_2_data: MockOrderBookLoader = MockOrderBookLoader( *self.market_2_symbols) self.market_1_data.set_balanced_order_book(1.0, 0.5, 1.5, 0.01, 10) self.market_2_data.set_balanced_order_book(1.0, 0.5, 1.5, 0.005, 5) self.market_1.add_data(self.market_1_data) self.market_2.add_data(self.market_2_data) 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_symbols[0], 5, 5, 5, 5)) self.market_2.set_quantization_param( QuantizationParams(self.market_2_symbols[0], 5, 5, 5, 5)) self.market_symbol_pair_1 = MarketSymbolPair(*([self.market_1] + self.market_1_symbols)) self.market_symbol_pair_2 = MarketSymbolPair(*([self.market_2] + self.market_2_symbols)) self.market_pair: ArbitrageMarketPair = ArbitrageMarketPair( *(self.market_symbol_pair_1 + self.market_symbol_pair_2)) self.logging_options: int = ArbitrageStrategy.OPTION_LOG_ALL self.strategy: ArbitrageStrategy = ArbitrageStrategy( [self.market_pair], min_profitability=0.03, logging_options=self.logging_options) 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 main(): # Define the data cache path. hummingsim.set_data_path(os.path.join(os.environ["PWD"], "data")) # Define the parameters for the backtest. start = pd.Timestamp("2018-12-12", tz="UTC") end = pd.Timestamp("2019-01-12", tz="UTC") binance_symbol = ("ETHUSDT", "ETH", "USDT") ddex_symbol = ("WETH-DAI", "WETH", "DAI") binance_market = BacktestMarket() ddex_market = BacktestMarket() binance_market.config = MarketConfig(AssetType.BASE_CURRENCY, 0.001, AssetType.QUOTE_CURRENCY, 0.001, {}) ddex_market.config = MarketConfig(AssetType.BASE_CURRENCY, 0.001, AssetType.QUOTE_CURRENCY, 0.001, {}) binance_loader = BinanceOrderBookLoaderV2(*binance_symbol) ddex_loader = DDEXOrderBookLoader(*ddex_symbol) binance_market.add_data(binance_loader) ddex_market.add_data(ddex_loader) binance_market.set_quantization_param( QuantizationParams("ETHUSDT", 5, 3, 5, 3)) ddex_market.set_quantization_param( QuantizationParams("WETH-DAI", 5, 3, 5, 3)) market_pair = CrossExchangeMarketPair(*([ddex_market] + list(ddex_symbol) + [binance_market] + list(binance_symbol))) strategy = CrossExchangeMarketMakingStrategy( [market_pair], 0.003, logging_options=CrossExchangeMarketMakingStrategy. OPTION_LOG_MAKER_ORDER_FILLED) clock = Clock(ClockMode.BACKTEST, start_time=start.timestamp(), end_time=end.timestamp()) clock.add_iterator(binance_market) clock.add_iterator(ddex_market) clock.add_iterator(strategy) binance_market.set_balance("ETH", 10.0) binance_market.set_balance("USDT", 1000.0) ddex_market.set_balance("WETH", 10.0) ddex_market.set_balance("DAI", 1000.0) clock.backtest() binance_loader.close() ddex_loader.close()
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 setUp(self): self.clock_tick_size = 1 self.clock: Clock = Clock(ClockMode.BACKTEST, self.clock_tick_size, self.start_timestamp, self.end_timestamp) self.market: BacktestMarket = BacktestMarket() self.book_data: MockOrderBookLoader = MockOrderBookLoader( self.trading_pair, self.base_asset, self.quote_asset) self.mid_price = 100 self.bid_spread = 0.01 self.ask_spread = 0.01 self.order_refresh_time = 30 self.book_data.set_balanced_order_book(mid_price=self.mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.market.add_data(self.book_data) self.market.set_balance("HBOT", 500) self.market.set_balance("ETH", 5000) self.market.set_quantization_param( QuantizationParams(self.trading_pair, 6, 6, 6, 6)) self.market_info = MarketTradingPairTuple(self.market, self.trading_pair, self.base_asset, self.quote_asset) self.clock.add_iterator(self.market) self.order_fill_logger: EventLogger = EventLogger() self.cancel_order_logger: EventLogger = EventLogger() self.market.add_listener(MarketEvent.OrderFilled, self.order_fill_logger) self.market.add_listener(MarketEvent.OrderCancelled, self.cancel_order_logger) self.ext_market: BacktestMarket = BacktestMarket() self.ext_data: MockOrderBookLoader = MockOrderBookLoader( self.trading_pair, self.base_asset, self.quote_asset) self.ext_market_info: MarketTradingPairTuple = MarketTradingPairTuple( self.ext_market, self.trading_pair, self.base_asset, self.quote_asset) self.ext_data.set_balanced_order_book(mid_price=100, min_price=1, max_price=400, price_step_size=1, volume_step_size=100) self.ext_market.add_data(self.ext_data) self.order_book_asset_del = OrderBookAssetPriceDelegate( self.ext_market, self.trading_pair) self.one_level_strategy = PureMarketMakingStrategy() self.one_level_strategy.init_params( self.market_info, bid_spread=Decimal("0.01"), ask_spread=Decimal("0.01"), order_amount=Decimal("1"), order_refresh_time=3.0, filled_order_delay=3.0, order_refresh_tolerance_pct=-1, minimum_spread=-1, asset_price_delegate=self.order_book_asset_del, take_if_crossed=True)
def setUp(self): self.maxDiff = None self.clock: Clock = Clock(ClockMode.BACKTEST, 1.0, self.start_timestamp, self.end_timestamp) self.market: BacktestMarket = BacktestMarket() self.market_data = MockOrderBookLoader(self.trading_pair, self.base_asset, self.quote_asset) self.market_data.set_balanced_order_book(10, 5, 15, 0.1, 1) self.market.add_data(self.market_data) 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.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 test_market_ready(self): # Simulate Order Book being populated quote_balance = 5000 self.maker_data: MockOrderBookLoader = MockOrderBookLoader( trading_pair=self.trading_pair, base_currency=self.base_asset, quote_currency=self.quote_asset, ) self.mid_price = 100 self.time_delay = 15 self.cancel_order_wait_time = 45 self.maker_data.set_balanced_order_book(mid_price=self.mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.market.add_data(self.maker_data) self.market.set_balance("COINALPHA", 500) self.market.set_balance("HBOT", quote_balance) self.market.set_quantization_param( QuantizationParams(self.trading_pair, 6, 6, 6, 6)) self.clock.add_iterator(self.market) self.clock.add_iterator(self.strategy) self.clock.backtest_til(self.start_timestamp + self.tick_size) # Check status output when market is ready status_msg_output: str = self.ev_loop.run_until_complete( self.strategy.format_status()) self.assertTrue("Assets:" in status_msg_output) self.assertTrue(f"HBOT {quote_balance}" in status_msg_output)
def setUp(self): super().setUp() self.log_records = [] self.clock: Clock = Clock(ClockMode.BACKTEST, self.clock_tick_size, self.start_timestamp, self.end_timestamp) self.market: BacktestMarket = BacktestMarket() self.maker_data: MockOrderBookLoader = MockOrderBookLoader( *self.maker_trading_pairs) self.mid_price = 100 self.order_delay_time = 15 self.cancel_order_wait_time = 45 self.maker_data.set_balanced_order_book(mid_price=self.mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.market.add_data(self.maker_data) self.market.set_balance("COINALPHA", 500) self.market.set_balance("WETH", 50000) self.market.set_balance("QETH", 500) self.market.set_quantization_param( QuantizationParams(self.maker_trading_pairs[0], 6, 6, 6, 6)) self.market_info: MarketTradingPairTuple = MarketTradingPairTuple( *([self.market] + self.maker_trading_pairs)) # Define strategies to test self.limit_buy_strategy: TwapTradeStrategy = TwapTradeStrategy( [self.market_info], order_price=Decimal("99"), cancel_order_wait_time=self.cancel_order_wait_time, is_buy=True, order_delay_time=self.order_delay_time, target_asset_amount=Decimal("2.0"), order_step_size=Decimal("1.0")) self.limit_sell_strategy: TwapTradeStrategy = TwapTradeStrategy( [self.market_info], order_price=Decimal("101"), cancel_order_wait_time=self.cancel_order_wait_time, is_buy=False, order_delay_time=self.order_delay_time, target_asset_amount=Decimal("5.0"), order_step_size=Decimal("1.67")) self.clock.add_iterator(self.market) self.maker_order_fill_logger: EventLogger = EventLogger() self.cancel_order_logger: EventLogger = EventLogger() self.buy_order_completed_logger: EventLogger = EventLogger() self.sell_order_completed_logger: EventLogger = EventLogger() self.market.add_listener(MarketEvent.BuyOrderCompleted, self.buy_order_completed_logger) self.market.add_listener(MarketEvent.SellOrderCompleted, self.sell_order_completed_logger) self.market.add_listener(MarketEvent.OrderFilled, self.maker_order_fill_logger) self.market.add_listener(MarketEvent.OrderCancelled, self.cancel_order_logger)
def test_with_adjust_orders_disabled(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.taker_data.set_balanced_order_book(1.0, 0.5, 1.5, 0.001, 20) 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, 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 setUp(self): self.clock_tick_size = 1 self.clock: Clock = Clock(ClockMode.BACKTEST, self.clock_tick_size, self.start_timestamp, self.end_timestamp) self.market: BacktestMarket = BacktestMarket() self.book_data: MockOrderBookLoader = MockOrderBookLoader( self.trading_pair, self.base_asset, self.quote_asset) self.mid_price = 100 self.bid_spread = 0.01 self.ask_spread = 0.01 self.order_refresh_time = 30 self.book_data.set_balanced_order_book(mid_price=self.mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.market.add_data(self.book_data) self.market.set_balance("HBOT", 500) self.market.set_balance("ETH", 5000) self.market.set_quantization_param( QuantizationParams(self.trading_pair, 6, 6, 6, 6)) self.market_info = MarketTradingPairTuple(self.market, self.trading_pair, self.base_asset, self.quote_asset) self.clock.add_iterator(self.market) self.maker_order_fill_logger: EventLogger = EventLogger() self.cancel_order_logger: EventLogger = EventLogger() self.market.add_listener(MarketEvent.OrderFilled, self.maker_order_fill_logger) self.market.add_listener(MarketEvent.OrderCancelled, self.cancel_order_logger)
def create_market( trading_pairs: List[str], mid_price, balances: Dict[str, int] ) -> (BacktestMarket, Dict[str, MarketTradingPairTuple]): """ Create a BacktestMarket and marketinfo dictionary to be used by the liquidity mining strategy """ market: ExtendedBacktestMarket = ExtendedBacktestMarket() market_infos: Dict[str, MarketTradingPairTuple] = {} for trading_pair in trading_pairs: base_asset = trading_pair.split("-")[0] quote_asset = trading_pair.split("-")[1] book_data: MockOrderBookLoader = MockOrderBookLoader( trading_pair, base_asset, quote_asset) book_data.set_balanced_order_book(mid_price=mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) market.add_data(book_data) 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 test_empty_maker_orderbook(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) # Orderbook is empty 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_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 setUp(self): self.clock_tick_size = 1 self.clock: Clock = Clock(ClockMode.BACKTEST, self.clock_tick_size, self.start_timestamp, self.end_timestamp) self.market: BacktestMarket = BacktestMarket() self.maker_data: MockOrderBookLoader = MockOrderBookLoader(*self.maker_trading_pairs) self.mid_price = 100 self.maker_data.set_balanced_order_book(mid_price=self.mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.market.add_data(self.maker_data) self.market.set_balance("COINALPHA", 500) self.market.set_balance("WETH", 5000) self.market.set_balance("QETH", 500) self.market.set_quantization_param( QuantizationParams( self.maker_trading_pairs[0], 6, 6, 6, 6 ) ) self.market_info: MarketTradingPairTuple = MarketTradingPairTuple( self.market, self.maker_trading_pairs[0], self.maker_trading_pairs[1], self.maker_trading_pairs[2] ) self.strategy: PureMarketMakingStrategy = PureMarketMakingStrategy( self.market_info, bid_spread=Decimal(.05), ask_spread=Decimal(.05), order_amount=Decimal(1), order_refresh_time=30, minimum_spread=0, )
def main(): # Define the data cache path. hummingsim.set_data_path(os.path.join(os.environ["PWD"], "data")) # Define the parameters for the backtest. start = pd.Timestamp("2019-01-01", tz="UTC") end = pd.Timestamp("2019-01-02", tz="UTC") binance_trading_pair = ("ETHUSDT", "ETH", "USDT") # ddex_trading_pair = ("WETH-DAI", "WETH", "DAI") binance_market = BacktestMarket() ddex_market = BacktestMarket() binance_market.config = MarketConfig(AssetType.BASE_CURRENCY, 0.001, AssetType.QUOTE_CURRENCY, 0.001, {}) ddex_market.config = MarketConfig(AssetType.BASE_CURRENCY, 0.001, AssetType.QUOTE_CURRENCY, 0.001, {}) binance_loader = BinanceOrderBookLoaderV2(*binance_trading_pair) #ddex_loader = DDEXOrderBookLoader(*ddex_trading_pair) binance_market.add_data(binance_loader) #ddex_market.add_data(ddex_loader) binance_market.set_quantization_param( QuantizationParams("ETHUSDT", 5, 3, 5, 3)) #ddex_market.set_quantization_param(QuantizationParams("WETH-DAI", 5, 3, 5, 3)) market_pair = PureMarketPair(*([binance_market] + list(binance_trading_pair))) strategy = PureMarketMakingStrategy( [market_pair], order_size=50000, bid_place_threshold=0.003, ask_place_threshold=0.003, logging_options=PureMarketMakingStrategy.OPTION_LOG_ALL) clock = Clock(ClockMode.BACKTEST, tick_size=60, start_time=start.timestamp(), end_time=end.timestamp()) clock.add_iterator(binance_market) #clock.add_iterator(ddex_market) clock.add_iterator(strategy) binance_market.set_balance("ETH", 100000.0) binance_market.set_balance("USDT", 100000000.0) ddex_market.set_balance("WETH", 100000.0) ddex_market.set_balance("DAI", 1000.0) current = start.timestamp() step = 60 while current <= end.timestamp(): current += step clock.backtest_til(current) print("clock ticked") binance_loader.close()
def setUp(self): self.clock_tick_size = 1 self._last_clock_tick = 0 self.clock: Clock = Clock(ClockMode.BACKTEST, self.clock_tick_size, self.start_timestamp, self.end_timestamp) self.market: BacktestMarket = BacktestMarket() self.book_data: MockOrderBookLoader = MockOrderBookLoader( self.trading_pair, self.base_asset, self.quote_asset) self.mid_price = 100 self.bid_spread = 0.01 self.ask_spread = 0.01 self.order_refresh_time = 30 self.book_data.set_balanced_order_book(mid_price=self.mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.market.add_data(self.book_data) self.market.set_balance("HBOT", 500) self.market.set_balance("ETH", 5000) self.market.set_quantization_param( QuantizationParams(self.trading_pair, 6, 6, 6, 6)) self.market_info = MarketTradingPairTuple(self.market, self.trading_pair, self.base_asset, self.quote_asset) self.clock.add_iterator(self.market) self.one_level_strategy = PureMarketMakingStrategy( self.market_info, bid_spread=Decimal("0.01"), ask_spread=Decimal("0.01"), order_amount=Decimal("1"), order_refresh_time=5.0, filled_order_delay=5.0, order_refresh_tolerance_pct=-1, minimum_spread=-1, ) self.multi_levels_strategy = PureMarketMakingStrategy( self.market_info, bid_spread=Decimal("0.01"), ask_spread=Decimal("0.01"), order_amount=Decimal("1"), order_refresh_time=5.0, filled_order_delay=5.0, order_refresh_tolerance_pct=-1, order_levels=3, order_level_spread=Decimal("0.01"), order_level_amount=Decimal("1"), minimum_spread=-1, ) self._ev_loop = asyncio.get_event_loop()
def test_market_ready(self): # Simulate Order Book being populated quote_balance = 5000 self.maker_data: MockOrderBookLoader = MockOrderBookLoader( trading_pair=self.trading_pair, base_currency=self.base_asset, quote_currency=self.quote_asset, ) self.mid_price = 100 self.time_delay = 15 self.cancel_order_wait_time = 45 self.maker_data.set_balanced_order_book(mid_price=self.mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.market.add_data(self.maker_data) self.market.set_balance("COINALPHA", 500) self.market.set_balance("HBOT", quote_balance) self.market.set_quantization_param( QuantizationParams(self.trading_pair, 6, 6, 6, 6)) expected_best_ask = min([ row.price for row in self.market.order_book_ask_entries(self.trading_pair) ]) expected_best_bid = max([ row.price for row in self.market.order_book_bid_entries(self.trading_pair) ]) self.clock.add_iterator(self.market) self.clock.add_iterator(self.strategy) self.clock.backtest_til(self.start_timestamp + self.tick_size) # Check status output when market is ready status_msg_output: str = self.ev_loop.run_until_complete( self.strategy.format_status()) curr_best_bid, curr_best_ask = [ Decimal(item) for item in status_msg_output.split('\n')[2].split(' ') if item != '' ] self.assertEqual(expected_best_bid, curr_best_bid) self.assertEqual(expected_best_ask, curr_best_ask)
def setUp(self): self.clock: Clock = Clock(ClockMode.BACKTEST, 60.0, self.start_timestamp, self.end_timestamp) self.clock_tick_size = 60 self.maker_market: BacktestMarket = BacktestMarket() self.maker_data: MockOrderBookLoader = MockOrderBookLoader( *self.maker_symbols) self.mid_price = 100 self.bid_threshold = 0.01 self.ask_threshold = 0.01 self.cancel_order_wait_time = 45 self.maker_data.set_balanced_order_book(mid_price=self.mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.maker_market.add_data(self.maker_data) self.maker_market.set_balance("COINALPHA", 500) self.maker_market.set_balance("WETH", 500) self.maker_market.set_balance("QETH", 500) self.maker_market.set_quantization_param( QuantizationParams(self.maker_symbols[0], 5, 5, 5, 5)) self.market_pair: PureMarketPair = PureMarketPair( *([self.maker_market] + self.maker_symbols)) logging_options: int = ( PureMarketMakingStrategy.OPTION_LOG_ALL & (~PureMarketMakingStrategy.OPTION_LOG_NULL_ORDER_SIZE)) self.strategy: {PureMarketMakingStrategy} = PureMarketMakingStrategy( [self.market_pair], order_size=1, bid_place_threshold=self.bid_threshold, ask_place_threshold=self.ask_threshold, cancel_order_wait_time=45, logging_options=logging_options) self.logging_options = logging_options self.clock.add_iterator(self.maker_market) self.clock.add_iterator(self.strategy) self.maker_order_fill_logger: EventLogger = EventLogger() self.cancel_order_logger: EventLogger = EventLogger() self.maker_market.add_listener(MarketEvent.OrderFilled, self.maker_order_fill_logger) self.maker_market.add_listener(MarketEvent.OrderCancelled, self.cancel_order_logger)
def setUp(self): self.market: MockBacktestMarket = MockBacktestMarket() self.market_info: MarketTradingPairTuple = MarketTradingPairTuple( self.market, self.trading_pair, *self.trading_pair.split("-")) self.order_book_data: MockOrderBookLoader = MockOrderBookLoader( self.trading_pair, *self.trading_pair.split("-")) self.mid_price = 100 self.order_book_data.set_balanced_order_book(mid_price=self.mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.market.add_data(self.order_book_data) self.market.set_balance("COINALPHA", 500) self.market.set_balance("WETH", 5000) self.market.set_balance("QETH", 500) self.market.set_quantization_param( QuantizationParams(self.trading_pair.split("-")[0], 6, 6, 6, 6)) self.strategy: StrategyBase = MockStrategy() self.strategy.add_markets([self.market])
def setUp(self): self.clock: Clock = Clock(ClockMode.BACKTEST, self.clock_tick_size, self.start_timestamp, self.end_timestamp) self.market: BacktestMarket = BacktestMarket() self.maker_data: MockOrderBookLoader = MockOrderBookLoader( trading_pair=self.trading_pair, base_currency=self.base_asset, quote_currency=self.quote_asset, ) self.maker_data.set_balanced_order_book(mid_price=100, min_price=50, max_price=150, price_step_size=1, volume_step_size=10) self.market.add_data(self.maker_data) self.market.set_balance("COINALPHA", self.base_balance) self.market.set_balance("HBOT", self.quote_balance) self.market.set_quantization_param( QuantizationParams( self.trading_pair, 6, 6, 6, 6 ) ) self.market_info = MarketTradingPairTuple(self.market, self.trading_pair, self.base_asset, self.quote_asset)
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_symbols) 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( MarketSymbolPair(self.maker_market, *self.maker_symbols), MarketSymbolPair(self.taker_market, *self.taker_symbols), ) self.strategy: CrossExchangeMarketMakingStrategy = CrossExchangeMarketMakingStrategy( [self.market_pair], order_size_portfolio_ratio_limit=0.3, min_profitability=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_symbols[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, 60.0, self.start_timestamp, self.end_timestamp) self.clock_tick_size = 60 self.maker_market: BacktestMarket = BacktestMarket() self.maker_data: MockOrderBookLoader = MockOrderBookLoader(*self.maker_symbols) self.mid_price = 100 self.bid_threshold = 0.01 self.ask_threshold = 0.01 self.cancel_order_wait_time = 45 self.maker_data.set_balanced_order_book(mid_price=self.mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.equal_strategy_sizing_delegate = StaggeredMultipleSizeSizingDelegate(order_start_size = 1.0, order_step_size= 0, number_of_orders= 5) self.staggered_strategy_sizing_delegate = StaggeredMultipleSizeSizingDelegate(order_start_size=1.0, order_step_size=0.5, number_of_orders=5) self.multiple_order_strategy_pricing_delegate = ConstantMultipleSpreadPricingDelegate(bid_spread=self.bid_threshold, ask_spread=self.ask_threshold, order_interval_size=0.01, number_of_orders=5) self.maker_market.add_data(self.maker_data) self.maker_market.set_balance("COINALPHA", 500) self.maker_market.set_balance("WETH", 5000) self.maker_market.set_balance("QETH", 500) self.maker_market.set_quantization_param( QuantizationParams( self.maker_symbols[0], 6, 6, 6, 6 ) ) self.market_info: MarketInfo = MarketInfo( *( [self.maker_market] + self.maker_symbols ) ) logging_options: int = (PureMarketMakingStrategyV2.OPTION_LOG_ALL & (~PureMarketMakingStrategyV2.OPTION_LOG_NULL_ORDER_SIZE)) self.strategy: PureMarketMakingStrategyV2 = PureMarketMakingStrategyV2( [self.market_info], legacy_order_size=1.0, legacy_bid_spread=self.bid_threshold, legacy_ask_spread=self.ask_threshold, cancel_order_wait_time=45, logging_options=logging_options ) self.multi_order_equal_strategy: PureMarketMakingStrategyV2 = PureMarketMakingStrategyV2( [self.market_info], legacy_order_size=1.0, legacy_bid_spread=self.bid_threshold, legacy_ask_spread=self.ask_threshold, cancel_order_wait_time=45, sizing_delegate=self.equal_strategy_sizing_delegate, pricing_delegate=self.multiple_order_strategy_pricing_delegate, logging_options=logging_options ) self.multi_order_staggered_strategy: PureMarketMakingStrategyV2 = PureMarketMakingStrategyV2( [self.market_info], legacy_order_size=1.0, legacy_bid_spread=self.bid_threshold, legacy_ask_spread=self.ask_threshold, cancel_order_wait_time=45, sizing_delegate=self.staggered_strategy_sizing_delegate, pricing_delegate=self.multiple_order_strategy_pricing_delegate, logging_options=logging_options ) self.logging_options = logging_options self.clock.add_iterator(self.maker_market) self.clock.add_iterator(self.strategy) self.maker_order_fill_logger: EventLogger = EventLogger() self.cancel_order_logger: EventLogger = EventLogger() self.maker_market.add_listener(MarketEvent.OrderFilled, self.maker_order_fill_logger) self.maker_market.add_listener(MarketEvent.OrderCancelled, self.cancel_order_logger)
def setUp(self): self.clock: Clock = Clock(ClockMode.BACKTEST, self.clock_tick_size, self.start_timestamp, self.end_timestamp) self.market: BacktestMarket = BacktestMarket() self.maker_data: MockOrderBookLoader = MockOrderBookLoader( *self.maker_trading_pairs) self.mid_price = 100 self.time_delay = 15 self.cancel_order_wait_time = 45 self.maker_data.set_balanced_order_book(mid_price=self.mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.market.add_data(self.maker_data) self.market.set_balance("COINALPHA", 500) self.market.set_balance("WETH", 5000) self.market.set_balance("QETH", 500) self.market.set_quantization_param( QuantizationParams(self.maker_trading_pairs[0], 6, 6, 6, 6)) self.market_info: MarketTradingPairTuple = MarketTradingPairTuple( *([self.market] + self.maker_trading_pairs)) logging_options: int = ( SimpleTradeStrategy.OPTION_LOG_ALL & (~SimpleTradeStrategy.OPTION_LOG_NULL_ORDER_SIZE)) # Define strategies to test self.limit_buy_strategy: SimpleTradeStrategy = SimpleTradeStrategy( [self.market_info], order_type="limit", order_price=Decimal("99"), cancel_order_wait_time=self.cancel_order_wait_time, is_buy=True, time_delay=self.time_delay, order_amount=Decimal("1.0"), logging_options=logging_options) self.limit_sell_strategy: SimpleTradeStrategy = SimpleTradeStrategy( [self.market_info], order_type="limit", order_price=Decimal("101"), cancel_order_wait_time=self.cancel_order_wait_time, is_buy=False, time_delay=self.time_delay, order_amount=Decimal("1.0"), logging_options=logging_options) self.market_buy_strategy: SimpleTradeStrategy = SimpleTradeStrategy( [self.market_info], order_type="market", order_price=None, cancel_order_wait_time=self.cancel_order_wait_time, is_buy=True, time_delay=self.time_delay, order_amount=Decimal("1.0"), logging_options=logging_options) self.market_sell_strategy: SimpleTradeStrategy = SimpleTradeStrategy( [self.market_info], order_type="market", order_price=None, cancel_order_wait_time=self.cancel_order_wait_time, is_buy=False, time_delay=self.time_delay, order_amount=Decimal("1.0"), logging_options=logging_options) self.logging_options = logging_options self.clock.add_iterator(self.market) self.maker_order_fill_logger: EventLogger = EventLogger() self.cancel_order_logger: EventLogger = EventLogger() self.buy_order_completed_logger: EventLogger = EventLogger() self.sell_order_completed_logger: EventLogger = EventLogger() self.market.add_listener(MarketEvent.BuyOrderCompleted, self.buy_order_completed_logger) self.market.add_listener(MarketEvent.SellOrderCompleted, self.sell_order_completed_logger) self.market.add_listener(MarketEvent.OrderFilled, self.maker_order_fill_logger) self.market.add_listener(MarketEvent.OrderCancelled, self.cancel_order_logger)
def setUp(self): self.clock_tick_size = 1 self.clock: Clock = Clock(ClockMode.BACKTEST, self.clock_tick_size, self.start_timestamp, self.end_timestamp) self.market: BacktestMarket = BacktestMarket() self.book_data: MockOrderBookLoader = MockOrderBookLoader(self.trading_pair, self.base_asset, self.quote_asset) self.mid_price = 100 self.bid_spread = 0.01 self.ask_spread = 0.01 self.order_refresh_time = 30 self.book_data.set_balanced_order_book(mid_price=self.mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.market.add_data(self.book_data) self.market.set_balance("HBOT", 500) self.market.set_balance("ETH", 5000) self.market.set_quantization_param( QuantizationParams( self.trading_pair, 6, 6, 6, 6 ) ) self.market_info = MarketTradingPairTuple(self.market, self.trading_pair, self.base_asset, self.quote_asset) self.clock.add_iterator(self.market) self.maker_order_fill_logger: EventLogger = EventLogger() self.cancel_order_logger: EventLogger = EventLogger() self.market.add_listener(MarketEvent.OrderFilled, self.maker_order_fill_logger) self.market.add_listener(MarketEvent.OrderCancelled, self.cancel_order_logger) self.one_level_strategy: PureMarketMakingStrategy = PureMarketMakingStrategy( self.market_info, bid_spread=Decimal("0.01"), ask_spread=Decimal("0.01"), order_amount=Decimal("1"), order_refresh_time=4, filled_order_delay=8, hanging_orders_enabled=True, hanging_orders_cancel_pct=0.05, order_refresh_tolerance_pct=0 ) self.multi_levels_strategy: PureMarketMakingStrategy = PureMarketMakingStrategy( self.market_info, bid_spread=Decimal("0.01"), ask_spread=Decimal("0.01"), order_amount=Decimal("1"), order_levels=5, order_level_spread=Decimal("0.01"), order_refresh_time=4, filled_order_delay=8, order_refresh_tolerance_pct=0 ) self.hanging_order_multiple_strategy = PureMarketMakingStrategy( self.market_info, bid_spread=Decimal("0.01"), ask_spread=Decimal("0.01"), order_amount=Decimal("1"), order_levels=5, order_level_spread=Decimal("0.01"), order_refresh_time=4, filled_order_delay=8, order_refresh_tolerance_pct=0, hanging_orders_enabled=True )
ddex_trading_pair = ("WETH-DAI", "WETH", "DAI") binance_market = BacktestMarket() ddex_market = BacktestMarket() binance_loader = BinanceOrderBookLoaderV2(*binance_trading_pair) ddex_loader = DDEXOrderBookLoader(*ddex_trading_pair) binance_market.config = MarketConfig(AssetType.BASE_CURRENCY, 0.001, AssetType.QUOTE_CURRENCY, 0.001, {}) ddex_market.config = MarketConfig(AssetType.BASE_CURRENCY, 0.001, AssetType.QUOTE_CURRENCY, 0.001, {}) binance_market.add_data(binance_loader) ddex_market.add_data(ddex_loader) binance_market.set_quantization_param(QuantizationParams( "ETHUSDT", 5, 3, 5, 3)) ddex_market.set_quantization_param(QuantizationParams("WETH-DAI", 5, 3, 5, 3)) market_pair1 = ArbitrageMarketPair(*([ddex_market] + list(ddex_trading_pair) + [binance_market] + list(binance_trading_pair))) strategy = ArbitrageStrategy( [market_pair1], 0.025, logging_options=ArbitrageStrategy.OPTION_LOG_CREATE_ORDER) clock = Clock(ClockMode.BACKTEST, start_time=start.timestamp(), end_time=end.timestamp()) clock.add_iterator(binance_market)
def setUp(self): self.clock: Clock = Clock(ClockMode.BACKTEST, self.clock_tick_size, self.start_timestamp, self.end_timestamp) self.market: BacktestMarket = BacktestMarket() self.maker_data: MockOrderBookLoader = MockOrderBookLoader(*self.maker_symbols) self.mid_price = 100 self.time_delay = 15 self.cancel_order_wait_time = 45 self.maker_data.set_balanced_order_book(mid_price=self.mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.market.add_data(self.maker_data) self.market.set_balance("COINALPHA", 500) self.market.set_balance("WETH", 500000000000) self.market.set_balance("QETH", 500) self.market.set_quantization_param( QuantizationParams( self.maker_symbols[0], 6, 6, 6, 6 ) ) self.market_info: MarketTradingPairTuple = MarketTradingPairTuple( *( [self.market] + self.maker_symbols ) ) # Define strategies to test self.limit_buy_strategy: Dev5TwapTradeStrategy = Dev5TwapTradeStrategy( [self.market_info], order_type="limit", order_price=Decimal("99"), cancel_order_wait_time=self.cancel_order_wait_time, is_buy=True, time_delay=self.time_delay, is_vwap=True, percent_slippage=50.0, order_percent_of_volume=0.5, order_amount=Decimal("100.0") ) self.limit_sell_strategy: Dev5TwapTradeStrategy = Dev5TwapTradeStrategy( [self.market_info], order_type="limit", order_price=Decimal("101"), cancel_order_wait_time=self.cancel_order_wait_time, is_buy=False, time_delay=self.time_delay, is_vwap=True, percent_slippage=50.0, order_percent_of_volume=0.5, order_amount=Decimal("100.0") ) self.market_buy_strategy: Dev5TwapTradeStrategy = Dev5TwapTradeStrategy( [self.market_info], order_type="market", order_price=None, cancel_order_wait_time=self.cancel_order_wait_time, is_buy=True, time_delay=self.time_delay, is_vwap=True, percent_slippage=50.0, order_percent_of_volume=0.5, order_amount=Decimal("100.0") ) self.market_sell_strategy: Dev5TwapTradeStrategy = Dev5TwapTradeStrategy( [self.market_info], order_type="market", order_price=None, cancel_order_wait_time=self.cancel_order_wait_time, is_buy=False, time_delay=self.time_delay, is_vwap=True, percent_slippage=50.0, order_percent_of_volume=0.5, order_amount=Decimal("100.0") ) self.clock.add_iterator(self.market) self.maker_order_fill_logger: EventLogger = EventLogger() self.cancel_order_logger: EventLogger = EventLogger() self.buy_order_completed_logger: EventLogger = EventLogger() self.sell_order_completed_logger: EventLogger = EventLogger() self.market.add_listener(MarketEvent.BuyOrderCompleted, self.buy_order_completed_logger) self.market.add_listener(MarketEvent.SellOrderCompleted, self.sell_order_completed_logger) self.market.add_listener(MarketEvent.OrderFilled, self.maker_order_fill_logger) self.market.add_listener(MarketEvent.OrderCancelled, self.cancel_order_logger)
def setUp(self): self.clock: Clock = Clock(ClockMode.BACKTEST, self.clock_tick_size, self.start_timestamp, self.end_timestamp) self.market: BacktestMarket = BacktestMarket() self.maker_data: MockOrderBookLoader = MockOrderBookLoader( trading_pair=self.trading_pair, base_currency=self.base_asset, quote_currency=self.quote_asset, ) self.mid_price = 100 self.time_delay = 15 self.cancel_order_wait_time = 45 self.maker_data.set_balanced_order_book(mid_price=self.mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.market.add_data(self.maker_data) self.market.set_balance("COINALPHA", 500) self.market.set_balance("WETH", 5000) self.market.set_quantization_param( QuantizationParams(self.trading_pair, 6, 6, 6, 6)) self.market_info: MarketTradingPairTuple = MarketTradingPairTuple( self.market, self.trading_pair, self.base_asset, self.quote_asset) # Define strategies to test self.buy_mid_price_strategy: PerformTradeStrategy = PerformTradeStrategy( exchange=self.market, trading_pair=self.trading_pair, is_buy=True, spread=self.spread, order_amount=Decimal("1.0"), price_type=PriceType.MidPrice) self.sell_mid_price_strategy: PerformTradeStrategy = PerformTradeStrategy( exchange=self.market, trading_pair=self.trading_pair, is_buy=False, spread=self.spread, order_amount=Decimal("1.0"), price_type=PriceType.MidPrice) self.buy_last_price_strategy: PerformTradeStrategy = PerformTradeStrategy( exchange=self.market, trading_pair=self.trading_pair, is_buy=True, spread=self.spread, order_amount=Decimal("1.0"), price_type=PriceType.LastTrade) self.sell_last_price_strategy: PerformTradeStrategy = PerformTradeStrategy( exchange=self.market, trading_pair=self.trading_pair, is_buy=False, spread=self.spread, order_amount=Decimal("1.0"), price_type=PriceType.LastTrade) self.buy_last_own_trade_price_strategy: PerformTradeStrategy = PerformTradeStrategy( exchange=self.market, trading_pair=self.trading_pair, is_buy=True, spread=self.spread, order_amount=Decimal("1.0"), price_type=PriceType.LastOwnTrade) self.sell_last_own_trade_price_strategy: PerformTradeStrategy = PerformTradeStrategy( exchange=self.market, trading_pair=self.trading_pair, is_buy=False, spread=self.spread, order_amount=Decimal("1.0"), price_type=PriceType.LastOwnTrade) self.clock.add_iterator(self.market) self.maker_order_fill_logger: EventLogger = EventLogger() self.cancel_order_logger: EventLogger = EventLogger() self.buy_order_completed_logger: EventLogger = EventLogger() self.sell_order_completed_logger: EventLogger = EventLogger() self.market.add_listener(MarketEvent.BuyOrderCompleted, self.buy_order_completed_logger) self.market.add_listener(MarketEvent.SellOrderCompleted, self.sell_order_completed_logger) self.market.add_listener(MarketEvent.OrderFilled, self.maker_order_fill_logger) self.market.add_listener(MarketEvent.OrderCancelled, self.cancel_order_logger)
def setUp(self): self.clock_tick_size = 1 self.clock: Clock = Clock(ClockMode.BACKTEST, self.clock_tick_size, self.start_timestamp, self.end_timestamp) self.maker_market: BacktestMarket = BacktestMarket() self.maker_data: MockOrderBookLoader = MockOrderBookLoader( *self.maker_trading_pairs) self.mid_price = 100 self.bid_spread = 0.01 self.ask_spread = 0.01 self.order_refresh_time = 30 self.maker_data.set_balanced_order_book(mid_price=self.mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.constant_pricing_delegate = ConstantSpreadPricingDelegate( Decimal(self.bid_spread), Decimal(self.ask_spread)) self.constant_sizing_delegate = ConstantSizeSizingDelegate( Decimal("1.0")) self.filter_delegate = PassThroughFilterDelegate() self.maker_market.add_data(self.maker_data) self.maker_market.set_balance("COINALPHA", 500) self.maker_market.set_balance("WETH", 5000) self.maker_market.set_balance("QETH", 500) self.maker_market.set_quantization_param( QuantizationParams(self.maker_trading_pairs[0], 6, 6, 6, 6)) self.market_info: MarketTradingPairTuple = MarketTradingPairTuple( *([self.maker_market] + self.maker_trading_pairs)) logging_options: int = ( PureMarketMakingStrategyV2.OPTION_LOG_ALL & (~PureMarketMakingStrategyV2.OPTION_LOG_NULL_ORDER_SIZE)) self.one_level_strategy: PureMarketMakingStrategyV2 = PureMarketMakingStrategyV2( [self.market_info], filter_delegate=self.filter_delegate, pricing_delegate=self.constant_pricing_delegate, sizing_delegate=self.constant_sizing_delegate, order_refresh_time=4, filled_order_delay=8, hanging_orders_enabled=True, logging_options=logging_options, hanging_orders_cancel_pct=0.05, order_refresh_tolerance_pct=0) self.multiple_order_pricing_delegate = ConstantMultipleSpreadPricingDelegate( bid_spread=Decimal(self.bid_spread), ask_spread=Decimal(self.ask_spread), order_level_spread=Decimal("0.01"), order_levels=Decimal("5")) self.equal_sizing_delegate = StaggeredMultipleSizeSizingDelegate( order_start_size=Decimal("1.0"), order_step_size=Decimal("0"), order_levels=Decimal("5")) self.multi_levels_strategy: PureMarketMakingStrategyV2 = PureMarketMakingStrategyV2( [self.market_info], filter_delegate=self.filter_delegate, pricing_delegate=self.multiple_order_pricing_delegate, sizing_delegate=self.equal_sizing_delegate, order_refresh_time=4, filled_order_delay=8, hanging_orders_enabled=True, logging_options=logging_options, hanging_orders_cancel_pct=0.1, order_refresh_tolerance_pct=0) self.hanging_order_multiple_strategy: PureMarketMakingStrategyV2 = PureMarketMakingStrategyV2( [self.market_info], filter_delegate=self.filter_delegate, pricing_delegate=self.multiple_order_pricing_delegate, sizing_delegate=self.equal_sizing_delegate, order_refresh_time=4, filled_order_delay=8, hanging_orders_enabled=True, logging_options=logging_options, order_refresh_tolerance_pct=0) self.logging_options = logging_options self.clock.add_iterator(self.maker_market) self.maker_order_fill_logger: EventLogger = EventLogger() self.cancel_order_logger: EventLogger = EventLogger() self.maker_market.add_listener(MarketEvent.OrderFilled, self.maker_order_fill_logger) self.maker_market.add_listener(MarketEvent.OrderCancelled, self.cancel_order_logger)