def setUpClass(cls):
cls.assertReverts = assertReverts
compiled = compile_contracts([ERC20Token_SOURCE])
cls.erc20_abi = compiled['ERC20Token']['abi']
cls.erc20_event_dict = generate_topic_event_map(cls.erc20_abi)
cls.erc20token, cls.construction_txr = attempt_deploy(
compiled, 'ERC20Token', MASTER,
["Test Token", "TEST", 1000 * UNIT, MASTER])
cls.totalSupply = lambda self: cls.erc20token.functions.totalSupply(
).call()
cls.name = lambda self: cls.erc20token.functions.name().call()
cls.symbol = lambda self: cls.erc20token.functions.symbol().call()
cls.balanceOf = lambda self, account: cls.erc20token.functions.balanceOf(
account).call()
cls.allowance = lambda self, account, spender: cls.erc20token.functions.allowance(
account, spender).call()
cls.transfer = lambda self, sender, to, value: mine_tx(
cls.erc20token.functions.transfer(to, value).transact(
{'from': sender}))
cls.approve = lambda self, sender, spender, value: mine_tx(
cls.erc20token.functions.approve(spender, value).transact(
{'from': sender}))
cls.transferFrom = lambda self, sender, fromAccount, to, value: mine_tx(
cls.erc20token.functions.transferFrom(fromAccount, to, value).
transact({'from': sender}))
def setUpClass(cls):
cls.assertReverts = assertReverts
compiled = compile_contracts([MATH_MODULE_SOURCE],
remappings=['""=contracts'])
cls.math, tx_receipt = attempt_deploy(compiled, 'PublicMath', MASTER,
[])
cls.addIsSafe = lambda self, x, y: cls.math.functions.pubAddIsSafe(
x, y).call()
cls.safeAdd = lambda self, x, y: cls.math.functions.pubSafeAdd(
x, y).call()
cls.subIsSafe = lambda self, x, y: cls.math.functions.pubSubIsSafe(
x, y).call()
cls.safeSub = lambda self, x, y: cls.math.functions.pubSafeSub(
x, y).call()
cls.mulIsSafe = lambda self, x, y: cls.math.functions.pubMulIsSafe(
x, y).call()
cls.safeMul = lambda self, x, y: cls.math.functions.pubSafeMul(
x, y).call()
cls.safeMul_dec = lambda self, x, y: cls.math.functions.pubSafeMul_dec(
x, y).call()
cls.divIsSafe = lambda self, x, y: cls.math.functions.pubDivIsSafe(
x, y).call()
cls.safeDiv = lambda self, x, y: cls.math.functions.pubSafeDiv(
x, y).call()
cls.safeDiv_dec = lambda self, x, y: cls.math.functions.pubSafeDiv_dec(
x, y).call()
cls.intToDec = lambda self, i: cls.math.functions.pubIntToDec(i).call()
def setUpClass(cls):
cls.assertReverts = assertReverts
cls.assertClose = assertClose
compiled = compile_contracts([SD_SOURCE], remappings=['""=contracts'])
cls.sd, txr = attempt_deploy(compiled, 'PayableSD', MASTER,
[MASTER, DUMMY])
cls.owner = lambda self: cls.sd.functions.owner().call()
cls.nominateOwner = lambda self, sender, newOwner: mine_tx(
cls.sd.functions.nominateOwner(newOwner).transact({'from': sender})
)
cls.acceptOwnership = lambda self, sender: mine_tx(
cls.sd.functions.acceptOwnership().transact({'from': sender}))
cls.initiationTime = lambda self: cls.sd.functions.initiationTime(
).call()
cls.beneficiary = lambda self: cls.sd.functions.beneficiary().call()
cls.setBeneficiary = lambda self, sender, beneficiary: mine_tx(
cls.sd.functions.setBeneficiary(beneficiary).transact(
{'from': sender}))
cls.initiateSelfDestruct = lambda self, sender: mine_tx(
cls.sd.functions.initiateSelfDestruct().transact({'from': sender}))
cls.terminateSelfDestruct = lambda self, sender: mine_tx(
cls.sd.functions.terminateSelfDestruct().transact({'from': sender}
))
cls.selfDestruct = lambda self, sender: mine_tx(
cls.sd.functions.selfDestruct().transact({'from': sender}))
send_value(MASTER, cls.sd.address, 10 * UNIT)
def setUpClass(cls):
cls.assertReverts = assertReverts
compiled = compile_contracts([OWNED_SOURCE])
cls.owned, txr = attempt_deploy(compiled, 'Owned', MASTER, [MASTER])
cls.owner = lambda self: cls.owned.functions.owner().call()
cls.setOwner = lambda self, sender, newOwner: mine_tx(cls.owned.functions.setOwner(newOwner).transact({'from': sender}))
def setUpClass(cls):
cls.assertReverts = assertReverts
compiled = compile_contracts([SETUP_SOURCE],
remappings=['""=contracts'])
cls.setup, txr = attempt_deploy(compiled, 'OneWeekSetup', MASTER, [])
cls.contractConstructionTime = block_time(txr.blockNumber)
cls.testFunc = lambda self: cls.setup.functions.testFunc().call()
cls.setupExpiryTime = lambda self: cls.setup.functions.publicSetupExpiryTime().call()
def setUpClass(cls):
cls.assertReverts = assertReverts
cls.the_owner = DUMMY
cls.compiled = compile_contracts(
[ExternStateProxyToken_SOURCE, TokenState_SOURCE, Proxy_SOURCE],
remappings=['""=contracts'])
cls.token_abi = cls.compiled['PublicExternStateProxyToken']['abi']
cls.token_event_dict = generate_topic_event_map(cls.token_abi)
cls.token_real, cls.construction_txr = attempt_deploy(
cls.compiled, 'PublicExternStateProxyToken', MASTER, [
"Test Token", "TEST", 1000 * UNIT, cls.the_owner, ZERO_ADDRESS,
cls.the_owner
])
cls.tokenstate = W3.eth.contract(
address=cls.token_real.functions.state().call(),
abi=cls.compiled['TokenState']['abi'])
mine_tx(
cls.token_real.functions.setState(cls.tokenstate.address).transact(
{'from': cls.the_owner}))
cls.tokenproxy, _ = attempt_deploy(
cls.compiled, 'Proxy', MASTER,
[cls.token_real.address, cls.the_owner])
mine_tx(
cls.token_real.functions.setProxy(cls.tokenproxy.address).transact(
{'from': cls.the_owner}))
cls.token = W3.eth.contract(
address=cls.tokenproxy.address,
abi=cls.compiled['PublicExternStateProxyToken']['abi'])
cls.owner = lambda self: cls.token.functions.owner().call()
cls.totalSupply = lambda self: cls.token.functions.totalSupply().call()
cls.state = lambda self: cls.token.functions.state().call()
cls.name = lambda self: cls.token.functions.name().call()
cls.symbol = lambda self: cls.token.functions.symbol().call()
cls.balanceOf = lambda self, account: cls.token.functions.balanceOf(
account).call()
cls.allowance = lambda self, account, spender: cls.token.functions.allowance(
account, spender).call()
cls.setState = lambda self, sender, new_state: mine_tx(
cls.token.functions.setState(new_state).transact({'from': sender}))
cls.transfer_byProxy = lambda self, sender, to, value: mine_tx(
cls.token.functions.transfer_byProxy(to, value).transact(
{'from': sender}))
cls.approve = lambda self, sender, spender, value: mine_tx(
cls.token.functions.approve(spender, value).transact(
{'from': sender}))
cls.transferFrom_byProxy = lambda self, sender, fromAccount, to, value: mine_tx(
cls.token.functions.transferFrom_byProxy(fromAccount, to, value).
transact({'from': sender}))
def setUpClass(cls):
cls.assertReverts = assertReverts
compiled = compile_contracts([OWNED_SOURCE])
cls.owned, txr = attempt_deploy(compiled, 'Owned', MASTER, [MASTER])
cls.owner = lambda self: cls.owned.functions.owner().call()
cls.nominatedOwner = lambda self: cls.owned.functions.nominatedOwner().call()
cls.nominateOwner = lambda self, sender, newOwner: mine_tx(
cls.owned.functions.nominateOwner(newOwner).transact({'from': sender}))
cls.acceptOwnership = lambda self, sender: mine_tx(
cls.owned.functions.acceptOwnership().transact({'from': sender}))
cls.owned_event_map = generate_topic_event_map(compiled['Owned']['abi'])
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 setUpClass(cls):
cls.assertReverts = assertReverts
cls.compiled = compile_contracts([TokenState_SOURCE],
remappings=['""=contracts'])
cls.owner = MASTER
cls.associate = DUMMY
cls.tokenstate, _ = attempt_deploy(cls.compiled, 'TokenState', MASTER, [cls.owner, cls.associate])
cls.state_owner = lambda self: cls.tokenstate.functions.owner().call()
cls.associatedContract = lambda self: cls.tokenstate.functions.associatedContract().call()
cls.balanceOf = lambda self, acc: cls.tokenstate.functions.balanceOf(acc).call()
cls.allowance = lambda self, frm, to: cls.tokenstate.functions.allowance(frm, to).call()
cls.setAssociatedContract = lambda self, sender, addr: mine_tx(
cls.tokenstate.functions.setAssociatedContract(addr).transact({'from': sender}))
cls.setAllowance = lambda self, sender, tokenOwner, spender, value: mine_tx(
cls.tokenstate.functions.setAllowance(tokenOwner, spender, value).transact({'from': sender}))
cls.setBalanceOf = lambda self, sender, account, value: mine_tx(
cls.tokenstate.functions.setBalanceOf(account, value).transact({'from': sender}))
def setUpClass(cls):
cls.assertReverts = assertReverts
cls.initial_beneficiary, cls.fee_authority, cls.token_owner = fresh_accounts(
3)
cls.compiled = compile_contracts(
[ExternStateProxyFeeToken_SOURCE, Proxy_SOURCE, TokenState_SOURCE],
remappings=['""=contracts'])
cls.feetoken_abi = cls.compiled['PublicExternStateProxyFeeToken'][
'abi']
cls.feetoken_event_dict = generate_topic_event_map(cls.feetoken_abi)
cls.feetoken_real, cls.construction_txr = attempt_deploy(
cls.compiled, "PublicExternStateProxyFeeToken", MASTER, [
"Test Fee Token", "FEE", UNIT // 20, cls.fee_authority,
ZERO_ADDRESS, cls.token_owner
])
cls.feestate, txr = attempt_deploy(cls.compiled, "TokenState", MASTER,
[cls.token_owner, cls.token_owner])
mine_tx(
cls.feestate.functions.setBalanceOf(cls.initial_beneficiary,
1000 * UNIT).transact(
{'from': cls.token_owner}))
mine_tx(
cls.feestate.functions.setAssociatedContract(
cls.feetoken_real.address).transact({'from': cls.token_owner}))
cls.feetoken_proxy, _ = attempt_deploy(
cls.compiled, 'Proxy', MASTER,
[cls.feetoken_real.address, cls.token_owner])
mine_tx(
cls.feetoken_real.functions.setProxy(
cls.feetoken_proxy.address).transact({'from':
cls.token_owner}))
cls.feetoken = W3.eth.contract(
address=cls.feetoken_proxy.address,
abi=cls.compiled['PublicExternStateProxyFeeToken']['abi'])
mine_tx(
cls.feetoken_real.functions.setState(
cls.feestate.address).transact({'from': cls.token_owner}))
cls.owner = lambda self: cls.feetoken.functions.owner().call()
cls.totalSupply = lambda self: cls.feetoken.functions.totalSupply(
).call()
cls.state = lambda self: cls.feetoken.functions.state().call()
cls.name = lambda self: cls.feetoken.functions.name().call()
cls.symbol = lambda self: cls.feetoken.functions.symbol().call()
cls.balanceOf = lambda self, account: self.feetoken.functions.balanceOf(
account).call()
cls.allowance = lambda self, account, spender: self.feetoken.functions.allowance(
account, spender).call()
cls.transferFeeRate = lambda self: cls.feetoken.functions.transferFeeRate(
).call()
cls.maxTransferFeeRate = lambda self: cls.feetoken.functions.maxTransferFeeRate(
).call()
cls.feePool = lambda self: cls.feetoken.functions.feePool().call()
cls.feeAuthority = lambda self: cls.feetoken.functions.feeAuthority(
).call()
cls.transferFeeIncurred = lambda self, value: cls.feetoken.functions.transferFeeIncurred(
value).call()
cls.transferPlusFee = lambda self, value: cls.feetoken.functions.transferPlusFee(
value).call()
cls.priceToSpend = lambda self, value: cls.feetoken.functions.priceToSpend(
value).call()
cls.nominateOwner = lambda self, sender, address: mine_tx(
cls.feetoken.functions.nominateOwner(address).transact(
{'from': sender}))
cls.acceptOwnership = lambda self, sender: mine_tx(
cls.feetoken.functions.acceptOwnership().transact({'from': sender}
))
cls.setTransferFeeRate = lambda self, sender, new_fee_rate: mine_tx(
cls.feetoken.functions.setTransferFeeRate(new_fee_rate).transact(
{'from': sender}))
cls.setFeeAuthority = lambda self, sender, new_fee_authority: mine_tx(
cls.feetoken.functions.setFeeAuthority(new_fee_authority).transact(
{'from': sender}))
cls.setState = lambda self, sender, new_state: mine_tx(
cls.feetoken.functions.setState(new_state).transact(
{'from': sender}))
cls.transfer_byProxy = lambda self, sender, to, value: mine_tx(
cls.feetoken.functions.transfer_byProxy(to, value).transact(
{'from': sender}))
cls.approve = lambda self, sender, spender, value: mine_tx(
cls.feetoken.functions.approve(spender, value).transact(
{'from': sender}))
cls.transferFrom_byProxy = lambda self, sender, fromAccount, to, value: mine_tx(
cls.feetoken.functions.transferFrom_byProxy(
fromAccount, to, value).transact({'from': sender}))
cls.withdrawFee = lambda self, sender, account, value: mine_tx(
cls.feetoken_real.functions.withdrawFee(account, value).transact(
{'from': sender}))
cls.donateToFeePool = lambda self, sender, value: mine_tx(
cls.feetoken.functions.donateToFeePool(value).transact(
{'from': sender}))
cls.debug_messageSender = lambda self: cls.feetoken_real.functions._messageSender(
).call()
cls.debug_optionalProxy = lambda self, sender: mine_tx(
cls.feetoken.functions._optionalProxy_tester().transact(
{'from': sender}))
cls.debug_optionalProxy_direct = lambda self, sender: mine_tx(
cls.feetoken_real.functions._optionalProxy_tester().transact(
{'from': sender}))
def setUpClass(cls):
cls.assertReverts = assertReverts
cls.initial_beneficiary, cls.fee_authority, cls.token_owner = fresh_accounts(
3)
compiled = compile_contracts([ERC20FeeToken_SOURCE])
cls.erc20fee_abi = compiled['ERC20FeeToken']['abi']
cls.erc20fee_event_dict = generate_topic_event_map(cls.erc20fee_abi)
cls.erc20feetoken, cls.construction_txr = attempt_deploy(
compiled, "ERC20FeeToken", MASTER, [
"Test Fee Token", "FEE", 1000 * UNIT, cls.initial_beneficiary,
UNIT // 20, cls.fee_authority, cls.token_owner
])
cls.owner = lambda self: cls.erc20feetoken.functions.owner().call()
cls.totalSupply = lambda self: cls.erc20feetoken.functions.totalSupply(
).call()
cls.name = lambda self: cls.erc20feetoken.functions.name().call()
cls.symbol = lambda self: cls.erc20feetoken.functions.symbol().call()
cls.balanceOf = lambda self, account: self.erc20feetoken.functions.balanceOf(
account).call()
cls.allowance = lambda self, account, spender: self.erc20feetoken.functions.allowance(
account, spender).call()
cls.transferFeeRate = lambda self: cls.erc20feetoken.functions.transferFeeRate(
).call()
cls.maxTransferFeeRate = lambda self: cls.erc20feetoken.functions.maxTransferFeeRate(
).call()
cls.feePool = lambda self: cls.erc20feetoken.functions.feePool().call()
cls.feeAuthority = lambda self: cls.erc20feetoken.functions.feeAuthority(
).call()
cls.transferFeeIncurred = lambda self, value: cls.erc20feetoken.functions.transferFeeIncurred(
value).call()
cls.transferPlusFee = lambda self, value: cls.erc20feetoken.functions.transferPlusFee(
value).call()
cls.setOwner = lambda self, sender, address: mine_tx(
cls.erc20feetoken.functions.setOwner(address).transact(
{'from': sender}))
cls.setTransferFeeRate = lambda self, sender, new_fee_rate: mine_tx(
cls.erc20feetoken.functions.setTransferFeeRate(new_fee_rate).
transact({'from': sender}))
cls.setFeeAuthority = lambda self, sender, new_fee_authority: mine_tx(
cls.erc20feetoken.functions.setFeeAuthority(new_fee_authority).
transact({'from': sender}))
cls.transfer = lambda self, sender, to, value: mine_tx(
cls.erc20feetoken.functions.transfer(to, value).transact(
{'from': sender}))
cls.approve = lambda self, sender, spender, value: mine_tx(
cls.erc20feetoken.functions.approve(spender, value).transact(
{'from': sender}))
cls.transferFrom = lambda self, sender, fromAccount, to, value: mine_tx(
cls.erc20feetoken.functions.transferFrom(fromAccount, to, value).
transact({'from': sender}))
cls.withdrawFee = lambda self, sender, account, value: mine_tx(
cls.erc20feetoken.functions.withdrawFee(account, value).transact(
{'from': sender}))
cls.donateToFeePool = lambda self, sender, value: mine_tx(
cls.erc20feetoken.functions.donateToFeePool(value).transact(
{'from': sender}))
def setUpClass(cls):
cls.assertReverts = assertReverts
cls.assertClose = assertClose
compiled = compile_contracts(
[ESCROW_SOURCE, HAVVEN_SOURCE, NOMIN_SOURCE])
cls.havven, txr = attempt_deploy(compiled, 'Havven', MASTER, [MASTER])
cls.nomin, txr = attempt_deploy(
compiled, 'EtherNomin', MASTER,
[cls.havven.address, MASTER, MASTER, 1000 * 10**18, MASTER])
cls.escrow, txr = attempt_deploy(
compiled, 'HavvenEscrow', MASTER,
[MASTER, cls.havven.address, cls.nomin.address])
mine_tx(
cls.havven.functions.setNomin(cls.nomin.address).transact(
{'from': MASTER}))
mine_tx(
cls.havven.functions.setEscrow(cls.escrow.address).transact(
{'from': MASTER}))
cls.h_totalSupply = lambda self: cls.havven.functions.totalSupply(
).call()
cls.h_targetFeePeriodDurationSeconds = lambda self: cls.havven.functions.targetFeePeriodDurationSeconds(
).call()
cls.h_feePeriodStartTime = lambda self: cls.havven.functions.feePeriodStartTime(
).call()
cls.h_endow = lambda self, sender, receiver, amt: mine_tx(
cls.havven.functions.endow(receiver, amt).transact(
{'from': sender}))
cls.h_balanceOf = lambda self, account: cls.havven.functions.balanceOf(
account).call()
cls.h_transfer = lambda self, sender, receiver, amt: mine_tx(
cls.havven.functions.transfer(receiver, amt).transact(
{'from': sender}))
cls.h_recomputeLastAverageBalance = lambda self, sender: mine_tx(
cls.havven.functions.recomputeLastAverageBalance().transact(
{'from': sender}))
cls.n_updatePrice = lambda self, sender, price: mine_tx(
cls.nomin.functions.updatePrice(price).transact({'from': sender}))
cls.n_setTransferFeeRate = lambda self, sender, rate: mine_tx(
cls.nomin.functions.setTransferFeeRate(rate).transact(
{'from': sender}))
cls.n_issue = lambda self, sender, quantity, value: mine_tx(
cls.nomin.functions.issue(quantity).transact({
'from': sender,
'value': value
}))
cls.n_burn = lambda self, sender, quantity: mine_tx(
cls.nomin.functions.burn(quantity).transact({'from': sender}))
cls.n_buy = lambda self, sender, quantity, value: mine_tx(
cls.nomin.functions.buy(quantity).transact({
'from': sender,
'value': value
}))
cls.n_sell = lambda self, sender, quantity: mine_tx(
cls.nomin.functions.sell(quantity).transact({'from': sender}))
cls.n_purchaseCostEther = lambda self, quantity: cls.nomin.functions.purchaseCostEther(
quantity).call()
cls.n_balanceOf = lambda self, account: cls.nomin.functions.balanceOf(
account).call()
cls.n_transfer = lambda self, sender, recipient, quantity: mine_tx(
cls.nomin.functions.transfer(recipient, quantity).transact(
{'from': sender}))
cls.n_feePool = lambda self: cls.nomin.functions.feePool().call()
cls.n_nominPool = lambda self: cls.nomin.functions.nominPool().call()
cls.n_priceToSpend = lambda self, v: cls.nomin.functions.priceToSpend(
v).call()
cls.owner = lambda self: cls.escrow.functions.owner().call()
cls.setOwner = lambda self, sender, newOwner: mine_tx(
cls.escrow.functions.setOwner(newOwner).transact({'from': sender}))
cls.e_havven = lambda self: cls.escrow.functions.havven().call()
cls.e_nomin = lambda self: cls.escrow.functions.nomin().call()
cls.vestingSchedules = lambda self, account, index, i: cls.escrow.functions.vestingSchedules(
account, index, i).call()
cls.numVestingEntries = lambda self, account: cls.escrow.functions.numVestingEntries(
account).call()
cls.getVestingScheduleEntry = lambda self, account, index: cls.escrow.functions.getVestingScheduleEntry(
account, index).call()
cls.getVestingTime = lambda self, account, index: cls.escrow.functions.getVestingTime(
account, index).call()
cls.getVestingQuantity = lambda self, account, index: cls.escrow.functions.getVestingQuantity(
account, index).call()
cls.totalVestedAccountBalance = lambda self, account: cls.escrow.functions.totalVestedAccountBalance(
account).call()
cls.totalVestedBalance = lambda self: cls.escrow.functions.totalVestedBalance(
).call()
cls.getNextVestingIndex = lambda self, account: cls.escrow.functions.getNextVestingIndex(
account).call()
cls.getNextVestingEntry = lambda self, account: cls.escrow.functions.getNextVestingEntry(
account).call()
cls.getNextVestingTime = lambda self, account: cls.escrow.functions.getNextVestingTime(
account).call()
cls.getNextVestingQuantity = lambda self, account: cls.escrow.functions.getNextVestingQuantity(
account).call()
cls.feePool = lambda self: cls.escrow.functions.feePool().call()
cls.setHavven = lambda self, sender, account: mine_tx(
cls.escrow.functions.setHavven(account).transact({'from': sender}))
cls.setNomin = lambda self, sender, account: mine_tx(
cls.escrow.functions.setNomin(account).transact({'from': sender}))
cls.withdrawFees = lambda self, sender: mine_tx(
cls.escrow.functions.withdrawFees().transact({'from': sender}))
cls.withdrawFeePool = lambda self, sender: mine_tx(
cls.escrow.functions.withdrawFeePool().transact({'from': sender}))
cls.purgeAccount = lambda self, sender, account: mine_tx(
cls.escrow.functions.purgeAccount(account).transact(
{'from': sender}))
cls.withdrawHavvens = lambda self, sender, quantity: mine_tx(
cls.escrow.functions.withdrawHavvens(quantity).transact(
{'from': sender}))
cls.appendVestingEntry = lambda self, sender, account, time, quantity: mine_tx(
cls.escrow.functions.appendVestingEntry(account, time, quantity).
transact({'from': sender}))
cls.addRegularVestingSchedule = lambda self, sender, account, time, quantity, periods: mine_tx(
cls.escrow.functions.addRegularVestingSchedule(
account, time, quantity, periods).transact({'from': sender}))
cls.vest = lambda self, sender: mine_tx(cls.escrow.functions.vest().
transact({'from': sender}))
