def test_scenario(self, mcd: DssDeployment, our_address: Address, other_address: Address): isinstance(mcd, DssDeployment) isinstance(our_address, Address) prevBalance = mcd.mkr.balance_of(our_address) amount = Wad.from_number(1000) mint_mkr(mcd.mkr, our_address, amount) assert mcd.mkr.balance_of(our_address) == amount + prevBalance # Lock MKR in DS-Chief assert mcd.mkr.approve(mcd.ds_chief.address).transact(from_address=our_address) assert mcd.ds_chief.lock(amount).transact(from_address=our_address) assert mcd.mkr.balance_of(our_address) == prevBalance # Vote for our address assert mcd.ds_chief.vote_yays([our_address.address]).transact(from_address=our_address) assert mcd.ds_chief.etch([other_address.address]).transact(from_address=our_address) # Confirm that etch(our address) != etch(other address) etches = mcd.ds_chief.past_etch(3) assert etches[0].slate != etches[-1].slate assert mcd.ds_chief.get_approvals(our_address.address) == amount # Lift hat for our address assert mcd.ds_chief.get_hat() != our_address assert mcd.ds_chief.lift(our_address).transact(from_address=our_address) assert mcd.ds_chief.get_hat() == our_address # Now vote for other address assert mcd.ds_chief.vote_etch(etches[-1]).transact(from_address=our_address) assert mcd.ds_chief.lift(other_address).transact(from_address=our_address) assert mcd.ds_chief.get_hat() == other_address
def create_flap_auction(mcd: DssDeployment, deployment_address: Address, our_address: Address): assert isinstance(mcd, DssDeployment) assert isinstance(deployment_address, Address) assert isinstance(our_address, Address) flapper = mcd.flapper print(f"Before Surplus: {mcd.vat.dai(mcd.vow.address)}") create_surplus(mcd, flapper, deployment_address) print(f"After Surplus: {mcd.vat.dai(mcd.vow.address)}") # Kick off the flap auction joy = mcd.vat.dai(mcd.vow.address) assert joy > mcd.vat.sin(mcd.vow.address) + mcd.vow.bump() + mcd.vow.hump() assert (mcd.vat.sin(mcd.vow.address) - mcd.vow.sin()) - mcd.vow.ash() == Rad(0) assert mcd.vow.flap().transact() kick = flapper.kicks() assert kick == 1 assert len(flapper.active_auctions()) == 1 mint_mkr(mcd.mkr, our_address, Wad.from_number(10)) flapper.approve(mcd.mkr.address, directly(from_address=our_address)) bid = Wad.from_number(0.001) assert mcd.mkr.balance_of(our_address) > bid assert flapper.tend(flapper.kicks(), mcd.vow.bump(), bid).transact(from_address=our_address)
def test_scenario(self, web3, mcd, flapper, our_address, other_address, deployment_address): create_surplus(mcd, flapper, deployment_address) joy_before = mcd.vat.dai(mcd.vow.address) # total surplus > total debt + surplus auction lot size + surplus buffer assert joy_before > mcd.vat.sin( mcd.vow.address) + mcd.vow.bump() + mcd.vow.hump() assert (mcd.vat.sin(mcd.vow.address) - mcd.vow.sin()) - mcd.vow.ash() == Rad(0) assert mcd.vow.flap().transact() kick = flapper.kicks() assert kick == 1 assert len(flapper.active_auctions()) == 1 check_active_auctions(flapper) current_bid = flapper.bids(1) assert current_bid.lot > Rad(0) log = self.last_log(flapper) assert isinstance(log, Flapper.KickLog) assert log.id == kick assert log.lot == current_bid.lot assert log.bid == current_bid.bid # Allow the auction to expire, and then resurrect it time_travel_by(web3, flapper.tau() + 1) assert flapper.tick(kick).transact() # Bid on the resurrected auction mint_mkr(mcd.mkr, our_address, Wad.from_number(10)) flapper.approve(mcd.mkr.address, directly(from_address=our_address)) bid = Wad.from_number(0.001) assert mcd.mkr.balance_of(our_address) > bid TestFlapper.tend(flapper, kick, our_address, current_bid.lot, bid) current_bid = flapper.bids(kick) assert current_bid.bid == bid assert current_bid.guy == our_address # Exercise _deal_ after bid has expired time_travel_by(web3, flapper.ttl() + 1) now = datetime.now().timestamp() assert 0 < current_bid.tic < now or current_bid.end < now assert flapper.deal(kick).transact(from_address=our_address) joy_after = mcd.vat.dai(mcd.vow.address) print(f'joy_before={str(joy_before)}, joy_after={str(joy_after)}') assert joy_before - joy_after == mcd.vow.bump() log = self.last_log(flapper) assert isinstance(log, Flapper.DealLog) assert log.usr == our_address assert log.id == kick # Grab our dai mcd.approve_dai(our_address) assert mcd.dai_adapter.exit(our_address, Wad( current_bid.lot)).transact(from_address=our_address) assert mcd.dai.balance_of(our_address) >= Wad(current_bid.lot) assert (mcd.vat.sin(mcd.vow.address) - mcd.vow.sin()) - mcd.vow.ash() == Rad(0)
def mint_approve_lock(mcd: DssDeployment, amount: Wad, address: Address): prevBalance = mcd.mkr.balance_of(address) mint_mkr(mcd.mkr, address, amount) assert mcd.mkr.balance_of(address) == amount + prevBalance # Lock MKR in DS-Chief assert mcd.mkr.approve(mcd.ds_chief.address).transact(from_address=address) assert mcd.ds_chief.lock(amount).transact(from_address=address) assert mcd.mkr.balance_of(address) == prevBalance
def test_check_eta_receipt(self, mcd: DssDeployment, keeper: ChiefKeeper, simpledb: SimpleDatabase, our_address: Address): print_out("test_check_eta_receipt") # clear out anything that came before keeper.check_hat() keeper.check_eta() # Give 1000 MKR to our_address amount = Wad.from_number(5000) mint_mkr(mcd.mkr, our_address, amount) assert mcd.mkr.balance_of(our_address) == amount # Lock MKR in DS-Chief assert mcd.mkr.approve( mcd.ds_chief.address).transact(from_address=our_address) assert mcd.ds_chief.lock(amount).transact(from_address=our_address) # Deploy spell spell = DSSBadSpell.deploy(mcd.web3) # Vote 5000 mkr on the spell assert mcd.ds_chief.vote_yays([spell.address.address ]).transact(from_address=our_address) keeper.check_hat() block = mcd.web3.eth.blockNumber simpledb.update_db_etas(block) hat = mcd.ds_chief.get_hat() etas = keeper.database.db.get(doc_id=3)['upcoming_etas'] verify([hat.address], etas, 1) keeper.check_eta() # Confirm that the spell was casted and that the database was updated # For the DSSBadSpell, the cast() call in non-conformant. Usually # cast() will flip done to true, but in this broken spell it's modified # to not set done to true so we can test this bug and prevent # regressions. assert DSSBadSpell(mcd.web3, Address(hat)).done() == False etas = keeper.database.db.get(doc_id=3)['upcoming_etas'] verify([], etas, 0)
def test_join(self, mcd, our_address): assert mcd.mkr.approve(mcd.esm.address).transact() # This should have no effect yet succeed regardless assert mcd.esm.join(Wad(0)).transact() assert mcd.esm.sum() == Wad(0) assert mcd.esm.sum_of(our_address) == Wad(0) # Ensure the appropriate amount of MKR can be joined mint_mkr(mcd.mkr, our_address, mcd.esm.min()) assert mcd.esm.join(mcd.esm.min()).transact() assert mcd.esm.sum() == mcd.esm.min() # Joining extra MKR should succeed yet have no effect mint_mkr(mcd.mkr, our_address, Wad(153)) assert mcd.esm.join(Wad(153)).transact() assert mcd.esm.sum() == mcd.esm.min() + Wad(153) assert mcd.esm.sum_of(our_address) == mcd.esm.sum()
def prepare_esm(mcd: DssDeployment, our_address: Address): assert mcd.esm is not None assert isinstance(mcd.esm, ShutdownModule) assert isinstance(mcd.esm.address, Address) assert mcd.esm.sum() == Wad(0) assert mcd.esm.min() > Wad(0) assert not mcd.esm.fired() assert mcd.mkr.approve(mcd.esm.address).transact() # This should have no effect yet succeed regardless assert mcd.esm.join(Wad(0)).transact() assert mcd.esm.sum() == Wad(0) assert mcd.esm.sum_of(our_address) == Wad(0) # Mint and join a min amount to call esm.fire mint_mkr(mcd.mkr, our_address, mcd.esm.min()) assert mcd.esm.join(mcd.esm.min()).transact() assert mcd.esm.sum() == mcd.esm.min()
def create_flap_auction(mcd: DssDeployment, deployment_address: Address, our_address: Address): assert isinstance(mcd, DssDeployment) assert isinstance(deployment_address, Address) assert isinstance(our_address, Address) flapper = mcd.flapper create_surplus(mcd, flapper, deployment_address) joy = mcd.vat.dai(mcd.vow.address) assert joy > mcd.vat.sin(mcd.vow.address) + mcd.vow.bump() + mcd.vow.hump() assert (mcd.vat.sin(mcd.vow.address) - mcd.vow.sin()) - mcd.vow.ash() == Rad(0) assert mcd.vow.flap().transact() mint_mkr(mcd.mkr, our_address, Wad.from_number(10)) flapper.approve(mcd.mkr.address, directly(from_address=our_address)) bid = Wad.from_number(0.001) assert mcd.mkr.balance_of(our_address) > bid assert flapper.tend(flapper.kicks(), mcd.vow.bump(), bid).transact(from_address=our_address)
def test_setup(self, mcd: DssDeployment, our_address: Address, guy_address: Address): print_out("test_setup") # Give 1000 MKR to our_address amount = Wad.from_number(1000) mint_mkr(mcd.mkr, our_address, amount) assert mcd.mkr.balance_of(our_address) == amount #Give 2000 MKR to guy_address guyAmount = Wad.from_number(2000) mint_mkr(mcd.mkr, guy_address, guyAmount) assert mcd.mkr.balance_of(guy_address) == guyAmount # Lock MKR in DS-Chief assert mcd.mkr.approve( mcd.ds_chief.address).transact(from_address=our_address) assert mcd.mkr.approve( mcd.ds_chief.address).transact(from_address=guy_address) assert mcd.ds_chief.lock(amount).transact(from_address=our_address) assert mcd.ds_chief.lock(guyAmount).transact(from_address=guy_address) # Deploy spell self.spell = DSSSpell.deploy(mcd.web3, mcd.pause.address, mcd.vat.address) # Vote 1000 mkr on our address and guy_address # Vote 2000 mkr on global spell address assert mcd.ds_chief.vote_yays( [our_address.address, guy_address.address]).transact(from_address=our_address) assert mcd.ds_chief.vote_yays([self.spell.address.address ]).transact(from_address=guy_address) # At this point there are two yays in the chief, one to our_address and the other to the spell address pytest.global_spell = self.spell
# but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <https://www.gnu.org/licenses/>. from web3 import Web3, HTTPProvider import sys from pymaker import Address from pymaker.deployment import DssDeployment from pymaker.keys import register_keys from pymaker.numeric import Wad from tests.test_dss import mint_mkr web3 = Web3(HTTPProvider(endpoint_uri="http://0.0.0.0:8545")) web3.eth.defaultAccount = "0x50FF810797f75f6bfbf2227442e0c961a8562F4C" register_keys(web3, [ "key_file=../lib/pymaker/tests/config/keys/UnlimitedChain/key1.json,pass_file=/dev/null", "key_file=../lib/pymaker/tests/config/keys/UnlimitedChain/key2.json,pass_file=/dev/null", "key_file=../lib/pymaker/tests/config/keys/UnlimitedChain/key3.json,pass_file=/dev/null", "key_file=../lib/pymaker/tests/config/keys/UnlimitedChain/key4.json,pass_file=/dev/null", "key_file=../lib/pymaker/tests/config/keys/UnlimitedChain/key.json,pass_file=/dev/null" ]) mcd = DssDeployment.from_node(web3) mint_mkr(mcd.mkr, Address(sys.argv[1]), Wad.from_number(sys.argv[2])) print( f"MKR balance for {sys.argv[1]} is {mcd.mkr.balance_of(Address(sys.argv[1]))}" )
def test_scenario(self, web3, mcd, flapper, our_address, other_address, deployment_address): joy = mcd.vat.dai(mcd.vow.address) if joy == Rad(0): # Create a CDP with surplus print('Creating a CDP with surplus') collateral = mcd.collaterals['ETH-B'] assert flapper.kicks() == 0 wrap_eth(mcd, deployment_address, Wad.from_number(0.1)) collateral.approve(deployment_address) assert collateral.adapter.join( deployment_address, Wad.from_number(0.1)).transact(from_address=deployment_address) frob(mcd, collateral, deployment_address, dink=Wad.from_number(0.1), dart=Wad.from_number(10)) assert mcd.jug.drip( collateral.ilk).transact(from_address=deployment_address) else: print('Surplus already exists; skipping CDP creation') joy_before = mcd.vat.dai(mcd.vow.address) # total surplus > total debt + surplus auction lot size + surplus buffer assert joy_before > mcd.vat.sin( mcd.vow.address) + mcd.vow.bump() + mcd.vow.hump() assert (mcd.vat.sin(mcd.vow.address) - mcd.vow.sin()) - mcd.vow.ash() == Rad(0) assert mcd.vow.flap().transact() kick = flapper.kicks() assert kick == 1 assert len(flapper.active_auctions()) == 1 current_bid = flapper.bids(1) assert current_bid.lot > Rad(0) # Bid on the surplus mint_mkr(mcd.mkr, deployment_address, our_address, Wad.from_number(10)) flapper.approve(mcd.mkr.address, directly(from_address=our_address)) bid = Wad.from_number(0.001) assert mcd.mkr.balance_of(our_address) > bid TestFlapper.tend(flapper, kick, our_address, current_bid.lot, bid) current_bid = flapper.bids(kick) assert current_bid.bid == bid assert current_bid.guy == our_address # Exercise _deal_ after bid has expired wait(mcd, our_address, flapper.ttl() + 1) now = datetime.now().timestamp() assert 0 < current_bid.tic < now or current_bid.end < now assert flapper.deal(kick).transact(from_address=our_address) joy_after = mcd.vat.dai(mcd.vow.address) print(f'joy_before={str(joy_before)}, joy_after={str(joy_after)}') assert joy_before - joy_after == mcd.vow.bump() # Grab our dai mcd.approve_dai(our_address) assert mcd.dai_adapter.exit(our_address, Wad( current_bid.lot)).transact(from_address=our_address) assert mcd.dai.balance_of(our_address) >= Wad(current_bid.lot) assert (mcd.vat.sin(mcd.vow.address) - mcd.vow.sin()) - mcd.vow.ash() == Rad(0)