def test_should_cancel_all_orders_outside_bands(self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args(f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Web3Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and keeper.approve() self.synchronize_orders_twice(keeper) assert len(deployment.otc.get_orders()) == 2 # when deployment.otc.make(deployment.sai.address, Wad.from_number(5), deployment.gem.address, Wad.from_number(0.0538)).transact() #price=92.936802973977695 deployment.otc.make(deployment.sai.address, Wad.from_number(5), deployment.gem.address, Wad.from_number(0.0505)).transact() #price=99.0 deployment.otc.make(deployment.gem.address, Wad.from_number(0.5), deployment.sai.address, Wad.from_number(50.5)).transact() #price=101 deployment.otc.make(deployment.gem.address, Wad.from_number(0.5), deployment.sai.address, Wad.from_number(53.5)).transact() #price=107 assert len(deployment.otc.get_orders()) == 6 # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 2
def test_should_not_cancel_anything_if_no_orders_to_cancel_regardless_of_price_availability( self, tmpdir): # given config = BandConfig.sample_config(tmpdir) bands = self.create_bands(config) # when price = Price(buy_price=Wad.from_number(100), sell_price=Wad.from_number(200)) orders_to_cancel = bands.cancellable_orders([], [], price) # then assert (orders_to_cancel == []) # when price = Price(buy_price=Wad.from_number(100), sell_price=None) orders_to_cancel = bands.cancellable_orders([], [], price) # then assert (orders_to_cancel == []) # when price = Price(buy_price=None, sell_price=Wad.from_number(200)) orders_to_cancel = bands.cancellable_orders([], [], price) # then assert (orders_to_cancel == []) # when price = Price(buy_price=None, sell_price=None) orders_to_cancel = bands.cancellable_orders([], [], price) # then assert (orders_to_cancel == [])
def test_should_cancel_the_only_sell_order_and_place_a_new_one_if_above_max(self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args(f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Web3Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and keeper.approve() # and # [one artificially created order above the max band threshold] deployment.otc.make(deployment.gem.address, Wad.from_number(20), deployment.sai.address, Wad.from_number(2080)).transact() # when self.synchronize_orders_twice(keeper) # then # [the artificial order gets cancelled, a new one gets created instead] assert len(deployment.otc.get_orders()) == 2 assert self.orders_by_token(deployment, deployment.gem)[0].maker == deployment.our_address assert self.orders_by_token(deployment, deployment.gem)[0].pay_amount == Wad.from_number(7.5) assert self.orders_by_token(deployment, deployment.gem)[0].pay_token == deployment.gem.address assert self.orders_by_token(deployment, deployment.gem)[0].buy_amount == Wad.from_number(780) assert self.orders_by_token(deployment, deployment.gem)[0].buy_token == deployment.sai.address
def test_should_not_cancel_anything_if_no_orders_to_cancel_regardless_of_price_availability(self, tmpdir): # given config = BandConfig.sample_config(tmpdir) bands = self.create_bands(config) # when price = Price(buy_price=Wad.from_number(100), sell_price=Wad.from_number(200)) orders_to_cancel = bands.cancellable_orders([], [], price) # then assert(orders_to_cancel == []) # when price = Price(buy_price=Wad.from_number(100), sell_price=None) orders_to_cancel = bands.cancellable_orders([], [], price) # then assert(orders_to_cancel == []) # when price = Price(buy_price=None, sell_price=Wad.from_number(200)) orders_to_cancel = bands.cancellable_orders([], [], price) # then assert(orders_to_cancel == []) # when price = Price(buy_price=None, sell_price=None) orders_to_cancel = bands.cancellable_orders([], [], price) # then assert(orders_to_cancel == [])
def test_should_create_both_buy_and_sell_orders_and_modifie_it_according_rules(self, tmpdir): config = BandConfig.sample_config(tmpdir) bands = self.create_bands(config) buy_price_to_round_up = Wad.from_number(100.009) sell_price_to_round_up = Wad.from_number(200.039) price = Price(buy_price=buy_price_to_round_up, sell_price=sell_price_to_round_up) new_orders, _, _ = bands.new_orders([], [], Wad.from_number(1000000), Wad.from_number(1000000), price) assert(len(new_orders) == 2) assert(new_orders[0].is_sell is False) assert(new_orders[0].price == Wad.from_number(96.01)) assert(new_orders[0].amount == Wad.from_number(0.78117)) assert(new_orders[1].is_sell is True) assert(new_orders[1].price == Wad.from_number(208.04)) assert(new_orders[1].amount == Wad.from_number(7.5)) buy_price_to_round_down = Wad.from_number(100.022) sell_price_to_round_down = Wad.from_number(200.014) price = Price(buy_price=buy_price_to_round_down, sell_price=sell_price_to_round_down) new_orders, _, _ = bands.new_orders([], [], Wad.from_number(1000000), Wad.from_number(1000000), price) assert(len(new_orders) == 2) assert(new_orders[0].is_sell is False) assert(new_orders[0].price == Wad.from_number(96.02)) assert(new_orders[0].amount == Wad.from_number(0.78109)) assert(new_orders[1].is_sell is True) assert(new_orders[1].price == Wad.from_number(208.01)) assert(new_orders[1].amount == Wad.from_number(7.5))
def test_new_buy_orders_taker_amount_exceed_buy_balance_fail_case(tmpdir): bands_file = BandConfig.sample_config(tmpdir) bands_config = ReloadableConfig(str(bands_file)) airswap_bands = AirswapBands.read(bands_config, EmptyFeed(), FixedFeed({'canBuy': True, 'canSell': True}), History()) # maker_amount -> denominated in DAI maker_amount = Wad(0) taker_amount = Wad(11360000000000000000) our_buy_balance = Wad(50000000000000000) buy_limit = Wad(1562000000000000000000) target_price = WebSocketPriceFeed(FakeFeed({"buyPrice": "120", "sellPrice": "130"})).get_price() new_order = airswap_bands._new_side_orders('buy', maker_amount, taker_amount, our_buy_balance, buy_limit, airswap_bands.buy_bands[0], target_price.buy_price) # -- pricing logic -- # buyPrice = 120 * minMargin = 0.02 = 117.6 # maker_amount = 11.36000 / 117.6 = 0.09659863945 # our_buy_balance = 0.050000000000000000 !!BREAK!! assert new_order == {}
def test_should_cancel_orders_on_shutdown(self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args( f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--buy-token-address {deployment.sai.address} " f"--sell-token-address {deployment.gem.address} " f"--price-feed tub " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and keeper.approve() self.synchronize_orders_twice(keeper) assert len(deployment.otc.get_orders()) == 2 # when keeper.shutdown() # then assert len(deployment.otc.get_orders()) == 0
def test_should_cancel_selected_sell_orders_to_bring_the_band_total_below_max_and_closest_to_it( self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args( f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--buy-token-address {deployment.sai.address} " f"--sell-token-address {deployment.gem.address} " f"--price-feed tub " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and keeper.approve() self.synchronize_orders_twice(keeper) assert len(deployment.otc.get_orders()) == 2 # when [7.5+2.0 = 9.5] deployment.otc.make(deployment.gem.address, Wad.from_number(2), deployment.sai.address, Wad.from_number(208)).transact() # and keeper.order_book_manager.wait_for_order_book_refresh() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 3 # when [9.5+0.5 = 10] deployment.otc.make(deployment.gem.address, Wad.from_number(0.5), deployment.sai.address, Wad.from_number(52)).transact() # and keeper.order_book_manager.wait_for_order_book_refresh() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 4 # when [10+0.1 = 10.1] --> above max! deployment.otc.make(deployment.gem.address, Wad.from_number(0.1), deployment.sai.address, Wad.from_number(10.4)).transact() # and keeper.order_book_manager.wait_for_order_book_refresh() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 4 assert reduce(Wad.__add__, map(lambda order: order.pay_amount, self.orders_by_token(deployment, deployment.gem)), Wad(0)) \ == Wad.from_number(10.0)
def test_new_buy_orders_taker_amount_success_case(tmpdir): bands_file = BandConfig.sample_config(tmpdir) bands_config = ReloadableConfig(str(bands_file)) airswap_bands = AirswapBands.read(bands_config, EmptyFeed(), FixedFeed({'canBuy': True, 'canSell': True}), History()) # maker_amount -> denominated in DAI maker_amount = Wad(0) taker_amount = Wad(11360000000000000000) our_buy_balance = Wad(1562000000000000000000) buy_limit = Wad(1562000000000000000000) target_price = WebSocketPriceFeed(FakeFeed({"buyPrice": "120", "sellPrice": "130"})).get_price() new_order = airswap_bands._new_side_orders('buy', maker_amount, taker_amount, our_buy_balance, buy_limit, airswap_bands.buy_bands[0], target_price.buy_price) # -- pricing logic -- # buyPrice = 120 * minMargin = 0.04 = 4.8 # 120 - 4.8 = 115.2 # maker_amount = 11.36000 / 115.2 = 0.09861111111111111111111 assert new_order['taker_amount'].__float__() == 11.36000 assert new_order['maker_amount'].__float__() == 0.09861111111111111111111
def test_should_use_specified_gas_price_for_all_transactions( self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args( f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--price-feed tub " f"--config {config_file} " f"--gas-price 70000000000"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and start_block_number = deployment.web3.eth.blockNumber # when keeper.approve() self.synchronize_orders_twice(keeper) keeper.shutdown() # then for block_number in range(start_block_number + 1, deployment.web3.eth.blockNumber + 1): for transaction in deployment.web3.eth.getBlock( block_number, full_transactions=True).transactions: assert transaction.gasPrice == 70000000000
def test_should_cancel_all_orders_but_not_terminate_if_market_gets_closed( self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args( f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--price-feed tub " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # when keeper.approve() self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 2 # when deployment.otc._contract.transact().stop() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 0 assert not keeper.lifecycle.terminated_internally
def test_should_cancel_orders_on_shutdown(self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args(f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--buy-token-address {deployment.sai.address} " f"--sell-token-address {deployment.gem.address} " f"--price-feed tub " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and keeper.approve() self.synchronize_orders_twice(keeper) assert len(deployment.otc.get_orders()) == 2 # when keeper.shutdown() # then assert len(deployment.otc.get_orders()) == 0
def test_should_cancel_orders_if_price_disappears(self, tmpdir): # given config = BandConfig.sample_config(tmpdir) bands = self.create_bands(config) # and buy_order = FakeOrder(Wad.from_number(75), Wad.from_number(96)) sell_order = FakeOrder(Wad.from_number(7.5), Wad.from_number(208)) # when price = Price(buy_price=Wad.from_number(100), sell_price=Wad.from_number(200)) orders_to_cancel = bands.cancellable_orders([buy_order], [sell_order], price) # then assert(orders_to_cancel == []) # when price = Price(buy_price=Wad.from_number(100), sell_price=None) orders_to_cancel = bands.cancellable_orders([buy_order], [sell_order], price) # then assert(orders_to_cancel == [sell_order]) # when price = Price(buy_price=None, sell_price=Wad.from_number(200)) orders_to_cancel = bands.cancellable_orders([buy_order], [sell_order], price) # then assert(orders_to_cancel == [buy_order]) # when price = Price(buy_price=None, sell_price=None) orders_to_cancel = bands.cancellable_orders([buy_order], [sell_order], price) # then assert(orders_to_cancel == [buy_order, sell_order])
def test_should_cancel_all_orders_but_not_terminate_if_market_gets_closed(self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args(f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--buy-token-address {deployment.sai.address} " f"--sell-token-address {deployment.gem.address} " f"--price-feed tub " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # when keeper.approve() self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 2 # when deployment.otc._contract.transact().stop() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 0 assert not keeper.lifecycle.terminated_internally
def test_should_use_specified_gas_price_for_all_transactions(self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args(f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--buy-token-address {deployment.sai.address} " f"--sell-token-address {deployment.gem.address} " f"--price-feed tub " f"--config {config_file} " f"--gas-price 70000000000"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and start_block_number = deployment.web3.eth.blockNumber # when keeper.approve() self.synchronize_orders_twice(keeper) keeper.shutdown() # then for block_number in range(start_block_number+1, deployment.web3.eth.blockNumber+1): for transaction in deployment.web3.eth.getBlock(block_number, full_transactions=True).transactions: assert transaction.gasPrice == 70000000000
def test_should_reload_config_file_if_changed(self, deployment: Deployment, tmpdir): # given config_file = BandConfig.with_variables_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args( f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--price-feed tub " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # when keeper.approve() self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 1 # when second_config_file = BandConfig.sample_config(tmpdir) shutil.copyfile(second_config_file, config_file) # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 2
def test_should_cancel_the_only_buy_order_and_place_a_new_one_if_above_max( self, deployment: Deployment, tmpdir: py.path.local): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = EtherDeltaMarketMakerKeeper(args=args( f"--eth-from {deployment.our_address} --config {config_file}" f" --tub-address {deployment.tub.address}" f" --etherdelta-address {deployment.etherdelta.address}" f" --etherdelta-socket https://127.0.0.1:99999/" f" --order-age 3600 --eth-reserve 10" f" --min-eth-deposit 1 --min-sai-deposit 400"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) keeper.etherdelta_api.publish_order = MagicMock() # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and keeper.approve() # and # [one artificially created order above the max band threshold] keeper.our_orders.append( deployment.etherdelta.create_order(deployment.sai.address, Wad.from_number(170), EtherDelta.ETH_TOKEN, Wad.from_number(1.770805), 1000000)) # when keeper.synchronize_orders( ) # ... first call is so it can cancel the order keeper.synchronize_orders( ) # ... second call is so it can made deposits keeper.synchronize_orders( ) # ... third call is so the actual orders can get placed # then # [the artificial order gets cancelled, a new one gets created instead] assert len(self.orders(keeper)) == 2 assert self.orders_by_token( keeper, deployment.sai.address)[0].maker == deployment.our_address assert self.orders_by_token( keeper, deployment.sai.address)[0].pay_amount == Wad.from_number(75) assert self.orders_by_token( keeper, deployment.sai.address)[0].pay_token == deployment.sai.address assert self.orders_by_token( keeper, deployment.sai.address)[0].buy_amount == Wad.from_number(0.78125) assert self.orders_by_token( keeper, deployment.sai.address)[0].buy_token == EtherDelta.ETH_TOKEN
def test_should_place_extra_order_only_if_order_brought_below_min(self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args(f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--buy-token-address {deployment.sai.address} " f"--sell-token-address {deployment.gem.address} " f"--price-feed tub " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and keeper.approve() self.synchronize_orders_twice(keeper) assert len(deployment.otc.get_orders()) == 2 sai_order_id = self.orders_by_token(deployment, deployment.sai)[0].order_id # when deployment.otc.take(sai_order_id, Wad.from_number(20)).transact() # and keeper.order_book_manager.wait_for_order_book_refresh() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 2 # when deployment.otc.take(sai_order_id, Wad.from_number(5)).transact() # and keeper.order_book_manager.wait_for_order_book_refresh() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 2 # when deployment.otc.take(sai_order_id, Wad.from_number(1)).transact() # and keeper.order_book_manager.wait_for_order_book_refresh() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 3 assert deployment.otc.get_orders()[2].pay_amount == Wad.from_number(26) assert deployment.otc.get_orders()[2].pay_token == deployment.sai.address assert deployment.otc.get_orders()[2].buy_amount == Wad(270833333333333333) assert deployment.otc.get_orders()[2].buy_token == deployment.gem.address
def test_should_place_extra_order_only_if_order_brought_below_min(self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args(f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--buy-token-address {deployment.sai.address} " f"--sell-token-address {deployment.gem.address} " f"--price-feed eth_dai-tub " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and keeper.approve() self.synchronize_orders_twice(keeper) assert len(deployment.otc.get_orders()) == 2 sai_order_id = self.orders_by_token(deployment, deployment.sai)[0].order_id # when deployment.otc.take(sai_order_id, Wad.from_number(20)).transact() # and keeper.order_book_manager.wait_for_order_book_refresh() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 2 # when deployment.otc.take(sai_order_id, Wad.from_number(5)).transact() # and keeper.order_book_manager.wait_for_order_book_refresh() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 2 # when deployment.otc.take(sai_order_id, Wad.from_number(1)).transact() # and keeper.order_book_manager.wait_for_order_book_refresh() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 3 assert deployment.otc.get_orders()[2].pay_amount == Wad.from_number(26) assert deployment.otc.get_orders()[2].pay_token == deployment.sai.address assert deployment.otc.get_orders()[2].buy_amount == Wad(270833333333333333) assert deployment.otc.get_orders()[2].buy_token == deployment.gem.address
def test_should_not_create_orders_if_neither_buy_nor_sell_price_available(self, tmpdir): # given config = BandConfig.sample_config(tmpdir) bands = self.create_bands(config) # when price = Price(buy_price=None, sell_price=None) new_orders, _, _ = bands.new_orders([], [], Wad.from_number(1000000), Wad.from_number(1000000), price) # then assert(new_orders == [])
def test_should_create_orders_on_startup(self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args( f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--buy-token-address {deployment.sai.address} " f"--sell-token-address {deployment.gem.address} " f"--price-feed tub " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # when keeper.approve() self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 2 # and assert self.orders_by_token( deployment, deployment.sai)[0].maker == deployment.our_address assert self.orders_by_token( deployment, deployment.sai)[0].pay_amount == Wad.from_number(75) assert self.orders_by_token( deployment, deployment.sai)[0].pay_token == deployment.sai.address assert self.orders_by_token( deployment, deployment.sai)[0].buy_amount == Wad.from_number(0.78125) assert self.orders_by_token( deployment, deployment.sai)[0].buy_token == deployment.gem.address # and assert self.orders_by_token( deployment, deployment.gem)[0].maker == deployment.our_address assert self.orders_by_token( deployment, deployment.gem)[0].pay_amount == Wad.from_number(7.5) assert self.orders_by_token( deployment, deployment.gem)[0].pay_token == deployment.gem.address assert self.orders_by_token( deployment, deployment.gem)[0].buy_amount == Wad.from_number(780) assert self.orders_by_token( deployment, deployment.gem)[0].buy_token == deployment.sai.address
def test_should_cancel_selected_buy_orders_to_bring_the_band_total_below_max_and_closest_to_it( self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args( f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--price-feed tub " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and keeper.approve() self.synchronize_orders_twice(keeper) assert len(deployment.otc.get_orders()) == 2 # when [75+17 = 92] deployment.otc.make(deployment.sai.address, Wad.from_number(17), deployment.gem.address, Wad.from_number(0.1770805)).transact() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 3 # when [92+2 = 94] deployment.otc.make(deployment.sai.address, Wad.from_number(2), deployment.gem.address, Wad.from_number(0.020833)).transact() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 4 # when [94+7 = 101] --> above max! deployment.otc.make(deployment.sai.address, Wad.from_number(7), deployment.gem.address, Wad.from_number(0.072912)).transact() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 4 assert reduce(Wad.__add__, map(lambda order: order.pay_amount, self.orders_by_token(deployment, deployment.sai)), Wad(0)) \ == Wad.from_number(99)
def test_should_cancel_selected_sell_orders_to_bring_the_band_total_below_max_and_closest_to_it(self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args(f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--buy-token-address {deployment.sai.address} " f"--sell-token-address {deployment.gem.address} " f"--price-feed tub " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and keeper.approve() self.synchronize_orders_twice(keeper) assert len(deployment.otc.get_orders()) == 2 # when [7.5+2.0 = 9.5] deployment.otc.make(deployment.gem.address, Wad.from_number(2), deployment.sai.address, Wad.from_number(208)).transact() # and keeper.order_book_manager.wait_for_order_book_refresh() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 3 # when [9.5+0.5 = 10] deployment.otc.make(deployment.gem.address, Wad.from_number(0.5), deployment.sai.address, Wad.from_number(52)).transact() # and keeper.order_book_manager.wait_for_order_book_refresh() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 4 # when [10+0.1 = 10.1] --> above max! deployment.otc.make(deployment.gem.address, Wad.from_number(0.1), deployment.sai.address, Wad.from_number(10.4)).transact() # and keeper.order_book_manager.wait_for_order_book_refresh() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 4 assert reduce(Wad.__add__, map(lambda order: order.pay_amount, self.orders_by_token(deployment, deployment.gem)), Wad(0)) \ == Wad.from_number(10.0)
def test_should_create_only_sell_orders_if_only_sell_price_is_available(self, tmpdir): # given config = BandConfig.sample_config(tmpdir) bands = self.create_bands(config) # when price = Price(buy_price=None, sell_price=Wad.from_number(200)) new_orders, _, _ = bands.new_orders([], [], Wad.from_number(1000000), Wad.from_number(1000000), price) # then assert(len(new_orders) == 1) assert(new_orders[0].is_sell is True) assert(new_orders[0].price == Wad.from_number(208))
def test_should_create_both_buy_and_sell_orders_when_rules_allows_it(self, tmpdir): config = BandConfig.sample_config(tmpdir) bands = self.create_bands(config) price = Price(buy_price=Wad.from_number(100.01), sell_price=Wad.from_number(200.03)) new_orders, _, _ = bands.new_orders([], [], Wad.from_number(1000000), Wad.from_number(1000000), price) assert(len(new_orders) == 2) assert(new_orders[0].is_sell is False) assert(new_orders[0].amount == Wad.from_number(0.78117)) assert(new_orders[0].price == Wad.from_number(96.01)) assert(new_orders[1].is_sell is True) assert(new_orders[1].price == Wad.from_number(208.03)) assert(new_orders[1].amount == Wad.from_number(7.5))
def test_should_reload_config_file_if_changed(self, deployment: Deployment, tmpdir: py.path.local): # given config_file = BandConfig.with_variables_config(tmpdir) # and keeper = EtherDeltaMarketMakerKeeper(args=args( f"--eth-from {deployment.our_address} --config {config_file}" f" --tub-address {deployment.tub.address}" f" --etherdelta-address {deployment.etherdelta.address}" f" --etherdelta-socket https://127.0.0.1:99999/" f" --order-age 3600 --eth-reserve 10" f" --min-eth-deposit 1 --min-sai-deposit 400"), web3=deployment.web3) keeper.lifecycle = Web3Lifecycle(web3=keeper.web3) keeper.etherdelta_api.publish_order = MagicMock() # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # when keeper.approve() keeper.synchronize_orders( ) # ... first call is so it can made deposits keeper.synchronize_orders( ) # ... second call is so the actual orders can get placed # then assert len(self.orders(keeper)) == 1 # when second_config_file = BandConfig.sample_config(tmpdir) shutil.copyfile(second_config_file, config_file) # and keeper.synchronize_orders( ) # ... first call is so it can made deposits keeper.synchronize_orders( ) # ... second call is so the actual orders can get placed # then assert len(self.orders(keeper)) == 2
def test_should_create_both_buy_and_sell_orders_if_both_prices_are_available( self, tmpdir): # given config = BandConfig.sample_config(tmpdir) bands = self.create_bands(config) # when price = Price(buy_price=Wad.from_number(100), sell_price=Wad.from_number(200)) new_orders, _, _ = bands.new_orders([], [], Wad.from_number(1000000), Wad.from_number(1000000), price) # then assert (len(new_orders) == 2) assert (new_orders[0].is_sell is False) assert (new_orders[0].price == Wad.from_number(96)) assert (new_orders[0].amount == Wad.from_number(0.78125)) assert (new_orders[1].is_sell is True) assert (new_orders[1].price == Wad.from_number(208)) assert (new_orders[1].amount == Wad.from_number(7.5))
def test_should_cancel_orders_on_shutdown_and_withdraw_if_asked_to_do_so( self, deployment: Deployment, tmpdir: py.path.local): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = EtherDeltaMarketMakerKeeper(args=args( f"--eth-from {deployment.our_address} --config {config_file}" f" --tub-address {deployment.tub.address}" f" --etherdelta-address {deployment.etherdelta.address}" f" --etherdelta-socket https://127.0.0.1:99999/" f" --order-age 3600 --eth-reserve 10" f" --min-eth-deposit 1 --min-sai-deposit 400" f" --cancel-on-shutdown --withdraw-on-shutdown"), web3=deployment.web3) keeper.lifecycle = Web3Lifecycle(web3=keeper.web3) keeper.etherdelta_api.publish_order = MagicMock() # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and keeper.approve() keeper.synchronize_orders( ) # ... first call is so it can made deposits keeper.synchronize_orders( ) # ... second call is so the actual orders can get placed assert len(self.orders(keeper)) == 2 # when keeper.shutdown() # then assert len(self.orders(keeper)) == 0 # and assert deployment.etherdelta.balance_of( deployment.our_address) == Wad(0) assert deployment.etherdelta.balance_of_token( deployment.sai.address, deployment.our_address) == Wad(0)
def test_should_use_specified_gas_price_for_all_transactions( self, deployment: Deployment, tmpdir: py.path.local): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = EtherDeltaMarketMakerKeeper(args=args( f"--eth-from {deployment.our_address} --config {config_file}" f" --tub-address {deployment.tub.address}" f" --etherdelta-address {deployment.etherdelta.address}" f" --etherdelta-socket https://127.0.0.1:99999/" f" --order-age 3600 --eth-reserve 10" f" --min-eth-deposit 1 --min-sai-deposit 400" f" --cancel-on-shutdown" f" --gas-price 69000000000"), web3=deployment.web3) keeper.lifecycle = Web3Lifecycle(web3=keeper.web3) keeper.etherdelta_api.publish_order = MagicMock() # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and start_block_number = deployment.web3.eth.blockNumber # when keeper.approve() keeper.synchronize_orders( ) # ... first call is so it can made deposits keeper.synchronize_orders( ) # ... second call is so the actual orders can get placed keeper.shutdown() # then for block_number in range(start_block_number + 1, deployment.web3.eth.blockNumber + 1): for transaction in deployment.web3.eth.getBlock( block_number, full_transactions=True).transactions: assert transaction.gasPrice == 69000000000
def test_should_cancel_the_only_sell_order_and_place_a_new_one_if_above_max(self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args(f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--buy-token-address {deployment.sai.address} " f"--sell-token-address {deployment.gem.address} " f"--price-feed tub " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and keeper.approve() # and # [one artificially created order above the max band threshold] deployment.otc.make(deployment.gem.address, Wad.from_number(20), deployment.sai.address, Wad.from_number(2080)).transact() # and keeper.order_book_manager.wait_for_order_book_refresh() # when self.synchronize_orders_twice(keeper) # then # [the artificial order gets cancelled, a new one gets created instead] assert len(deployment.otc.get_orders()) == 2 assert self.orders_by_token(deployment, deployment.gem)[0].maker == deployment.our_address assert self.orders_by_token(deployment, deployment.gem)[0].pay_amount == Wad.from_number(7.5) assert self.orders_by_token(deployment, deployment.gem)[0].pay_token == deployment.gem.address assert self.orders_by_token(deployment, deployment.gem)[0].buy_amount == Wad.from_number(780) assert self.orders_by_token(deployment, deployment.gem)[0].buy_token == deployment.sai.address
def test_should_cancel_all_orders_but_not_terminate_if_config_file_becomes_invalid( self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args( f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--buy-token-address {deployment.sai.address} " f"--sell-token-address {deployment.gem.address} " f"--price-feed tub " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # when keeper.approve() self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 2 # when second_config_file = BandConfig.bands_overlapping_invalid_config( tmpdir) shutil.copyfile(second_config_file, config_file) # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 0 assert not keeper.lifecycle.terminated_internally
def test_should_create_orders_on_startup(self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args(f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--buy-token-address {deployment.sai.address} " f"--sell-token-address {deployment.gem.address} " f"--price-feed tub " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # when keeper.approve() self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 2 # and assert self.orders_by_token(deployment, deployment.sai)[0].maker == deployment.our_address assert self.orders_by_token(deployment, deployment.sai)[0].pay_amount == Wad.from_number(75) assert self.orders_by_token(deployment, deployment.sai)[0].pay_token == deployment.sai.address assert self.orders_by_token(deployment, deployment.sai)[0].buy_amount == Wad.from_number(0.78125) assert self.orders_by_token(deployment, deployment.sai)[0].buy_token == deployment.gem.address # and assert self.orders_by_token(deployment, deployment.gem)[0].maker == deployment.our_address assert self.orders_by_token(deployment, deployment.gem)[0].pay_amount == Wad.from_number(7.5) assert self.orders_by_token(deployment, deployment.gem)[0].pay_token == deployment.gem.address assert self.orders_by_token(deployment, deployment.gem)[0].buy_amount == Wad.from_number(780) assert self.orders_by_token(deployment, deployment.gem)[0].buy_token == deployment.sai.address
def test_should_cancel_all_orders_outside_bands(self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args(f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--buy-token-address {deployment.sai.address} " f"--sell-token-address {deployment.gem.address} " f"--price-feed tub " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and keeper.approve() self.synchronize_orders_twice(keeper) assert len(deployment.otc.get_orders()) == 2 # when deployment.otc.make(deployment.sai.address, Wad.from_number(5), deployment.gem.address, Wad.from_number(0.0538)).transact() #price=92.936802973977695 deployment.otc.make(deployment.sai.address, Wad.from_number(5), deployment.gem.address, Wad.from_number(0.0505)).transact() #price=99.0 deployment.otc.make(deployment.gem.address, Wad.from_number(0.5), deployment.sai.address, Wad.from_number(50.5)).transact() #price=101 deployment.otc.make(deployment.gem.address, Wad.from_number(0.5), deployment.sai.address, Wad.from_number(53.5)).transact() #price=107 assert len(deployment.otc.get_orders()) == 6 # and keeper.order_book_manager.wait_for_order_book_refresh() # and self.synchronize_orders_twice(keeper) # then assert len(deployment.otc.get_orders()) == 2
def test_should_send_replacement_orders_the_moment_old_ones_get_cancelled( self, deployment: Deployment, tmpdir): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = OasisMarketMakerKeeper(args=args( f"--eth-from {deployment.our_address} " f"--tub-address {deployment.tub.address} " f"--oasis-address {deployment.otc.address} " f"--buy-token-address {deployment.sai.address} " f"--sell-token-address {deployment.gem.address} " f"--price-feed tub " f"--config {config_file}"), web3=deployment.web3) keeper.lifecycle = Lifecycle(web3=keeper.web3) # and self.mint_tokens(deployment) # and keeper.approve() # when self.set_price(deployment, Wad.from_number(100)) self.synchronize_orders_once(keeper) # then assert len(deployment.otc.get_orders()) == 2 # and assert self.orders_by_token( deployment, deployment.sai)[0].maker == deployment.our_address assert self.orders_by_token( deployment, deployment.sai)[0].pay_amount == Wad.from_number(75) assert self.orders_by_token( deployment, deployment.sai)[0].pay_token == deployment.sai.address assert self.orders_by_token( deployment, deployment.sai)[0].buy_amount == Wad.from_number(0.78125) assert self.orders_by_token( deployment, deployment.sai)[0].buy_token == deployment.gem.address # and assert self.orders_by_token( deployment, deployment.gem)[0].maker == deployment.our_address assert self.orders_by_token( deployment, deployment.gem)[0].pay_amount == Wad.from_number(7.5) assert self.orders_by_token( deployment, deployment.gem)[0].pay_token == deployment.gem.address assert self.orders_by_token( deployment, deployment.gem)[0].buy_amount == Wad.from_number(780) assert self.orders_by_token( deployment, deployment.gem)[0].buy_token == deployment.sai.address # when self.set_price(deployment, Wad.from_number(200)) block_number_before = deployment.web3.eth.blockNumber self.synchronize_orders_once(keeper) block_number_after = deployment.web3.eth.blockNumber # then assert len(deployment.otc.get_orders()) == 2 # and assert block_number_after - block_number_before == 4 # and assert self.orders_by_token( deployment, deployment.sai)[0].maker == deployment.our_address assert self.orders_by_token( deployment, deployment.sai)[0].pay_amount == Wad.from_number(75) assert self.orders_by_token( deployment, deployment.sai)[0].pay_token == deployment.sai.address assert self.orders_by_token( deployment, deployment.sai)[0].buy_amount == Wad.from_number(0.78125 / 2) assert self.orders_by_token( deployment, deployment.sai)[0].buy_token == deployment.gem.address # and assert self.orders_by_token( deployment, deployment.gem)[0].maker == deployment.our_address assert self.orders_by_token( deployment, deployment.gem)[0].pay_amount == Wad.from_number(7.5) assert self.orders_by_token( deployment, deployment.gem)[0].pay_token == deployment.gem.address assert self.orders_by_token( deployment, deployment.gem)[0].buy_amount == Wad.from_number(780 * 2) assert self.orders_by_token( deployment, deployment.gem)[0].buy_token == deployment.sai.address
def test_airswap_read_bands(tmpdir): bands_file = BandConfig.sample_config(tmpdir) bands_config = ReloadableConfig(str(bands_file)) airswap_bands = AirswapBands.read(bands_config, EmptyFeed(), FixedFeed({'canBuy': True, 'canSell': True}), History()) assert isinstance(airswap_bands, AirswapBands)
def test_should_place_extra_order_only_if_order_brought_below_min( self, deployment: Deployment, tmpdir: py.path.local): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = EtherDeltaMarketMakerKeeper(args=args( f"--eth-from {deployment.our_address} --config {config_file}" f" --tub-address {deployment.tub.address}" f" --etherdelta-address {deployment.etherdelta.address}" f" --etherdelta-socket https://127.0.0.1:99999/" f" --order-age 3600 --eth-reserve 10" f" --min-eth-deposit 1 --min-sai-deposit 400"), web3=deployment.web3) keeper.lifecycle = Web3Lifecycle(web3=keeper.web3) keeper.etherdelta_api.publish_order = MagicMock() # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and keeper.approve() keeper.synchronize_orders( ) # ... first call is so it can made deposits keeper.synchronize_orders( ) # ... second call is so the actual orders can get placed assert len(self.orders(keeper)) == 2 sai_order = self.orders_by_token(keeper, deployment.sai.address)[0] # when print(sai_order.sell_to_buy_price) print(sai_order.buy_to_sell_price) deployment.etherdelta.trade(sai_order, Wad.from_number(20) / Wad.from_number(96)).transact() # and keeper.synchronize_orders() # then assert len(self.orders(keeper)) == 2 # when deployment.etherdelta.trade(sai_order, Wad.from_number(5) / Wad.from_number(96)).transact() # and keeper.synchronize_orders() # then assert len(self.orders(keeper)) == 2 # when deployment.etherdelta.trade(sai_order, Wad.from_number(1) / Wad.from_number(96)).transact() # and keeper.synchronize_orders() # then assert len(self.orders(keeper)) == 3 assert self.orders(keeper)[2].pay_amount == Wad.from_number(26) assert self.orders(keeper)[2].pay_token == deployment.sai.address assert self.orders(keeper)[2].buy_amount == Wad(270833333000000000) assert self.orders(keeper)[2].buy_token == EtherDelta.ETH_TOKEN
def test_should_cancel_selected_sell_orders_to_bring_the_band_total_below_max_and_closest_to_it( self, deployment: Deployment, tmpdir: py.path.local): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = EtherDeltaMarketMakerKeeper(args=args( f"--eth-from {deployment.our_address} --config {config_file}" f" --tub-address {deployment.tub.address}" f" --etherdelta-address {deployment.etherdelta.address}" f" --etherdelta-socket https://127.0.0.1:99999/" f" --order-age 3600 --eth-reserve 10" f" --min-eth-deposit 1 --min-sai-deposit 400"), web3=deployment.web3) keeper.lifecycle = Web3Lifecycle(web3=keeper.web3) keeper.etherdelta_api.publish_order = MagicMock() # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and keeper.approve() keeper.synchronize_orders( ) # ... first call is so it can made deposits keeper.synchronize_orders( ) # ... second call is so the actual orders can get placed assert len(self.orders(keeper)) == 2 # when [7.5+2.0 = 9.5] keeper.our_orders.append( deployment.etherdelta.create_order(EtherDelta.ETH_TOKEN, Wad.from_number(2), deployment.sai.address, Wad.from_number(208), 1000000)) # and keeper.synchronize_orders( ) # ... first call is so it can made deposits keeper.synchronize_orders( ) # ... second call is so the actual orders can get placed # then assert len(self.orders(keeper)) == 3 # when [9.5+0.5 = 10] keeper.our_orders.append( deployment.etherdelta.create_order(EtherDelta.ETH_TOKEN, Wad.from_number(0.5), deployment.sai.address, Wad.from_number(52), 1000000)) # and keeper.synchronize_orders( ) # ... first call is so it can made deposits keeper.synchronize_orders( ) # ... second call is so the actual orders can get placed # then assert len(self.orders(keeper)) == 4 # when [10+0.1 = 10.1] --> above max! keeper.our_orders.append( deployment.etherdelta.create_order(EtherDelta.ETH_TOKEN, Wad.from_number(0.1), deployment.sai.address, Wad.from_number(10.4), 1000000)) # and keeper.synchronize_orders( ) # ... first call is so it can made deposits keeper.synchronize_orders( ) # ... second call is so the actual orders can get placed # then assert len(self.orders(keeper)) == 4 assert reduce(Wad.__add__, map(lambda order: order.pay_amount, self.orders_by_token(keeper, EtherDelta.ETH_TOKEN)), Wad(0)) \ == Wad.from_number(10.0)
def test_should_deposit_and_create_orders_on_startup( self, deployment: Deployment, tmpdir: py.path.local): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = EtherDeltaMarketMakerKeeper(args=args( f"--eth-from {deployment.our_address} --config {config_file}" f" --tub-address {deployment.tub.address}" f" --etherdelta-address {deployment.etherdelta.address}" f" --etherdelta-socket https://127.0.0.1:99999/" f" --order-age 3600 --eth-reserve 10" f" --min-eth-deposit 1 --min-sai-deposit 400"), web3=deployment.web3) keeper.lifecycle = Web3Lifecycle(web3=keeper.web3) keeper.etherdelta_api.publish_order = MagicMock() # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # when keeper.approve() keeper.synchronize_orders( ) # ... first call is so it can made deposits keeper.synchronize_orders( ) # ... second call is so the actual orders can get placed # then assert deployment.etherdelta.balance_of( deployment.our_address) > Wad(0) assert deployment.etherdelta.balance_of_token( deployment.sai.address, deployment.our_address) > Wad(0) # and assert len(self.orders(keeper)) == 2 assert keeper.etherdelta_api.publish_order.call_count == 2 # and assert self.orders_by_token( keeper, deployment.sai.address)[0].maker == deployment.our_address assert self.orders_by_token( keeper, deployment.sai.address)[0].pay_amount == Wad.from_number(75) assert self.orders_by_token( keeper, deployment.sai.address)[0].pay_token == deployment.sai.address assert self.orders_by_token( keeper, deployment.sai.address)[0].buy_amount == Wad.from_number(0.78125) assert self.orders_by_token( keeper, deployment.sai.address)[0].buy_token == EtherDelta.ETH_TOKEN # and assert self.orders_by_token( keeper, EtherDelta.ETH_TOKEN)[0].maker == deployment.our_address assert self.orders_by_token( keeper, EtherDelta.ETH_TOKEN)[0].pay_amount == Wad.from_number(7.5) assert self.orders_by_token( keeper, EtherDelta.ETH_TOKEN)[0].pay_token == EtherDelta.ETH_TOKEN assert self.orders_by_token( keeper, EtherDelta.ETH_TOKEN)[0].buy_amount == Wad.from_number(780) assert self.orders_by_token( keeper, EtherDelta.ETH_TOKEN)[0].buy_token == deployment.sai.address
def test_should_cancel_all_orders_outside_bands(self, deployment: Deployment, tmpdir: py.path.local): # given config_file = BandConfig.sample_config(tmpdir) # and keeper = EtherDeltaMarketMakerKeeper(args=args( f"--eth-from {deployment.our_address} --config {config_file}" f" --tub-address {deployment.tub.address}" f" --etherdelta-address {deployment.etherdelta.address}" f" --etherdelta-socket https://127.0.0.1:99999/" f" --order-age 3600 --eth-reserve 10" f" --min-eth-deposit 1 --min-sai-deposit 400"), web3=deployment.web3) keeper.lifecycle = Web3Lifecycle(web3=keeper.web3) keeper.etherdelta_api.publish_order = MagicMock() # and self.mint_tokens(deployment) self.set_price(deployment, Wad.from_number(100)) # and keeper.approve() keeper.synchronize_orders( ) # ... first call is so it can made deposits keeper.synchronize_orders( ) # ... second call is so the actual orders can get placed assert len(self.orders(keeper)) == 2 # when keeper.our_orders.append( deployment.etherdelta.create_order( deployment.sai.address, Wad.from_number(5), EtherDelta.ETH_TOKEN, Wad.from_number(0.0538), 1000000)) #price=92.936802973977695 keeper.our_orders.append( deployment.etherdelta.create_order(deployment.sai.address, Wad.from_number(5), EtherDelta.ETH_TOKEN, Wad.from_number(0.0505), 1000000)) #price=99.0 keeper.our_orders.append( deployment.etherdelta.create_order(EtherDelta.ETH_TOKEN, Wad.from_number(0.5), deployment.sai.address, Wad.from_number(50.5), 1000000)) #price=101 keeper.our_orders.append( deployment.etherdelta.create_order(EtherDelta.ETH_TOKEN, Wad.from_number(0.5), deployment.sai.address, Wad.from_number(53.5), 1000000)) #price=107 assert len(self.orders(keeper)) == 6 # and keeper.synchronize_orders( ) # ... first call is so it can made deposits keeper.synchronize_orders( ) # ... second call is so the actual orders can get placed # then assert len(self.orders(keeper)) == 2