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: MockPaperExchange = MockPaperExchange()
self.mid_price = 100
self.bid_spread = 0.01
self.ask_spread = 0.01
self.order_refresh_time = 30
self.market.set_balanced_order_book(trading_pair=self.trading_pair,
mid_price=self.mid_price,
min_price=1,
max_price=200,
price_step_size=1,
volume_step_size=10)
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: MockPaperExchange = MockPaperExchange()
self.ext_market_info: MarketTradingPairTuple = MarketTradingPairTuple(
self.ext_market, self.trading_pair, self.base_asset, self.quote_asset
)
self.ext_market.set_balanced_order_book(trading_pair=self.trading_pair,
mid_price=100, min_price=1, max_price=400, price_step_size=1,
volume_step_size=100)
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.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 setUp(self):
self.db_path: str = realpath(
join(__file__, "../bamboo_relay_uncordinated_test.sqlite"))
try:
os.unlink(self.db_path)
except FileNotFoundError:
pass
self.market_logger = EventLogger()
self.wallet_logger = EventLogger()
for event_tag in self.market_events:
self.market.add_listener(event_tag, self.market_logger)
for event_tag in self.wallet_events:
self.wallet.add_listener(event_tag, self.wallet_logger)
def _initialize_event_loggers(self):
self.buy_order_completed_logger = EventLogger()
self.sell_order_completed_logger = EventLogger()
self.order_filled_logger = EventLogger()
self.order_failure_logger = EventLogger()
events_and_loggers = [
(MarketEvent.BuyOrderCompleted, self.buy_order_completed_logger),
(MarketEvent.SellOrderCompleted, self.sell_order_completed_logger),
(MarketEvent.OrderFilled, self.order_filled_logger),
(MarketEvent.OrderFailure, self.order_failure_logger)]
for event, logger in events_and_loggers:
self.exchange.add_listener(event, logger)
def setUp(self):
self.clock: Clock = Clock(ClockMode.BACKTEST, 1.0,
self.start_timestamp, self.end_timestamp)
self.maker_market: BacktestMarket = BacktestMarket()
self.taker_market: BacktestMarket = BacktestMarket()
self.maker_data: MockOrderBookLoader = MockOrderBookLoader(
*self.maker_symbols)
self.taker_data: MockOrderBookLoader = MockOrderBookLoader(
*self.taker_symbols)
self.maker_data.set_balanced_order_book(1.0, 0.5, 1.5, 0.01, 10)
self.taker_data.set_balanced_order_book(1.0, 0.5, 1.5, 0.001, 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(
*([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.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.maxDiff = None
self.clock: Clock = Clock(ClockMode.BACKTEST, 1.0,
self.start_timestamp, self.end_timestamp)
self.market_1: MockPaperExchange = MockPaperExchange(
client_config_map=ClientConfigAdapter(ClientConfigMap()))
self.market_2: MockPaperExchange = MockPaperExchange(
client_config_map=ClientConfigAdapter(ClientConfigMap()))
self.market_1.set_balanced_order_book(self.market_1_trading_pairs[0],
1.0, 0.5, 1.5, 0.01, 10)
self.market_2.set_balanced_order_book(self.market_2_trading_pairs[0],
1.0, 0.5, 1.5, 0.005, 5)
self.market_1.set_balance("COINALPHA", 500)
self.market_1.set_balance("WETH", 500)
self.market_2.set_balance("COINALPHA", 500)
self.market_2.set_balance("ETH", 500)
self.market_1.set_quantization_param(
QuantizationParams(self.market_1_trading_pairs[0], 5, 5, 5, 5))
self.market_2.set_quantization_param(
QuantizationParams(self.market_2_trading_pairs[0], 5, 5, 5, 5))
self.market_trading_pair_tuple_1 = MarketTradingPairTuple(
*([self.market_1] + self.market_1_trading_pairs))
self.market_trading_pair_tuple_2 = MarketTradingPairTuple(
*([self.market_2] + self.market_2_trading_pairs))
self.market_pair: ArbitrageMarketPair = ArbitrageMarketPair(
self.market_trading_pair_tuple_1, self.market_trading_pair_tuple_2)
self.logging_options: int = ArbitrageStrategy.OPTION_LOG_ALL
self.strategy: ArbitrageStrategy = ArbitrageStrategy()
self.strategy.init_params(
[self.market_pair],
min_profitability=Decimal("0.03"),
logging_options=self.logging_options,
secondary_to_primary_quote_conversion_rate=Decimal("0.95"))
self.clock.add_iterator(self.market_1)
self.clock.add_iterator(self.market_2)
self.clock.add_iterator(self.strategy)
self.market_1_order_fill_logger: EventLogger = EventLogger()
self.market_2_order_fill_logger: EventLogger = EventLogger()
self.market_1.add_listener(MarketEvent.OrderFilled,
self.market_1_order_fill_logger)
self.market_2.add_listener(MarketEvent.OrderFilled,
self.market_2_order_fill_logger)
def test_create_order_when_order_is_instantly_closed(self, mock_api):
trading_rules = self.get_trading_rules_mock()
self.exchange._trading_rules = self.exchange._format_trading_rules(
trading_rules)
url = f"{CONSTANTS.REST_URL}/{CONSTANTS.ORDER_CREATE_PATH_URL}"
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
resp = self.get_order_create_response_mock()
resp["status"] = "closed"
mock_api.post(regex_url, body=json.dumps(resp))
event_logger = EventLogger()
self.exchange.add_listener(MarketEvent.BuyOrderCreated, event_logger)
order_id = "someId"
self.async_run_with_timeout(coroutine=self.exchange._create_order(
trade_type=TradeType.BUY,
order_id=order_id,
trading_pair=self.trading_pair,
amount=Decimal("1"),
order_type=OrderType.LIMIT,
price=Decimal("5.1"),
))
self.assertEqual(1, len(event_logger.event_log))
self.assertEqual(order_id, event_logger.event_log[0].order_id)
self.assertTrue(order_id in self.exchange.in_flight_orders)
async def test_sell_order(self):
self._http_player.replay_timestamp_ms = 1648500097825
clock_task: asyncio.Task = safe_ensure_future(self.run_clock())
event_logger: EventLogger = EventLogger()
self._connector.add_listener(MarketEvent.SellOrderCreated,
event_logger)
self._connector.add_listener(MarketEvent.OrderFilled, event_logger)
try:
self._connector.sell("DAI-WETH", Decimal(100), OrderType.LIMIT,
Decimal("0.002816023229500"))
order_created_event: SellOrderCreatedEvent = await event_logger.wait_for(
SellOrderCreatedEvent, timeout_seconds=5)
self.assertEqual(
"0x63c7ffaf8dcede44c51cc2ea7ab3a5c0ea4915c9dab57dfcb432ea92ad174391", # noqa: mock
order_created_event.exchange_order_id)
self._http_player.replay_timestamp_ms = 1648500133889
order_filled_event: OrderFilledEvent = await event_logger.wait_for(
OrderFilledEvent, timeout_seconds=5)
self.assertEqual(
"0x63c7ffaf8dcede44c51cc2ea7ab3a5c0ea4915c9dab57dfcb432ea92ad174391", # noqa: mock
order_filled_event.exchange_trade_id)
finally:
clock_task.cancel()
try:
await clock_task
except asyncio.CancelledError:
pass
async def test_collect_fees(self):
self._http_player.replay_timestamp_ms = 1652728322607
clock_task: asyncio.Task = safe_ensure_future(self.run_clock())
event_logger: EventLogger = EventLogger()
self._connector.add_listener(MarketEvent.RangePositionUpdate,
event_logger)
self._connector.add_listener(MarketEvent.RangePositionFeeCollected,
event_logger)
try:
self._connector.collect_fees("COIN1-COIN3", 1001)
pos_update_event: RangePositionUpdateEvent = await event_logger.wait_for(
RangePositionUpdateEvent, timeout_seconds=5)
self.assertEqual(
"0x74ae9ae03e8bee4d6954dfb4944c87dae5de5f63f4932be3b16dfc93601f0fdc", # noqa: mock
pos_update_event.exchange_order_id)
self._http_player.replay_timestamp_ms = 1652728328486
fees_collected_event: RangePositionFeeCollectedEvent = await event_logger.wait_for(
RangePositionFeeCollectedEvent, timeout_seconds=5)
self.assertEqual(
"0x74ae9ae03e8bee4d6954dfb4944c87dae5de5f63f4932be3b16dfc93601f0fdc", # noqa: mock
fees_collected_event.exchange_order_id)
finally:
clock_task.cancel()
try:
await clock_task
except asyncio.CancelledError:
pass
async def test_remove_liquidity(self):
self._http_player.replay_timestamp_ms = 1652728331046
clock_task: asyncio.Task = safe_ensure_future(self.run_clock())
event_logger: EventLogger = EventLogger()
self._connector.add_listener(MarketEvent.RangePositionUpdate,
event_logger)
self._connector.add_listener(MarketEvent.RangePositionLiquidityRemoved,
event_logger)
try:
self._connector.remove_liquidity("COIN1-COIN3", 1000)
pos_update_event: RangePositionUpdateEvent = await event_logger.wait_for(
RangePositionUpdateEvent, timeout_seconds=5)
self.assertEqual(
"0x84c2e5633ea6f5aaa8fe19464a65b2a30d1fce66513db4b11439c09288962e7a", # noqa: mock
pos_update_event.exchange_order_id)
self._http_player.replay_timestamp_ms = 1652728338292
liquidity_removed_event: RangePositionLiquidityRemovedEvent = await event_logger.wait_for(
RangePositionLiquidityRemovedEvent, timeout_seconds=5)
self.assertEqual(
"0x84c2e5633ea6f5aaa8fe19464a65b2a30d1fce66513db4b11439c09288962e7a", # noqa: mock
liquidity_removed_event.exchange_order_id)
finally:
clock_task.cancel()
try:
await clock_task
except asyncio.CancelledError:
pass
async def test_add_liquidity(self):
self._http_player.replay_timestamp_ms = 1652728316475
clock_task: asyncio.Task = safe_ensure_future(self.run_clock())
event_logger: EventLogger = EventLogger()
self._connector.add_listener(MarketEvent.RangePositionUpdate,
event_logger)
self._connector.add_listener(MarketEvent.RangePositionLiquidityAdded,
event_logger)
try:
self._connector.add_liquidity("COIN1-COIN3", Decimal("1"),
Decimal("1"), Decimal("1"),
Decimal("5"), "LOW")
pos_update_event: RangePositionUpdateEvent = await event_logger.wait_for(
RangePositionUpdateEvent, timeout_seconds=5)
self.assertEqual(
"0x0b6145277c7a6eefff5db3f595a3563da77df7f6face91122fd117fb6345ba0f", # noqa: mock
pos_update_event.exchange_order_id)
self._http_player.replay_timestamp_ms = 1652728320503
liquidity_added_event: RangePositionLiquidityAddedEvent = await event_logger.wait_for(
RangePositionLiquidityAddedEvent, timeout_seconds=5)
self.assertEqual(
"0x0b6145277c7a6eefff5db3f595a3563da77df7f6face91122fd117fb6345ba0f", # noqa: mock
liquidity_added_event.exchange_order_id)
finally:
clock_task.cancel()
try:
await clock_task
except asyncio.CancelledError:
pass
async def test_approve_token(self):
self._http_player.replay_timestamp_ms = 1652728282963
coin1_in_flight_order: GatewayInFlightLPOrder = await self._connector.approve_token(
"uniswapLP", "COIN1")
self._http_player.replay_timestamp_ms = 1652728286030
coin3_in_flight_order: GatewayInFlightLPOrder = await self._connector.approve_token(
"uniswapLP", "COIN3")
self.assertEqual(
"0x65ef330422dc9892460e3ea67338013b9ca619270f960c4531f47a1812cb7677", # noqa: mock
coin1_in_flight_order.exchange_order_id)
self.assertEqual(
"0x551970f039ed4190b00a7277bf7e952aec371ac562853e89b54bbeea82c9ed86", # noqa: mock
coin3_in_flight_order.exchange_order_id)
clock_task: asyncio.Task = safe_ensure_future(self.run_clock())
event_logger: EventLogger = EventLogger()
self._connector.add_listener(TokenApprovalEvent.ApprovalSuccessful,
event_logger)
self._http_player.replay_timestamp_ms = 1652728338292
try:
async with timeout(5):
while len(event_logger.event_log) < 2:
await event_logger.wait_for(TokenApprovalSuccessEvent)
self.assertEqual(2, len(event_logger.event_log))
self.assertEqual({"uniswapLP_COIN1", "uniswapLP_COIN3"},
set(e.token_symbol
for e in event_logger.event_log))
finally:
clock_task.cancel()
try:
await clock_task
except asyncio.CancelledError:
pass
def setUp(self):
self.amm_1: MockAMM = MockAMM("onion")
self.amm_1.set_balance(base_asset, 500)
self.amm_1.set_balance(quote_asset, 500)
self.market_info_1 = MarketTradingPairTuple(self.amm_1, trading_pair,
base_asset, quote_asset)
self.amm_2: MockAMM = MockAMM("garlic")
self.amm_2.set_balance(base_asset, 500)
self.amm_2.set_balance(quote_asset, 500)
self.market_info_2 = MarketTradingPairTuple(self.amm_2, trading_pair,
base_asset, quote_asset)
self.strategy = AmmArbStrategy(
self.market_info_1,
self.market_info_2,
min_profitability=Decimal("0.01"),
order_amount=Decimal("1"),
market_1_slippage_buffer=Decimal("0.001"),
market_2_slippage_buffer=Decimal("0.002"),
)
self.clock.add_iterator(self.amm_1)
self.clock.add_iterator(self.amm_2)
self.clock.add_iterator(self.strategy)
self.market_order_fill_logger: EventLogger = EventLogger()
self.amm_1.add_listener(MarketEvent.OrderFilled,
self.market_order_fill_logger)
self.amm_2.add_listener(MarketEvent.OrderFilled,
self.market_order_fill_logger)
async def test_approve_token(self):
self._http_player.replay_timestamp_ms = 1648499867736
weth_in_flight_order: GatewayInFlightOrder = await self._connector.approve_token(
"WETH")
self._http_player.replay_timestamp_ms = 1648499871595
dai_in_flight_order: GatewayInFlightOrder = await self._connector.approve_token(
"DAI")
self.assertEqual(
"0x6c975ba8c1d35e8542ffd05956d9ec227c1ac234ae4d5f69819aa24bae784321", # noqa: mock
weth_in_flight_order.exchange_order_id)
self.assertEqual(
"0x919438daa20dc2f5381fdf25b6b89a189d055b3a1d6d848c44e53dc10f49168c", # noqa: mock
dai_in_flight_order.exchange_order_id)
clock_task: asyncio.Task = safe_ensure_future(self.run_clock())
event_logger: EventLogger = EventLogger()
self._connector.add_listener(TokenApprovalEvent.ApprovalSuccessful,
event_logger)
self._http_player.replay_timestamp_ms = 1648500060232
try:
async with timeout(10):
while len(event_logger.event_log) < 2:
await event_logger.wait_for(TokenApprovalSuccessEvent)
self.assertEqual(2, len(event_logger.event_log))
self.assertEqual({"WETH", "DAI"},
set(e.token_symbol
for e in event_logger.event_log))
finally:
clock_task.cancel()
try:
await clock_task
except asyncio.CancelledError:
pass
async def collect_cancel_approval(self):
print("Creating and then canceling token approval...\t\t",
end="",
flush=True)
connector: GatewayEVMAMM = self._connector
event_logger: EventLogger = EventLogger()
connector.add_listener(TokenApprovalEvent.ApprovalCancelled,
event_logger)
try:
async with self.run_clock():
tracked_order_1: GatewayInFlightOrder = await connector.approve_token(
"DAI",
max_fee_per_gas=MAX_FEE_PER_GAS,
max_priority_fee_per_gas=MAX_PRIORITY_FEE_PER_GAS)
tracked_order_2: GatewayInFlightOrder = await connector.approve_token(
"WETH",
max_fee_per_gas=MAX_FEE_PER_GAS,
max_priority_fee_per_gas=MAX_PRIORITY_FEE_PER_GAS)
tracked_order_1._creation_timestamp = connector.current_timestamp - 86400
tracked_order_2._creation_timestamp = connector.current_timestamp - 86400
safe_ensure_future(connector.cancel_outdated_orders(600))
while len(event_logger.event_log) < 2:
await event_logger.wait_for(TokenApprovalCancelledEvent)
finally:
connector.remove_listener(TokenApprovalEvent.ApprovalCancelled,
event_logger)
print("done")
def setUp(self):
self.maxDiff = None
self.clock: Clock = Clock(ClockMode.BACKTEST, 1.0,
self.start_timestamp, self.end_timestamp)
self.market: MockPaperExchange = MockPaperExchange()
self.market.set_balanced_order_book(self.trading_pair, 10, 5, 15, 0.1,
1)
self.market.set_balance(self.base_asset, 500)
self.market.set_balance(self.quote_asset, 500)
self.market.set_quantization_param(
QuantizationParams(self.trading_pair, 5, 5, 5, 5))
self.market_info = MarketTradingPairTuple(self.market,
self.trading_pair,
self.base_asset,
self.quote_asset)
self.logging_options: int = CeloArbStrategy.OPTION_LOG_ALL
self.strategy = CeloArbStrategy()
self.strategy.init_params(self.market_info,
min_profitability=Decimal("0.01"),
order_amount=Decimal("1"),
celo_slippage_buffer=Decimal("0.001"),
logging_options=self.logging_options,
hb_app_notification=False,
mock_celo_cli_mode=True)
self.clock.add_iterator(self.market)
self.clock.add_iterator(self.strategy)
self.market_order_fill_logger: EventLogger = EventLogger()
self.market.add_listener(MarketEvent.OrderFilled,
self.market_order_fill_logger)
CeloCLI.unlock_account(TEST_ADDRESS, TEST_PASSWORD)
async def test_buy_order(self):
self._http_player.replay_timestamp_ms = 1648500060561
clock_task: asyncio.Task = safe_ensure_future(self.run_clock())
event_logger: EventLogger = EventLogger()
self._connector.add_listener(MarketEvent.BuyOrderCreated, event_logger)
self._connector.add_listener(MarketEvent.OrderFilled, event_logger)
try:
self._connector.buy("DAI-WETH", Decimal(100), OrderType.LIMIT,
Decimal("0.002861464039500"))
order_created_event: BuyOrderCreatedEvent = await event_logger.wait_for(
BuyOrderCreatedEvent, timeout_seconds=5)
self.assertEqual(
"0xc3d3166e6142c479b26c21e007b68e2b7fb1d28c1954ab344b45d7390139654f", # noqa: mock
order_created_event.exchange_order_id)
self._http_player.replay_timestamp_ms = 1648500097569
order_filled_event: OrderFilledEvent = await event_logger.wait_for(
OrderFilledEvent, timeout_seconds=5)
self.assertEqual(
"0xc3d3166e6142c479b26c21e007b68e2b7fb1d28c1954ab344b45d7390139654f", # noqa: mock
order_filled_event.exchange_trade_id)
finally:
clock_task.cancel()
try:
await clock_task
except asyncio.CancelledError:
pass
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) -> None:
super().setUp()
self.ev_loop = asyncio.get_event_loop()
self.event_listener = EventLogger()
self.exchange = BittrexExchange(self.api_key,
self.secret_key,
trading_pairs=[self.trading_pair])
def _initialize_event_loggers(self):
self.buy_order_completed_logger = EventLogger()
self.sell_order_completed_logger = EventLogger()
self.order_cancelled_logger = EventLogger()
self.order_filled_logger = EventLogger()
self.funding_payment_completed_logger = EventLogger()
events_and_loggers = [
(MarketEvent.BuyOrderCompleted, self.buy_order_completed_logger),
(MarketEvent.SellOrderCompleted, self.sell_order_completed_logger),
(MarketEvent.OrderCancelled, self.order_cancelled_logger),
(MarketEvent.OrderFilled, self.order_filled_logger),
(MarketEvent.FundingPaymentCompleted,
self.funding_payment_completed_logger)
]
for event, logger in events_and_loggers:
self.exchange.add_listener(event, logger)
def setUp(self):
self.db_path: str = realpath(join(__file__, "../connector_test.sqlite"))
try:
os.unlink(self.db_path)
except FileNotFoundError:
pass
self.event_logger = EventLogger()
for event_tag in self.events:
self.connector.add_listener(event_tag, self.event_logger)
async def test_update_approval_status(self):
def create_approval_record(token_symbol: str,
tx_hash: str) -> GatewayInFlightLPOrder:
return GatewayInFlightLPOrder(
client_order_id=self._connector.create_approval_order_id(
"uniswapLP", token_symbol),
exchange_order_id=tx_hash,
trading_pair=token_symbol,
lp_type=LPType.ADD,
lower_price=s_decimal_0,
upper_price=s_decimal_0,
amount_0=s_decimal_0,
amount_1=s_decimal_0,
token_id=0,
gas_price=s_decimal_0,
creation_timestamp=self._connector.current_timestamp)
successful_records: List[GatewayInFlightLPOrder] = [
create_approval_record(
"COIN1",
"0x273a720fdc92554c47f409f4f74d3c262937451ccdbaddfd8d0185a9e3c64dd2" # noqa: mock
),
create_approval_record(
"COIN3",
"0x27d7a7156bd0afc73092602da67774aa3319adbc72213122d65480e482ce0a8b" # noqa: mock
),
]
"""fake_records: List[GatewayInFlightLPOrder] = [
create_approval_record(
"COIN1",
"0x273a720fdc92554c47f409f4f74d3c262937451ccdbaddfd8d0185a9e3c64dd1" # noqa: mock
),
create_approval_record(
"COIN3",
"0x27d7a7156bd0afc73092602da67774aa3319adbc72213122d65480e482ce0a8a" # noqa: mock
),
]"""
event_logger: EventLogger = EventLogger()
self._connector.add_listener(TokenApprovalEvent.ApprovalSuccessful,
event_logger)
self._connector.add_listener(TokenApprovalEvent.ApprovalFailed,
event_logger)
try:
await self._connector.update_token_approval_status(
successful_records)
self.assertEqual(2, len(event_logger.event_log))
self.assertEqual({"uniswapLP_COIN1", "uniswapLP_COIN3"},
set(e.token_symbol
for e in event_logger.event_log))
finally:
self._connector.remove_listener(
TokenApprovalEvent.ApprovalSuccessful, event_logger)
self._connector.remove_listener(TokenApprovalEvent.ApprovalFailed,
event_logger)
def setUp(self) -> None:
self.clock_tick_size = 1
self.clock: Clock = Clock(ClockMode.BACKTEST, self.clock_tick_size,
self.start_timestamp, self.end_timestamp)
self.mid_price = 100
self.bid_spread = 0.01
self.ask_spread = 0.01
self.order_refresh_time = 1
trading_pairs = list(
map(lambda quote_asset: "ETH-" + quote_asset, ["USDT", "BTC"]))
market, market_infos = self.create_market(trading_pairs,
self.mid_price, {
"USDT": 5000,
"ETH": 500,
"BTC": 100
})
self.market = market
self.market_infos = market_infos
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.default_strategy = LiquidityMiningStrategy()
self.default_strategy.init_params(
exchange=self.market,
market_infos=self.market_infos,
token="ETH",
order_amount=Decimal(2),
spread=Decimal(0.0005),
inventory_skew_enabled=False,
target_base_pct=Decimal(0.5),
order_refresh_time=5,
order_refresh_tolerance_pct=Decimal(
0.1), # tolerance of 10 % change
max_order_age=3,
)
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.mocking_assistant = NetworkMockingAssistant()
self.exchange = GateIoExchange(self.api_key,
self.api_secret,
trading_pairs=[self.trading_pair])
self.event_listener = EventLogger()
self.exchange.logger().setLevel(1)
self.exchange.logger().addHandler(self)
async def test_update_order_status(self):
def create_order_record(trading_pair: str, trade_type: TradeType,
tx_hash: str, price: Decimal, amount: Decimal,
gas_price: Decimal) -> GatewayInFlightOrder:
order: GatewayInFlightOrder = GatewayInFlightOrder(
client_order_id=self._connector.create_market_order_id(
trade_type, trading_pair),
exchange_order_id=tx_hash,
trading_pair=trading_pair,
order_type=OrderType.LIMIT,
trade_type=trade_type,
price=price,
amount=amount,
gas_price=gas_price,
creation_timestamp=self._connector.current_timestamp)
order.fee_asset = self._connector._native_currency
self._connector._order_tracker.start_tracking_order(order)
return order
successful_records: List[GatewayInFlightOrder] = [
create_order_record(
"DAI-WETH",
TradeType.BUY,
"0xc7287236f64484b476cfbec0fd21bc49d85f8850c8885665003928a122041e18", # noqa: mock
Decimal("0.00267589"),
Decimal("1000"),
Decimal("29"))
]
fake_records: List[GatewayInFlightOrder] = [
create_order_record(
"DAI-WETH",
TradeType.BUY,
"0xc7287236f64484b476cfbec0fd21bc49d85f8850c8885665003928a122041e17", # noqa: mock
Decimal("0.00267589"),
Decimal("1000"),
Decimal("29"))
]
event_logger: EventLogger = EventLogger()
self._connector.add_listener(MarketEvent.OrderFilled, event_logger)
try:
await self._connector.update_order_status(successful_records +
fake_records)
async with timeout(10):
while len(event_logger.event_log) < 1:
await event_logger.wait_for(OrderFilledEvent)
filled_event: OrderFilledEvent = event_logger.event_log[0]
self.assertEqual(
"0xc7287236f64484b476cfbec0fd21bc49d85f8850c8885665003928a122041e18", # noqa: mock
filled_event.exchange_trade_id)
finally:
self._connector.remove_listener(MarketEvent.OrderFilled,
event_logger)
async def test_update_approval_status(self):
def create_approval_record(token_symbol: str,
tx_hash: str) -> GatewayInFlightOrder:
return GatewayInFlightOrder(
client_order_id=self._connector.create_approval_order_id(
token_symbol),
exchange_order_id=tx_hash,
trading_pair=token_symbol,
order_type=OrderType.LIMIT,
trade_type=TradeType.BUY,
price=s_decimal_0,
amount=s_decimal_0,
gas_price=s_decimal_0,
creation_timestamp=self._connector.current_timestamp)
successful_records: List[GatewayInFlightOrder] = [
create_approval_record(
"WETH",
"0x66b533792f45780fc38573bfd60d6043ab266471607848fb71284cd0d9eecff9" # noqa: mock
),
create_approval_record(
"DAI",
"0x4f81aa904fcb16a8938c0e0a76bf848df32ce6378e9e0060f7afc4b2955de405" # noqa: mock
),
]
fake_records: List[GatewayInFlightOrder] = [
create_approval_record(
"WETH",
"0x66b533792f45780fc38573bfd60d6043ab266471607848fb71284cd0d9eecff8" # noqa: mock
),
create_approval_record(
"DAI",
"0x4f81aa904fcb16a8938c0e0a76bf848df32ce6378e9e0060f7afc4b2955de404" # noqa: mock
),
]
event_logger: EventLogger = EventLogger()
self._connector.add_listener(TokenApprovalEvent.ApprovalSuccessful,
event_logger)
self._connector.add_listener(TokenApprovalEvent.ApprovalFailed,
event_logger)
try:
await self._connector.update_token_approval_status(
successful_records + fake_records)
self.assertEqual(2, len(event_logger.event_log))
self.assertEqual({"WETH", "DAI"},
set(e.token_symbol
for e in event_logger.event_log))
finally:
self._connector.remove_listener(
TokenApprovalEvent.ApprovalSuccessful, event_logger)
self._connector.remove_listener(TokenApprovalEvent.ApprovalFailed,
event_logger)
def setUp(self):
self.db_path: str = realpath(join(__file__, "../connector_test.sqlite"))
try:
# on windows cannot unlink the sqlite db file before closing the db
if os.name != 'nt':
os.unlink(self.db_path)
except FileNotFoundError:
pass
self.event_logger = EventLogger()
for event_tag in self.events:
self.connector.add_listener(event_tag, self.event_logger)
async def test_cancel_approval(self):
connector: GatewayEVMAMM = self._connector
event_logger: EventLogger = EventLogger()
connector.add_listener(TokenApprovalEvent.ApprovalCancelled,
event_logger)
expected_evm_approve_tx_hash_set: Set[str] = {
"0x7666bb5ba3ecec828e323f20685dfd03a067e7b2830b217363293b166b48a679", # noqa: mock
"0x7291d26447e300bd37260add7ac7db9a745f64c7ee10854695b0a70b0897456f", # noqa: mock
}
expected_cancel_tx_hash_set: Set[str] = {
"0x21b4d0e956241a497cf50d9c5dcefea4ec9fb225a1d11f80477ca434caab30ff", # noqa: mock
"0x7ac85d5a77f28e9317127218c06eb3d70f4c68924a4b5b743fe8faef6d011d11", # noqa: mock
}
try:
async with self.run_clock():
self._http_player.replay_timestamp_ms = 1648503333290
tracked_order_1: GatewayInFlightOrder = await connector.approve_token(
"DAI",
max_fee_per_gas=MAX_FEE_PER_GAS,
max_priority_fee_per_gas=MAX_PRIORITY_FEE_PER_GAS)
self._http_player.replay_timestamp_ms = 1648503337964
tracked_order_2: GatewayInFlightOrder = await connector.approve_token(
"WETH",
max_fee_per_gas=MAX_FEE_PER_GAS,
max_priority_fee_per_gas=MAX_PRIORITY_FEE_PER_GAS)
self.assertEqual(2, len(connector._in_flight_orders))
self.assertEqual(
expected_evm_approve_tx_hash_set,
set(o.exchange_order_id
for o in connector._in_flight_orders.values()))
self._http_player.replay_timestamp_ms = 1648503342513
tracked_order_1._creation_timestamp = connector.current_timestamp - 86400
tracked_order_2._creation_timestamp = connector.current_timestamp - 86400
await connector.cancel_outdated_orders(600)
self.assertEqual(2, len(connector._in_flight_orders))
self.assertEqual(
expected_cancel_tx_hash_set,
set(o.cancel_tx_hash
for o in connector._in_flight_orders.values()))
self._http_player.replay_timestamp_ms = 1648503385484
async with timeout(10):
while len(event_logger.event_log) < 2:
await event_logger.wait_for(TokenApprovalCancelledEvent
)
self.assertEqual(0, len(connector._in_flight_orders))
finally:
connector.remove_listener(TokenApprovalEvent.ApprovalCancelled,
event_logger)
def setUp(self) -> None:
super().setUp()
self.mocking_assistant = NetworkMockingAssistant()
self.event_listener = EventLogger()
not_a_real_secret = "kQH5HW/8p1uGOVjbgWA7FunAmGO8lsSUXNsu3eow76sz84Q18fWxnyRzBHCd3pd5nE9qa99HAZtuZuj6F1huXg=="
self.exchange = KrakenExchange(
kraken_api_key="someKey",
kraken_secret_key=not_a_real_secret,
trading_pairs=[self.trading_pair],
)
self.start_time = 1
self.clock = Clock(clock_mode=ClockMode.BACKTEST,
start_time=self.start_time)
def setUp(self):
self.db_path: str = realpath(join(__file__, "../binance_test.sqlite"))
try:
os.unlink(self.db_path)
except FileNotFoundError:
pass
self.market_logger = EventLogger()
for event_tag in self.events:
self.market.add_listener(event_tag, self.market_logger)
for trading_pair, orderbook in self.market.order_books.items():
orderbook.clear_traded_order_book()
