def test_change_state(self): lucky_one = fresh_account() print() # Deploy contract and old tokenstate _old_tokenstate, _ = attempt_deploy(self.compiled, 'TokenState', MASTER, [MASTER, MASTER]) old_tokenstate = TokenStateInterface(_old_tokenstate, 'TokenState') _token, _ = attempt_deploy(self.compiled, 'ExternStateToken', MASTER, [ self.proxy.address, old_tokenstate.contract.address, "Test Token", "TEST", 1000 * UNIT, 18, MASTER ]) token = ExternStateTokenInterface(_token, 'ExternStateToken') mine_txs([ self.proxy.functions.setTarget(token.contract.address).transact( {"from": MASTER}) ]) old_tokenstate.setAssociatedContract(MASTER, token.contract.address) self.assertEqual(token.balanceOf(lucky_one), 0) self.assertEqual(old_tokenstate.balanceOf(lucky_one), 0) # Deploy new tokenstate and swap it out with the existing one. _new_tokenstate, _ = attempt_deploy(self.compiled, 'TokenState', MASTER, [MASTER, MASTER]) new_tokenstate = TokenStateInterface(_new_tokenstate, 'TokenState') new_tokenstate.setBalanceOf(MASTER, lucky_one, UNIT) new_tokenstate.setAssociatedContract(MASTER, token.contract.address) token.setTokenState(MASTER, new_tokenstate.contract.address) self.assertEqual(token.tokenState(), new_tokenstate.contract.address) self.assertEqual(token.balanceOf(lucky_one), UNIT) self.assertEqual(new_tokenstate.balanceOf(lucky_one), UNIT)
def deploy_contracts(cls): sources = [ 'tests/contracts/PublicEST.sol', 'contracts/ExternStateToken.sol', 'contracts/TokenState.sol', 'contracts/Proxy.sol' ] compiled, cls.event_maps = cls.compileAndMapEvents(sources) proxy_contract, _ = attempt_deploy(compiled, "Proxy", MASTER, [MASTER]) tokenstate, _ = attempt_deploy(compiled, 'TokenState', MASTER, [MASTER, MASTER]) token_contract, construction_txr = attempt_deploy( compiled, 'PublicEST', MASTER, [ proxy_contract.address, "Test Token", "TEST", 1000 * UNIT, tokenstate.address, MASTER ]) token_abi = compiled['PublicEST']['abi'] token_event_dict = generate_topic_event_map(token_abi) proxied_token = W3.eth.contract(address=proxy_contract.address, abi=token_abi) mine_txs([ tokenstate.functions.setBalanceOf(MASTER, 1000 * UNIT).transact( {'from': MASTER}), tokenstate.functions.setAssociatedContract( token_contract.address).transact({'from': MASTER}), proxy_contract.functions.setTarget( token_contract.address).transact({'from': MASTER}) ]) return proxy_contract, proxied_token, compiled, token_contract, token_abi, token_event_dict, tokenstate
def test_balance_after_swap(self): sender = self.initial_beneficiary receiver = fresh_account() receiver_balance = self.feetoken.balanceOf(receiver) self.assertEqual(receiver_balance, 0) value = 10 * UNIT amountReceived = self.feetoken.amountReceived(value) fee = value - amountReceived tx_receipt = self.feetoken.transfer(sender, receiver, value) self.assertEqual(self.feetoken.balanceOf(receiver), receiver_balance + amountReceived) self.proxy.setTarget(MASTER, self.feetoken_contract_2.address) self.feestate.setAssociatedContract(MASTER, self.feetoken_contract_2.address) mine_txs([ self.feetoken_contract_2.functions.setTokenState( self.feestate.contract.address).transact({'from': MASTER}) ]) self.assertEqual(self.feetoken.balanceOf(receiver), receiver_balance + amountReceived)
def deployContracts(cls): sources = ["tests/contracts/PublicNomin.sol", "tests/contracts/FakeCourt.sol", "contracts/Havven.sol"] compiled, cls.event_maps = cls.compileAndMapEvents(sources) havven_proxy, _ = attempt_deploy(compiled, 'Proxy', MASTER, [MASTER]) nomin_proxy, _ = attempt_deploy(compiled, 'Proxy', MASTER, [MASTER]) proxied_havven = W3.eth.contract(address=havven_proxy.address, abi=compiled['Havven']['abi']) proxied_nomin = W3.eth.contract(address=nomin_proxy.address, abi=compiled['PublicNomin']['abi']) nomin_state, txr = attempt_deploy( compiled, "TokenState", MASTER, [MASTER, MASTER] ) nomin_contract, _ = attempt_deploy( compiled, 'PublicNomin', MASTER, [nomin_proxy.address, nomin_state.address, MASTER, 0, MASTER] ) havven_contract, _ = attempt_deploy( compiled, "Havven", MASTER, [havven_proxy.address, ZERO_ADDRESS, MASTER, MASTER, UNIT//2, [], ZERO_ADDRESS] ) fake_court, _ = attempt_deploy(compiled, 'FakeCourt', MASTER, []) mine_txs([ nomin_state.functions.setAssociatedContract(nomin_contract.address).transact({'from': MASTER}), havven_proxy.functions.setTarget(havven_contract.address).transact({'from': MASTER}), nomin_proxy.functions.setTarget(nomin_contract.address).transact({'from': MASTER}), havven_contract.functions.setNomin(nomin_contract.address).transact({'from': MASTER}), nomin_contract.functions.setCourt(fake_court.address).transact({'from': MASTER}), nomin_contract.functions.setHavven(havven_contract.address).transact({'from': MASTER}) ]) return havven_proxy, proxied_havven, nomin_proxy, proxied_nomin, nomin_contract, havven_contract, fake_court, nomin_state
def deployContracts(cls): sources = [ "tests/contracts/PublicHavven.sol", "tests/contracts/PublicNomin.sol", "contracts/IssuanceController.sol" ] compiled, cls.event_maps = cls.compileAndMapEvents(sources) nomin_abi = compiled['PublicNomin']['abi'] havven_abi = compiled['PublicHavven']['abi'] issuance_controller_abi = compiled['IssuanceController']['abi'] havven_proxy, _ = attempt_deploy(compiled, 'Proxy', MASTER, [MASTER]) nomin_proxy, _ = attempt_deploy(compiled, 'Proxy', MASTER, [MASTER]) proxied_havven = W3.eth.contract(address=havven_proxy.address, abi=havven_abi) proxied_nomin = W3.eth.contract(address=nomin_proxy.address, abi=nomin_abi) havven_tokenstate, _ = attempt_deploy(compiled, 'TokenState', MASTER, [MASTER, MASTER]) nomin_tokenstate, _ = attempt_deploy(compiled, 'TokenState', MASTER, [MASTER, MASTER]) havven_contract, hvn_txr = attempt_deploy( compiled, 'PublicHavven', MASTER, [ havven_proxy.address, havven_tokenstate.address, MASTER, MASTER, UNIT // 2, [], ZERO_ADDRESS ]) nomin_contract, nom_txr = attempt_deploy( compiled, 'PublicNomin', MASTER, [ nomin_proxy.address, nomin_tokenstate.address, havven_contract.address, 0, MASTER ]) mine_txs([ havven_tokenstate.functions.setBalanceOf( havven_contract.address, 100000000 * UNIT).transact({'from': MASTER}), havven_tokenstate.functions.setAssociatedContract( havven_contract.address).transact({'from': MASTER}), nomin_tokenstate.functions.setAssociatedContract( nomin_contract.address).transact({'from': MASTER}), havven_proxy.functions.setTarget(havven_contract.address).transact( {'from': MASTER}), nomin_proxy.functions.setTarget(nomin_contract.address).transact( {'from': MASTER}), havven_contract.functions.setNomin( nomin_contract.address).transact({'from': MASTER}), ]) issuanceControllerContract, _ = attempt_deploy( compiled, 'IssuanceController', MASTER, [ cls.contractOwner, cls.fundsWallet, havven_contract.address, nomin_contract.address, cls.oracleAddress, cls.usdToEthPrice, cls.usdToHavPrice ]) return havven_proxy, proxied_havven, nomin_proxy, proxied_nomin, havven_contract, nomin_contract, nomin_abi, issuanceControllerContract
def deployContracts(cls): sources = [ "tests/contracts/PublicHavven.sol", "tests/contracts/PublicNomin.sol", "tests/contracts/FakeCourt.sol", "contracts/Havven.sol" ] print("Deployment initiated.\n") compiled, cls.event_maps = cls.compileAndMapEvents(sources) # Deploy contracts havven_proxy, _ = attempt_deploy(compiled, 'Proxy', MASTER, [MASTER]) nomin_proxy, _ = attempt_deploy(compiled, 'Proxy', MASTER, [MASTER]) proxied_havven = W3.eth.contract(address=havven_proxy.address, abi=compiled['PublicHavven']['abi']) proxied_nomin = W3.eth.contract(address=nomin_proxy.address, abi=compiled['PublicNomin']['abi']) havven_tokenstate, _ = attempt_deploy(compiled, 'TokenState', MASTER, [MASTER, MASTER]) nomin_tokenstate, _ = attempt_deploy(compiled, 'TokenState', MASTER, [MASTER, MASTER]) havven_contract, hvn_txr = attempt_deploy( compiled, 'PublicHavven', MASTER, [ havven_proxy.address, havven_tokenstate.address, MASTER, MASTER, UNIT // 2, [], ZERO_ADDRESS ]) nomin_contract, nom_txr = attempt_deploy( compiled, 'PublicNomin', MASTER, [ nomin_proxy.address, nomin_tokenstate.address, havven_contract.address, 0, MASTER ]) court_contract, court_txr = attempt_deploy( compiled, 'FakeCourt', MASTER, [havven_contract.address, nomin_contract.address, MASTER]) # Hook up each of those contracts to each other mine_txs([ havven_tokenstate.functions.setBalanceOf( havven_contract.address, 100000000 * UNIT).transact({'from': MASTER}), havven_tokenstate.functions.setAssociatedContract( havven_contract.address).transact({'from': MASTER}), nomin_tokenstate.functions.setAssociatedContract( nomin_contract.address).transact({'from': MASTER}), havven_proxy.functions.setTarget(havven_contract.address).transact( {'from': MASTER}), nomin_proxy.functions.setTarget(nomin_contract.address).transact( {'from': MASTER}), havven_contract.functions.setNomin( nomin_contract.address).transact({'from': MASTER}), nomin_contract.functions.setCourt(court_contract.address).transact( {'from': MASTER}) ]) print("\nDeployment complete.\n") return havven_proxy, proxied_havven, nomin_proxy, proxied_nomin, havven_contract, nomin_contract, court_contract
def send_value(sender, recipient, value): return mine_txs([ W3.eth.sendTransaction({ 'from': sender, 'to': recipient, 'value': value }) ])
def deployContracts(): sources = [ "tests/contracts/PublicFeeToken.sol", "contracts/FeeToken.sol", "contracts/TokenState.sol" ] compiled = compile_contracts(sources, remappings=['""=contracts']) feetoken_abi = compiled['PublicFeeToken']['abi'] proxy, _ = attempt_deploy(compiled, "Proxy", MASTER, [MASTER]) proxied_feetoken = W3.eth.contract(address=proxy.address, abi=feetoken_abi) feetoken_event_dict = generate_topic_event_map(feetoken_abi) feestate, txr = attempt_deploy(compiled, "TokenState", MASTER, [MASTER, MASTER]) feetoken_contract_1, construction_txr_1 = attempt_deploy( compiled, "PublicFeeToken", MASTER, [ proxy.address, feestate.address, "Test Fee Token", "FEE", 1000 * UNIT, UNIT // 20, MASTER, MASTER ]) feetoken_contract_2, construction_txr_2 = attempt_deploy( compiled, "PublicFeeToken", MASTER, [ proxy.address, feestate.address, "Test Fee Token 2", "FEE", 1000 * UNIT, UNIT // 20, MASTER, MASTER ]) mine_txs([ proxy.functions.setTarget(feetoken_contract_1.address).transact( {'from': MASTER}), feestate.functions.setBalanceOf(DUMMY, 1000 * UNIT).transact( {'from': MASTER}), feestate.functions.setAssociatedContract( feetoken_contract_1.address).transact({'from': MASTER}), feetoken_contract_1.functions.setTokenState( feestate.address).transact({'from': MASTER}) ]) return compiled, proxy, proxied_feetoken, feetoken_contract_1, feetoken_contract_2, feetoken_event_dict, feestate
def test_swap(self): self.assertEqual(self.feetoken.name(), "Test Fee Token") self.assertEqual(self.feetoken.symbol(), "FEE") self.assertEqual(self.feetoken.totalSupply(), 0) self.assertEqual(self.feetoken.transferFeeRate(), UNIT // 20) self.assertEqual(self.feetoken.feeAuthority(), self.fee_authority) self.assertEqual(self.feetoken.tokenState(), self.feestate.contract.address) self.assertEqual(self.feestate.associatedContract(), self.feetoken_contract_1.address) self.proxy.setTarget(MASTER, self.feetoken_contract_2.address) self.feestate.setAssociatedContract(MASTER, self.feetoken_contract_2.address) mine_txs([ self.feetoken_contract_2.functions.setTokenState( self.feestate.contract.address).transact({'from': MASTER}) ]) self.assertEqual(self.feetoken.name(), "Test Fee Token 2") self.assertEqual(self.feetoken.tokenState(), self.feestate.contract.address) self.assertEqual(self.feestate.associatedContract(), self.feetoken_contract_2.address)
def deployContracts(cls): print("Deployment initiated.\n") sources = [ "tests/contracts/PublicHavven.sol", "contracts/Nomin.sol", "contracts/HavvenEscrow.sol" ] compiled, cls.event_maps = cls.compileAndMapEvents(sources) # Deploy contracts havven_proxy, _ = attempt_deploy(compiled, 'Proxy', MASTER, [MASTER]) nomin_proxy, _ = attempt_deploy(compiled, 'Proxy', MASTER, [MASTER]) proxied_havven = W3.eth.contract(address=havven_proxy.address, abi=compiled['PublicHavven']['abi']) proxied_nomin = W3.eth.contract(address=nomin_proxy.address, abi=compiled['Nomin']['abi']) havven_tokenstate, _ = attempt_deploy(compiled, 'TokenState', MASTER, [MASTER, MASTER]) nomin_tokenstate, _ = attempt_deploy(compiled, 'TokenState', MASTER, [MASTER, MASTER]) havven_contract, hvn_txr = attempt_deploy( compiled, 'PublicHavven', MASTER, [ havven_proxy.address, havven_tokenstate.address, MASTER, MASTER, cls.initial_price, [], ZERO_ADDRESS ]) hvn_block = W3.eth.blockNumber nomin_contract, nom_txr = attempt_deploy(compiled, 'Nomin', MASTER, [ nomin_proxy.address, nomin_tokenstate.address, havven_contract.address, 0, MASTER ]) escrow_contract, escrow_txr = attempt_deploy( compiled, 'HavvenEscrow', MASTER, [MASTER, havven_contract.address]) # Hook up each of those contracts to each other mine_txs([ havven_tokenstate.functions.setBalanceOf( havven_contract.address, 100000000 * UNIT).transact({'from': MASTER}), havven_tokenstate.functions.setAssociatedContract( havven_contract.address).transact({'from': MASTER}), nomin_tokenstate.functions.setAssociatedContract( nomin_contract.address).transact({'from': MASTER}), havven_proxy.functions.setTarget(havven_contract.address).transact( {'from': MASTER}), nomin_proxy.functions.setTarget(nomin_contract.address).transact( {'from': MASTER}), havven_contract.functions.setNomin( nomin_contract.address).transact({'from': MASTER}), nomin_contract.functions.setHavven( havven_contract.address).transact({'from': MASTER}), havven_contract.functions.setEscrow( escrow_contract.address).transact({'from': MASTER}) ]) havven_event_dict = generate_topic_event_map( compiled['PublicHavven']['abi']) print("\nDeployment complete.\n") return havven_proxy, proxied_havven, nomin_proxy, proxied_nomin, havven_contract, nomin_contract, escrow_contract, hvn_block, havven_event_dict
def test_constructor_migration(self): # Ensure issuers list updates issued balances properly... update deploycontracts above. sources = [ "tests/contracts/PublicHavven.sol", "contracts/Nomin.sol", "contracts/HavvenEscrow.sol" ] print() compiled, event_maps = self.compileAndMapEvents(sources) # Initial issued nomin balances #issuer_addresses = [f"0x{'0'*39}{i+1}" for i in range(10)] issuers_all = fresh_accounts(54) issuers = issuers_all[:2] issuer_balances = [77 * UNIT * i for i in range(10)] total_nomins = sum(issuer_balances) # Deploy contracts havven_proxy, _ = attempt_deploy(compiled, 'Proxy', MASTER, [MASTER]) nomin_proxy, _ = attempt_deploy(compiled, 'Proxy', MASTER, [MASTER]) proxied_havven = W3.eth.contract(address=havven_proxy.address, abi=compiled['PublicHavven']['abi']) proxied_nomin = W3.eth.contract(address=nomin_proxy.address, abi=compiled['Nomin']['abi']) havven_tokenstate, _ = attempt_deploy(compiled, 'TokenState', MASTER, [MASTER, MASTER]) nomin_tokenstate, _ = attempt_deploy(compiled, 'TokenState', MASTER, [MASTER, MASTER]) havven_contract, hvn_txr = attempt_deploy( compiled, 'PublicHavven', MASTER, [ havven_proxy.address, havven_tokenstate.address, MASTER, MASTER, UNIT, [], ZERO_ADDRESS ]) hvn_block = W3.eth.blockNumber nomin_contract, nom_txr = attempt_deploy(compiled, 'Nomin', MASTER, [ nomin_proxy.address, nomin_tokenstate.address, havven_contract.address, 0, MASTER ]) escrow_contract, escrow_txr = attempt_deploy( compiled, 'HavvenEscrow', MASTER, [MASTER, havven_contract.address]) mine_txs([ havven_tokenstate.functions.setBalanceOf( havven_contract.address, 100000000 * UNIT).transact({'from': MASTER}), havven_tokenstate.functions.setAssociatedContract( havven_contract.address).transact({'from': MASTER}), nomin_tokenstate.functions.setAssociatedContract( nomin_contract.address).transact({'from': MASTER}), havven_proxy.functions.setTarget(havven_contract.address).transact( {'from': MASTER}), nomin_proxy.functions.setTarget(nomin_contract.address).transact( {'from': MASTER}), havven_contract.functions.setNomin( nomin_contract.address).transact({'from': MASTER}), nomin_contract.functions.setHavven( havven_contract.address).transact({'from': MASTER}), havven_contract.functions.setEscrow( escrow_contract.address).transact({'from': MASTER}) ]) havven_event_dict = generate_topic_event_map( compiled['PublicHavven']['abi']) havven = PublicHavvenInterface(proxied_havven, "Havven") nomin = PublicNominInterface(proxied_nomin, "Nomin") for i in range(len(issuers)): issuer = issuers[i] havven.endow(MASTER, issuer, 1000 * UNIT) havven.setIssuer(MASTER, issuer, True) mine_txs([ havven_contract.functions.updatePrice( UNIT, block_time() + 1).transact({'from': MASTER}) ]) havven.issueNomins(issuer, i * 10 * UNIT) fast_forward(havven.feePeriodDuration() // 20) for i in range(len(issuers)): issuer = issuers[i] havven.endow(MASTER, issuer, 1000 * UNIT) havven.setIssuer(MASTER, issuer, True) mine_txs([ havven_contract.functions.updatePrice( UNIT, block_time() + 1).transact({'from': MASTER}) ]) havven.issueNomins(issuer, (len(issuers) - 1 - i) * 5 * UNIT) fast_forward(havven.feePeriodDuration() // 15) new_havven_contract, txr = attempt_deploy( compiled, 'PublicHavven', MASTER, [ havven_proxy.address, havven_tokenstate.address, MASTER, MASTER, UNIT, issuers_all, havven_contract.address ]) new_havven = PublicHavvenInterface(new_havven_contract, "Havven") self.assertEqual(havven.totalIssuanceData(), new_havven.totalIssuanceData()) self.assertEqual(havven.feePeriodStartTime(), new_havven.feePeriodStartTime()) self.assertEqual(havven.lastFeePeriodStartTime(), new_havven.lastFeePeriodStartTime()) for issuer in issuers: self.assertEqual(havven.isIssuer(issuer), new_havven.isIssuer(issuer)) self.assertEqual(havven.issuanceData(issuer), new_havven.issuanceData(issuer)) self.assertEqual(havven.nominsIssued(issuer), new_havven.nominsIssued(issuer))
def test_swap_havven(self): alice, bob = fresh_accounts(2) self.havven.endow(MASTER, self.escrow.contract.address, 200 * UNIT) time = block_time() # Set up escrow schedules for alice and bob to test with. self.escrow.addRegularVestingSchedule(MASTER, alice, time + to_seconds(weeks=52), 100 * UNIT, 4) self.escrow.addRegularVestingSchedule(MASTER, bob, time + to_seconds(weeks=52), 100 * UNIT, 4) # Vest alice's first tranche as usual. fast_forward(to_seconds(weeks=13) + 10) self.escrow.vest(alice) self.assertEqual(self.havven.balanceOf(alice), 25 * UNIT) self.assertEqual(self.havven.balanceOf(self.escrow_contract.address), 175 * UNIT) print() # Deploy the new havven contract, with proxy and all. havven_proxy, _ = attempt_deploy(self.compiled, 'Proxy', MASTER, [MASTER]) havven_contract, _ = attempt_deploy( self.compiled, 'PublicHavven', MASTER, [ havven_proxy.address, self.havven_token_state.address, MASTER, MASTER, UNIT // 2, [], ZERO_ADDRESS ]) proxied_havven = W3.eth.contract( address=havven_proxy.address, abi=self.compiled['PublicHavven']['abi']) new_havven = PublicHavvenInterface(proxied_havven, "Havven") # Connect the contracts together. mine_txs([ self.havven_token_state.functions.setAssociatedContract( havven_contract.address).transact({'from': MASTER}), havven_proxy.functions.setTarget(havven_contract.address).transact( {'from': MASTER}) ]) new_havven.setEscrow(MASTER, self.escrow_contract.address) # This should work if the escrow is pointing at the havven proxy. self.escrow.setHavven(MASTER, proxied_havven.address) # Ensure that the new contract is properly up and running, but with the old state. self.assertEqual(new_havven.balanceOf(alice), 25 * UNIT) self.assertEqual(new_havven.balanceOf(bob), 0) tx = new_havven.transfer(alice, bob, 5 * UNIT) self.assertEqual(new_havven.balanceOf(alice), 20 * UNIT) self.assertEqual(new_havven.balanceOf(bob), 5 * UNIT) self.assertEqual(new_havven.balanceOf(self.escrow_contract.address), 175 * UNIT) # And the event emitted properly, from the proxy. self.assertEventEquals(self.havven_event_dict, tx.logs[0], 'Transfer', fields={ 'from': alice, 'to': bob, 'value': 5 * UNIT }, location=havven_proxy.address) # Vest alice's second tranche, but this time on the new contract. fast_forward(to_seconds(weeks=13) + 10) tx = self.escrow.vest(alice) self.assertEventEquals(self.havven_event_dict, tx.logs[0], 'Transfer', fields={ 'from': self.escrow_contract.address, 'to': alice, 'value': 25 * UNIT }, location=havven_proxy.address) self.assertEventEquals(self.escrow_event_dict, tx.logs[1], 'Vested', fields={ 'beneficiary': alice, 'time': block_time(tx['blockNumber']), 'value': 25 * UNIT }, location=self.escrow_contract.address) self.assertEqual(new_havven.balanceOf(alice), 45 * UNIT) self.assertEqual(new_havven.balanceOf(bob), 5 * UNIT) self.assertEqual(new_havven.balanceOf(self.escrow_contract.address), 150 * UNIT) # The stuff should also work if the escrow is pointing at the underlying havven contract fast_forward(to_seconds(weeks=13) + 10) self.escrow.setHavven(MASTER, havven_contract.address) tx = self.escrow.vest(alice) self.assertEventEquals(self.havven_event_dict, tx.logs[0], 'Transfer', fields={ 'from': self.escrow_contract.address, 'to': alice, 'value': 25 * UNIT }, location=havven_proxy.address) self.assertEventEquals(self.escrow_event_dict, tx.logs[1], 'Vested', fields={ 'beneficiary': alice, 'time': block_time(tx['blockNumber']), 'value': 25 * UNIT }, location=self.escrow_contract.address) self.assertEqual(new_havven.balanceOf(alice), 70 * UNIT) self.assertEqual(new_havven.balanceOf(bob), 5 * UNIT) self.assertEqual(new_havven.balanceOf(self.escrow_contract.address), 125 * UNIT) self.escrow.setHavven(MASTER, proxied_havven.address) fast_forward(to_seconds(weeks=13) + 10) tx = self.escrow.vest(alice) self.assertEqual(new_havven.balanceOf(alice), 95 * UNIT) self.assertEqual(new_havven.balanceOf(bob), 5 * UNIT) self.assertEqual(new_havven.balanceOf(self.escrow_contract.address), 100 * UNIT) # Now verify that vesting still works for bob on the new contract, even though he missed some. tx = self.escrow.vest(bob) self.assertEventEquals(self.havven_event_dict, tx.logs[0], 'Transfer', fields={ 'from': self.escrow_contract.address, 'to': bob, 'value': 100 * UNIT }, location=havven_proxy.address) self.assertEventEquals(self.escrow_event_dict, tx.logs[1], 'Vested', fields={ 'beneficiary': bob, 'time': block_time(tx['blockNumber']), 'value': 100 * UNIT }, location=self.escrow_contract.address) self.assertEqual(new_havven.balanceOf(alice), 95 * UNIT) self.assertEqual(new_havven.balanceOf(bob), 105 * UNIT) self.assertEqual(new_havven.balanceOf(self.escrow_contract.address), 0)