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)
