def mint_mkr(mkr: DSToken, recipient_address: Address, amount: Wad):
assert isinstance(mkr, DSToken)
assert isinstance(recipient_address, Address)
assert isinstance(amount, Wad)
assert amount > Wad(0)
deployment_address = Address("0x00a329c0648769A73afAc7F9381E08FB43dBEA72")
assert mkr.mint(amount).transact(from_address=deployment_address)
assert mkr.balance_of(deployment_address) > Wad(0)
assert mkr.approve(recipient_address).transact(from_address=deployment_address)
assert mkr.transfer(recipient_address, amount).transact(from_address=deployment_address)
def mint_mkr(mkr: DSToken, deployment_address: Address,
recipient_address: Address, amount: Wad):
assert isinstance(mkr, DSToken)
assert isinstance(deployment_address, Address)
assert isinstance(recipient_address, Address)
assert isinstance(amount, Wad)
assert amount > Wad(0)
assert mkr.mint(amount).transact(from_address=deployment_address)
assert mkr.balance_of(deployment_address) > Wad(0)
assert mkr.approve(recipient_address).transact(
from_address=deployment_address)
assert mkr.transfer(recipient_address,
amount).transact(from_address=deployment_address)
class TestAuctionKeeperFlipper(TransactionIgnoringTest):
def setup_method(self):
self.web3 = Web3(HTTPProvider("http://localhost:8555"))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.keeper_address = Address(self.web3.eth.defaultAccount)
self.gal_address = Address(self.web3.eth.accounts[1])
self.other_address = Address(self.web3.eth.accounts[2])
# GemMock version of DSToken with push(bytes32, uint function) an hope(address)
gem_abi = Contract._load_abi(__name__,
'../lib/pymaker/tests/abi/GemMock.abi')
gem_bin = Contract._load_bin(__name__,
'../lib/pymaker/tests/abi/GemMock.bin')
self.gem_addr = Contract._deploy(self.web3, gem_abi, gem_bin, [b'ABC'])
self.gem = DSToken(web3=self.web3, address=self.gem_addr)
self.dai_addr = Contract._deploy(self.web3, gem_abi, gem_bin, [b'DAI'])
self.dai = DSToken(web3=self.web3, address=self.dai_addr)
self.flipper = Flipper.deploy(self.web3, self.dai.address,
self.gem.address)
# Set allowance to allow flipper to move dai and gem
self.dai.approve(self.flipper.address).transact()
self.dai.approve(
self.flipper.address).transact(from_address=self.gal_address)
self.dai.approve(
self.flipper.address).transact(from_address=self.other_address)
self.gem.approve(
self.flipper.address).transact(from_address=self.gal_address)
self.gem.approve(
self.flipper.address).transact(from_address=self.other_address)
self.keeper = AuctionKeeper(args=args(
f"--eth-from {self.keeper_address} "
f"--flipper {self.flipper.address} "
f"--model ./bogus-model.sh"),
web3=self.web3)
self.keeper.approve()
# So that `keeper_address` and `other_address` can bid in auctions,
# they both need to have DAI in their accounts.
self.dai.mint(Wad.from_number(20000000)).transact()
self.dai.transfer(self.other_address,
Wad.from_number(10000000)).transact()
# So that `gal_address` can kick auction he need to have GEM in his accounts
self.gem.mint(Wad.from_number(1000000)).transact()
self.gem.transfer(self.gal_address,
Wad.from_number(1000000)).transact()
self.model = MagicMock()
self.model.get_stance = MagicMock(return_value=None)
self.model_factory = self.keeper.auctions.model_factory
self.model_factory.create_model = MagicMock(return_value=self.model)
def gem_balance(self, address: Address) -> Wad:
assert (isinstance(address, Address))
return Wad(self.gem.balance_of(address))
def simulate_model_output(self,
price: Wad,
gas_price: Optional[int] = None):
self.model.get_stance = MagicMock(
return_value=Stance(price=price, gas_price=gas_price))
def models(self, keeper):
model = MagicMock()
model.get_stance = MagicMock(return_value=None)
model_factory = keeper.auctions.model_factory
model_factory.create_model = MagicMock(return_value=model)
return (model, model_factory)
def test_should_start_a_new_model_and_provide_it_with_info_on_auction_kick(
self, bid_id, d, keeper, c):
# given
(model, model_factory) = self.models(keeper)
# when
keeper.check_all_auctions()
wait_for_other_threads()
# then
model_factory.create_model.assert_called_once_with(
Parameters(flipper=c.flipper.address,
flapper=None,
flopper=None,
id=bid_id))
# and
assert model.send_status.call_args[0][0].id == bid_id
assert model.send_status.call_args[0][0].flipper == c.flipper.address
assert model.send_status.call_args[0][0].flapper is None
assert model.send_status.call_args[0][0].flopper is None
assert model.send_status.call_args[0][0].bid == Wad.from_number(0)
assert model.send_status.call_args[0][0].lot == Wad(684931506849315068)
assert model.send_status.call_args[0][0].tab == Wad.from_number(100)
assert model.send_status.call_args[0][0].beg == Ray.from_number(1.05)
assert model.send_status.call_args[0][0].guy == d.cat.address
assert model.send_status.call_args[0][0].era > 0
assert model.send_status.call_args[
0][0].end < model.send_status.call_args[0][0].era + c.flipper.tau(
) + 1
assert model.send_status.call_args[0][0].tic == 0
assert model.send_status.call_args[0][0].price == Wad(0)
def test_should_provide_model_with_updated_info_after_our_own_bid(self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.model.send_status.call_count == 1
# when
self.simulate_model_output(price=Wad.from_number(15.0))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.model.send_status.call_count > 1
# and
assert self.model.send_status.call_args[0][0].id == 1
assert self.model.send_status.call_args[0][
0].flipper == self.flipper.address
assert self.model.send_status.call_args[0][0].flapper is None
assert self.model.send_status.call_args[0][0].flopper is None
assert self.model.send_status.call_args[0][0].bid == Wad.from_number(
1500)
assert self.model.send_status.call_args[0][0].lot == Wad.from_number(
100)
assert self.model.send_status.call_args[0][0].tab == Wad.from_number(
5000)
assert self.model.send_status.call_args[0][0].beg == Ray.from_number(
1.05)
assert self.model.send_status.call_args[0][
0].guy == self.keeper_address
assert self.model.send_status.call_args[0][0].era > 0
assert self.model.send_status.call_args[0][
0].end > self.model.send_status.call_args[0][0].era + 3600
assert self.model.send_status.call_args[0][
0].tic > self.model.send_status.call_args[0][0].era + 3600
assert self.model.send_status.call_args[0][0].price == Wad.from_number(
15.0)
def test_should_provide_model_with_updated_info_after_somebody_else_bids(
self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.model.send_status.call_count == 1
# when
self.flipper.tend(
1, Wad.from_number(100),
Wad.from_number(1700)).transact(from_address=self.other_address)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.model.send_status.call_count > 1
# and
assert self.model.send_status.call_args[0][0].id == 1
assert self.model.send_status.call_args[0][
0].flipper == self.flipper.address
assert self.model.send_status.call_args[0][0].flapper is None
assert self.model.send_status.call_args[0][0].flopper is None
assert self.model.send_status.call_args[0][0].bid == Wad.from_number(
1700)
assert self.model.send_status.call_args[0][0].lot == Wad.from_number(
100)
assert self.model.send_status.call_args[0][0].tab == Wad.from_number(
5000)
assert self.model.send_status.call_args[0][0].beg == Ray.from_number(
1.05)
assert self.model.send_status.call_args[0][0].guy == self.other_address
assert self.model.send_status.call_args[0][0].era > 0
assert self.model.send_status.call_args[0][
0].end > self.model.send_status.call_args[0][0].era + 3600
assert self.model.send_status.call_args[0][
0].tic > self.model.send_status.call_args[0][0].era + 3600
assert self.model.send_status.call_args[0][0].price == Wad.from_number(
17.0)
def test_should_terminate_model_if_auction_expired_due_to_tau(self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
self.model_factory.create_model.assert_called_once()
self.model.terminate.assert_not_called()
# when
time_travel_by(self.web3, self.flipper.tau() + 5)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
self.model_factory.create_model.assert_called_once()
self.model.terminate.assert_called_once()
def test_should_terminate_model_if_auction_expired_due_to_ttl_and_somebody_else_won_it(
self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
self.model_factory.create_model.assert_called_once()
self.model.terminate.assert_not_called()
# when
self.flipper.tend(
1, Wad.from_number(100),
Wad.from_number(1600)).transact(from_address=self.other_address)
# and
time_travel_by(self.web3, self.flipper.ttl() + 5)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
self.model_factory.create_model.assert_called_once()
self.model.terminate.assert_called_once()
def test_should_terminate_model_if_auction_is_dealt(self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
self.model_factory.create_model.assert_called_once()
self.model.terminate.assert_not_called()
# when
self.flipper.tend(
1, Wad.from_number(100),
Wad.from_number(1600)).transact(from_address=self.other_address)
# and
time_travel_by(self.web3, self.flipper.ttl() + 5)
# and
self.flipper.deal(1).transact(from_address=self.other_address)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
self.model_factory.create_model.assert_called_once()
self.model.terminate.assert_called_once()
def test_should_not_instantiate_model_if_auction_is_dealt(self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# and
self.flipper.tend(
1, Wad.from_number(100),
Wad.from_number(1600)).transact(from_address=self.other_address)
# and
time_travel_by(self.web3, self.flipper.ttl() + 5)
# and
self.flipper.deal(1).transact(from_address=self.other_address)
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
self.model_factory.create_model.assert_not_called()
def test_should_not_do_anything_if_no_output_from_model(self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
previous_block_number = self.web3.eth.blockNumber
# when
# [no output from model]
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.web3.eth.blockNumber == previous_block_number
def test_should_make_initial_bid(self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(16.0))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = self.flipper.bids(1)
assert round(auction.bid / auction.lot,
2) == round(Wad.from_number(16.0), 2)
def test_should_bid_even_if_there_is_already_a_bidder(self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# and
self.flipper.tend(
1, Wad.from_number(100),
Wad.from_number(1600)).transact(from_address=self.other_address)
assert self.flipper.bids(1).bid == Wad.from_number(1600)
# when
self.simulate_model_output(price=Wad.from_number(19.0))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = self.flipper.bids(1)
assert self.flipper.bids(1).bid == Wad.from_number(1900)
assert round(auction.bid / auction.lot,
2) == round(Wad.from_number(19.0), 2)
def test_should_sequentially_tend_and_dent_if_price_takes_us_to_the_dent_phrase(
self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(80.0))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = self.flipper.bids(1)
assert self.flipper.bids(1).bid == Wad.from_number(5000)
assert self.flipper.bids(1).lot == Wad.from_number(100)
assert round(auction.bid / auction.lot,
2) == round(Wad.from_number(50.0), 2)
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = self.flipper.bids(1)
assert self.flipper.bids(1).bid == Wad.from_number(5000)
assert self.flipper.bids(1).lot == Wad.from_number(62.5)
assert round(auction.bid / auction.lot,
2) == round(Wad.from_number(80.0), 2)
def test_should_use_most_up_to_date_price_for_dent_even_if_it_gets_updated_during_tend(
self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(80.0))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = self.flipper.bids(1)
assert self.flipper.bids(1).bid == Wad.from_number(5000)
assert self.flipper.bids(1).lot == Wad.from_number(100)
assert round(auction.bid / auction.lot,
2) == round(Wad.from_number(50.0), 2)
# when
self.simulate_model_output(price=Wad.from_number(100.0))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = self.flipper.bids(1)
assert self.flipper.bids(1).bid == Wad.from_number(5000)
assert self.flipper.bids(1).lot == Wad.from_number(50.0)
assert round(auction.bid / auction.lot,
2) == round(Wad.from_number(100.0), 2)
def test_should_only_tend_if_bid_is_only_slightly_above_tab(self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(50.1))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = self.flipper.bids(1)
assert self.flipper.bids(1).bid == Wad.from_number(5000)
assert self.flipper.bids(1).lot == Wad.from_number(100)
assert round(auction.bid / auction.lot,
2) == round(Wad.from_number(50.0), 2)
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = self.flipper.bids(1)
assert self.flipper.bids(1).bid == Wad.from_number(5000)
assert self.flipper.bids(1).lot == Wad.from_number(100)
assert round(auction.bid / auction.lot,
2) == round(Wad.from_number(50.0), 2)
def test_should_tend_up_to_exactly_tab_if_bid_is_only_slightly_below_tab(
self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(49.99))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = self.flipper.bids(1)
assert self.flipper.bids(1).bid == Wad.from_number(4999)
assert self.flipper.bids(1).lot == Wad.from_number(100)
assert round(auction.bid / auction.lot,
2) == round(Wad.from_number(49.99), 2)
# when
self.simulate_model_output(price=Wad.from_number(50.0))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = self.flipper.bids(1)
assert self.flipper.bids(1).bid == Wad.from_number(5000)
assert self.flipper.bids(1).lot == Wad.from_number(100)
assert round(auction.bid / auction.lot,
2) == round(Wad.from_number(50.0), 2)
def test_should_overbid_itself_if_model_has_updated_the_price(self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(15.0))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.flipper.bids(1).bid == Wad.from_number(1500.0)
# when
self.simulate_model_output(price=Wad.from_number(20.0))
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.flipper.bids(1).bid == Wad.from_number(2000.0)
def test_should_increase_gas_price_of_pending_transactions_if_model_increases_gas_price(
self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(20.0), gas_price=10)
# and
self.start_ignoring_transactions()
# and
self.keeper.check_all_auctions()
# and
time.sleep(5)
# and
self.end_ignoring_transactions()
# and
self.simulate_model_output(price=Wad.from_number(20.0), gas_price=15)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.flipper.bids(1).bid == Wad.from_number(2000.0)
assert self.web3.eth.getBlock(
'latest', full_transactions=True).transactions[0].gasPrice == 15
def test_should_replace_pending_transactions_if_model_raises_bid_and_increases_gas_price(
self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(15.0), gas_price=10)
# and
self.start_ignoring_transactions()
# and
self.keeper.check_all_auctions()
# and
time.sleep(5)
# and
self.end_ignoring_transactions()
# and
self.simulate_model_output(price=Wad.from_number(20.0), gas_price=15)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.flipper.bids(1).bid == Wad.from_number(2000.0)
assert self.web3.eth.getBlock(
'latest', full_transactions=True).transactions[0].gasPrice == 15
def test_should_replace_pending_transactions_if_model_lowers_bid_and_increases_gas_price(
self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(20.0), gas_price=10)
# and
self.start_ignoring_transactions()
# and
self.keeper.check_all_auctions()
# and
time.sleep(5)
# and
self.end_ignoring_transactions()
# and
self.simulate_model_output(price=Wad.from_number(15.0), gas_price=15)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.flipper.bids(1).bid == Wad.from_number(1500.0)
assert self.web3.eth.getBlock(
'latest', full_transactions=True).transactions[0].gasPrice == 15
def test_should_not_tend_on_rounding_errors_with_small_amounts(self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad(5000), Wad(2), Wad(4)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(3.0))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.flipper.bids(1).bid == Wad(6)
# when
tx_count = self.web3.eth.getTransactionCount(
self.keeper_address.address)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.web3.eth.getTransactionCount(
self.keeper_address.address) == tx_count
def test_should_not_dent_on_rounding_errors_with_small_amounts(self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad(5000), Wad(10), Wad(5000)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(1000.0))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.flipper.bids(1).lot == Wad(5)
# when
tx_count = self.web3.eth.getTransactionCount(
self.keeper_address.address)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.web3.eth.getTransactionCount(
self.keeper_address.address) == tx_count
def test_should_deal_when_we_won_the_auction(self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(15.0))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = self.flipper.bids(1)
assert round(auction.bid / auction.lot,
2) == round(Wad.from_number(15.0), 2)
assert self.gem_balance(self.keeper_address) == Wad(0)
# when
time_travel_by(self.web3, self.flipper.ttl() + 5)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.gem_balance(self.keeper_address) > Wad(0)
def test_should_not_deal_when_auction_finished_but_somebody_else_won(self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# and
self.flipper.tend(
1, Wad.from_number(100),
Wad.from_number(1500)).transact(from_address=self.other_address)
assert self.flipper.bids(1).bid == Wad.from_number(1500)
# when
time_travel_by(self.web3, self.flipper.ttl() + 5)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.gem_balance(self.other_address) == Wad(0)
def test_should_obey_gas_price_provided_by_the_model(self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(15.0),
gas_price=175000)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.web3.eth.getBlock(
'latest',
full_transactions=True).transactions[0].gasPrice == 175000
def test_should_use_default_gas_price_if_not_provided_by_the_model(self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(15.0))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.web3.eth.getBlock(
'latest', full_transactions=True
).transactions[0].gasPrice == self.web3.eth.gasPrice
class TestFlipper:
def setup_method(self):
self.web3 = Web3(HTTPProvider("http://localhost:8555"))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.other_address_1 = Address(self.web3.eth.accounts[1])
self.other_address_2 = Address(self.web3.eth.accounts[2])
self.dai = DSToken.deploy(self.web3, 'DAI')
# we need a GemLike version of DSToken with push(bytes32, uint function)
self.gem_addr = Contract._deploy(self.web3, Contract._load_abi(__name__, 'abi/GemMock.abi'), Contract._load_bin(__name__, 'abi/GemMock.bin'), [b'ABC'])
self.gem = DSToken(web3=self.web3, address=self.gem_addr)
self.flipper = Flipper.deploy(self.web3, self.dai.address, self.gem.address)
# Set allowance to allow flipper to move dai and gem
# With full deployment kick is only done by Cat via flip() which take care of allowance via gem.hope()
self.gem.approve(self.flipper.address).transact()
self.gem.approve(self.flipper.address).transact(from_address=self.other_address_1)
self.dai.approve(self.flipper.address).transact()
def dai_balance(self, address: Address) -> Wad:
assert(isinstance(address, Address))
return self.dai.balance_of(address)
def dai_mint(self, amount: Wad):
assert(isinstance(amount, Wad))
assert self.dai.mint(amount).transact()
def gem_balance(self, address: Address) -> Wad:
assert(isinstance(address, Address))
return self.gem.balance_of(address)
def test_beg(self):
assert self.flipper.beg() == Ray.from_number(1.05)
def test_ttl(self):
assert self.flipper.ttl() == 3*60*60 # 3 hours
def test_tau(self):
assert self.flipper.tau() == 2*24*60*60 # 2 days
def test_read(self):
# given
assert self.gem.mint(Wad.from_number(100)).transact()
assert self.gem_balance(self.our_address) == Wad.from_number(100)
# when
assert self.flipper.kick(urn=self.other_address_1,
gal=self.other_address_2,
tab=Wad.from_number(5000),
lot=Wad.from_number(100),
bid=Wad.from_number(100)).transact()
# then
assert self.flipper.kicks() == 1
# and
auction = self.flipper.bids(1)
assert auction.lad == self.other_address_1
assert auction.gal == self.other_address_2
assert auction.bid == Wad.from_number(100)
assert auction.lot == Wad.from_number(100)
assert auction.tab == Wad.from_number(5000)
assert auction.guy == self.our_address
assert auction.tic == 0
assert auction.end > 0
def test_scenario(self):
# given
self.dai_mint(Wad.from_number(100000))
assert self.gem.mint(Wad.from_number(100)).transact()
assert self.gem.transfer(self.other_address_1, Wad.from_number(100)).transact()
assert self.dai_balance(self.our_address) == Wad.from_number(100000)
# when
self.flipper.kick(urn=self.other_address_1,
gal=self.other_address_1,
tab=Wad.from_number(5000),
lot=Wad.from_number(100),
bid=Wad.from_number(1000)).transact(from_address=self.other_address_1)
# then
assert self.dai_balance(self.our_address) == Wad.from_number(100000)
assert self.dai_balance(self.other_address_1) == Wad.from_number(0)
assert self.gem_balance(self.our_address) == Wad.from_number(0)
assert self.gem_balance(self.other_address_1) == Wad.from_number(0)
# when
self.flipper.tend(1, Wad.from_number(100), Wad.from_number(2000)).transact()
assert self.dai_balance(self.our_address) == Wad.from_number(100000) - Wad.from_number(2000)
assert self.dai_balance(self.other_address_1) == Wad.from_number(2000)
assert self.gem_balance(self.our_address) == Wad.from_number(0)
assert self.gem_balance(self.other_address_1) == Wad.from_number(0)
# when
self.flipper.tend(1, Wad.from_number(100), Wad.from_number(5000)).transact()
assert self.dai_balance(self.our_address) == Wad.from_number(100000) - Wad.from_number(5000)
assert self.dai_balance(self.other_address_1) == Wad.from_number(5000)
assert self.gem_balance(self.our_address) == Wad.from_number(0)
assert self.gem_balance(self.other_address_1) == Wad.from_number(0)
# when
self.flipper.dent(1, Wad.from_number(80), Wad.from_number(5000)).transact()
assert self.dai_balance(self.our_address) == Wad.from_number(100000) - Wad.from_number(5000)
assert self.dai_balance(self.other_address_1) == Wad.from_number(5000)
assert self.gem_balance(self.our_address) == Wad.from_number(0)
assert self.gem_balance(self.other_address_1) == Wad.from_number(20)
time_travel_by(self.web3, 60*60*24*8)
# when
self.flipper.deal(1).transact()
assert self.dai_balance(self.our_address) == Wad.from_number(100000) - Wad.from_number(5000)
assert self.dai_balance(self.other_address_1) == Wad.from_number(5000)
assert self.gem_balance(self.our_address) == Wad.from_number(80)
assert self.gem_balance(self.other_address_1) == Wad.from_number(20)
