def __init__(self, contract, name):
FeeTokenInterface.__init__(self, contract, name)
self.clearTokens = lambda sender, address: mine_tx(
self.contract.functions.clearTokens(address).transact({"from": sender}), "clearTokens", self.contract_name)
self.giveTokens = lambda sender, address, value: mine_tx(
self.contract.functions.giveTokens(address, value).transact({"from": sender}), "giveTokens", self.contract_name)
def __init__(self, contract, name):
OwnedInterface.__init__(self, contract, name)
self.contract = contract
self.contract_name = name
self.initiationTime = lambda: self.contract.functions.initiationTime(
).call()
self.selfDestructBeneficiary = lambda: self.contract.functions.selfDestructBeneficiary(
).call()
self.selfDestructInitiated = lambda: self.contract.functions.selfDestructInitiated(
).call()
self.SELFDESTRUCT_DELAY = lambda: self.contract.functions.SELFDESTRUCT_DELAY(
).call()
self.setSelfDestructBeneficiary = lambda sender, beneficiary: mine_tx(
self.contract.functions.setSelfDestructBeneficiary(
beneficiary).transact({'from': sender}),
"setSelfDestructBeneficiary", self.contract_name)
self.initiateSelfDestruct = lambda sender: mine_tx(
self.contract.functions.initiateSelfDestruct().transact(
{'from': sender}), "initiateSelfDestruct", self.contract_name)
self.terminateSelfDestruct = lambda sender: mine_tx(
self.contract.functions.terminateSelfDestruct().transact(
{'from': sender}), "terminateSelfDestruct", self.contract_name)
self.selfDestruct = lambda sender: mine_tx(
self.contract.functions.selfDestruct().transact({'from': sender}),
"selfDestruct", self.contract_name)
def __init__(self, contract, name):
CourtInterface.__init__(self, contract, name)
self.contract = contract
self.contract_name = name
self.getHavven = lambda: self.contract.functions._havven().call()
self.getNomin = lambda: self.contract.functions._nomin().call()
self.minStandingBalance = lambda: self.contract.functions.minStandingBalance().call()
self.votingPeriod = lambda: self.contract.functions.votingPeriod().call()
self.MIN_VOTING_PERIOD = lambda: self.contract.functions._MIN_VOTING_PERIOD().call()
self.MAX_VOTING_PERIOD = lambda: self.contract.functions._MAX_VOTING_PERIOD().call()
self.confirmationPeriod = lambda: self.contract.functions.confirmationPeriod().call()
self.MIN_CONFIRMATION_PERIOD = lambda: self.contract.functions._MIN_CONFIRMATION_PERIOD().call()
self.MAX_CONFIRMATION_PERIOD = lambda: self.contract.functions._MAX_CONFIRMATION_PERIOD().call()
self.requiredParticipation = lambda: self.contract.functions.requiredParticipation().call()
self.MIN_REQUIRED_PARTICIPATION = lambda: self.contract.functions._MIN_REQUIRED_PARTICIPATION().call()
self.requiredMajority = lambda: self.contract.functions.requiredMajority().call()
self.MIN_REQUIRED_MAJORITY = lambda: self.contract.functions._MIN_REQUIRED_MAJORITY().call()
self.voteWeight = lambda account, motionID: self.contract.functions._voteWeight(account, motionID).call()
self.nextMotionID = lambda: self.contract.functions._nextMotionID().call()
# Internal
self.setupVote = lambda sender, target: mine_tx(
self.contract.functions.publicSetupVote(target).transact({'from': sender}), "setupVote", self.contract_name)
self.setHavven = lambda sender, addr: mine_tx(
self.contract.functions.setHavven(addr).transact({'from': sender}), "setHavven", self.contract_name)
self.setNomin = lambda sender, addr: mine_tx(
self.contract.functions.setNomin(addr).transact({'from': sender}), "setNomin", self.contract_name)
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 test_setOwner(self):
pre_owner = self.nomin.owner()
new_owner = DUMMY
# Only the owner must be able to set the owner.
self.assertReverts(self.nomin.nominateNewOwner, new_owner, new_owner)
txr = mine_tx(
self.nomin_contract.functions.nominateNewOwner(new_owner).transact(
{'from': pre_owner}), 'nominateNewOwner', 'Nomin')
self.assertEventEquals(self.nomin_event_dict,
txr.logs[0],
'OwnerNominated',
fields={'newOwner': new_owner},
location=self.nomin_contract.address)
txr = mine_tx(
self.nomin_contract.functions.acceptOwnership().transact(
{'from': new_owner}), 'acceptOwnership', 'Nomin')
self.assertEventEquals(self.nomin_event_dict,
txr.logs[0],
'OwnerChanged',
fields={
'oldOwner': pre_owner,
'newOwner': new_owner
},
location=self.nomin_contract.address)
self.assertEqual(self.nomin_contract.functions.owner().call(),
new_owner)
def deploy_public_havven():
print("Deployment initiated.\n")
compiled = attempt(compile_contracts, [SOLIDITY_SOURCES],
"Compiling contracts... ")
# Deploy contracts
havven_contract, hvn_txr = attempt_deploy(compiled, 'PublicHavven', MASTER,
[ZERO_ADDRESS, MASTER])
hvn_block = W3.eth.blockNumber
nomin_contract, nom_txr = attempt_deploy(compiled, 'EtherNomin', MASTER, [
havven_contract.address, MASTER, MASTER, 1000 * UNIT, MASTER,
ZERO_ADDRESS
])
court_contract, court_txr = attempt_deploy(
compiled, 'Court', MASTER,
[havven_contract.address, nomin_contract.address, MASTER])
escrow_contract, escrow_txr = attempt_deploy(
compiled, 'PublicHavvenEscrow', MASTER,
[MASTER, havven_contract.address])
# Install proxies
havven_proxy, _ = attempt_deploy(compiled, 'Proxy', MASTER,
[havven_contract.address, MASTER])
mine_tx(
havven_contract.functions.setProxy(havven_proxy.address).transact(
{'from': MASTER}))
proxy_havven = W3.eth.contract(address=havven_proxy.address,
abi=compiled['PublicHavven']['abi'])
nomin_proxy, _ = attempt_deploy(compiled, 'Proxy', MASTER,
[nomin_contract.address, MASTER])
mine_tx(
nomin_contract.functions.setProxy(nomin_proxy.address).transact(
{'from': MASTER}))
proxy_nomin = W3.eth.contract(address=nomin_proxy.address,
abi=compiled['EtherNomin']['abi'])
# Hook up each of those contracts to each other
txs = [
proxy_havven.functions.setNomin(nomin_contract.address).transact(
{'from': MASTER}),
proxy_nomin.functions.setCourt(court_contract.address).transact(
{'from': MASTER}),
proxy_havven.functions.setEscrow(escrow_contract.address).transact(
{'from': MASTER})
]
attempt(mine_txs, [txs], "Linking contracts... ")
escrow_event_dict = generate_topic_event_map(
compiled['HavvenEscrow']['abi'])
print("\nDeployment complete.\n")
return proxy_havven, proxy_nomin, havven_proxy, nomin_proxy, havven_contract, nomin_contract, court_contract, escrow_contract, hvn_block, escrow_event_dict
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.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}))
def __init__(self, contract, name):
self.contract = contract
self.contract_name = name
self.owner = lambda: self.contract.functions.owner().call()
self.nominatedOwner = lambda: self.contract.functions.nominatedOwner().call()
self.nominateNewOwner = lambda sender, addr: mine_tx(
self.contract.functions.nominateNewOwner(addr).transact({'from': sender}), "nominateNewOwner", self.contract_name)
self.acceptOwnership = lambda sender: mine_tx(
self.contract.functions.acceptOwnership().transact({'from': sender}), "acceptOwnership", self.contract_name)
def __init__(self, contract, name):
StateInterface.__init__(self, contract, name)
self.contract = contract
self.contract_name = name
self.balanceOf = lambda acc: self.contract.functions.balanceOf(
acc).call()
self.allowance = lambda frm, to: self.contract.functions.allowance(
frm, to).call()
self.setAllowance = lambda sender, token_owner, spender, value: mine_tx(
self.contract.functions.setAllowance(token_owner, spender, value).
transact({'from': sender}), "setAllowance", self.contract_name)
self.setBalanceOf = lambda sender, account, value: mine_tx(
self.contract.functions.setBalanceOf(account, value).transact(
{'from': sender}), "setBalanceOf", self.contract_name)
def send_value(sender, recipient, value):
return mine_tx(
W3.eth.sendTransaction({
'from': sender,
'to': recipient,
'value': value
}))
def __init__(self, contract, name):
self.contract = contract
self.contract_name = name
self.owner = lambda: self.contract.functions.owner().call()
self.paused = lambda: self.contract.functions.paused().call()
self.lastPauseTime = lambda: self.contract.functions.lastPauseTime(
).call()
self.getSomeValue = lambda: self.contract.functions.someValue().call()
self.setPaused = lambda sender, paused: mine_tx(
self.contract.functions.setPaused(paused).transact(
{'from': sender}), "setPaused", self.contract_name)
self.setSomeValue = lambda sender, someValue: mine_tx(
self.contract.functions.setSomeValue(someValue).transact(
{'from': sender}), "setSomeValue", self.contract_name)
def __init__(self, contract, name):
NominInterface.__init__(self, contract, name)
self.contract = contract
self.contract_name = name
self.debugEmptyFeePool = lambda sender: mine_tx(
self.contract.functions.debugEmptyFeePool().transact(
{'from': sender}), "debugEmptyFeePool", self.contract_name)
self.debugFreezeAccount = lambda sender, target: mine_tx(
self.contract.functions.debugFreezeAccount(target).transact(
{'from': sender}), "debugFreezeAccount", self.contract_name)
self.giveNomins = lambda sender, target, amount: mine_tx(
self.contract.functions.giveNomins(target, amount).transact(
{'from': sender}), "giveNomins", self.contract_name)
self.clearNomins = lambda sender, target: mine_tx(
self.contract.functions.clearNomins(target).transact(
{'from': sender}), "clearNomins", self.contract_name)
self.generateFees = lambda sender, amt: mine_tx(
self.contract.functions.generateFees(amt).transact(
{'from': sender}), "generateFees", self.contract_name)
self.publicBurn = lambda sender, target, amount: mine_tx(
self.contract.functions.publicBurn(target, amount).transact(
{'from': sender}), "publicBurn", self.contract_name)
self.publicIssue = lambda sender, target, amount: mine_tx(
self.contract.functions.publicIssue(target, amount).transact(
{'from': sender}), "publicIssue", self.contract_name)
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 __init__(self, contract, name):
self.contract = contract
self.contract_name = name
self.setNomin = lambda sender, new_nomin: mine_tx(
self.contract.functions.setNomin(new_nomin).transact({'from': sender}), "setNomin", "FakeCourt")
self.setConfirming = lambda sender, target, status: mine_tx(
self.contract.functions.setConfirming(target, status).transact({'from': sender}), "setConfirming",
"FakeCourt")
self.setVotePasses = lambda sender, target, status: mine_tx(
self.contract.functions.setVotePasses(target, status).transact({'from': sender}), "setVotePasses",
"FakeCourt")
self.setTargetMotionID = lambda sender, target, motionID: mine_tx(
self.contract.functions.setTargetMotionID(target, motionID).transact({'from': sender}), "setTargetMotionID",
"FakeCourt")
self.freezeAndConfiscate = lambda sender, target: mine_tx(
self.contract.functions.freezeAndConfiscate(target).transact({'from': sender}), "freezeAndConfiscate",
"FakeCourt")
def __init__(self, contract, name):
FeeTokenInterface.__init__(self, contract, name)
self.contract = contract
self.contract_name = name
self.havven = lambda: self.contract.functions.havven().call()
self.frozen = lambda address: self.contract.functions.frozen(address
).call()
self.setHavven = lambda sender, address: mine_tx(
self.contract.functions.setHavven(address).transact(
{'from': sender}), "setHavven", self.contract_name)
self.transferPlusFee = lambda value: self.contract.functions.transferPlusFee(
value).call()
self.transferFeeIncurred = lambda value: self.contract.functions.transferFeeIncurred(
value).call()
self.transfer = lambda sender, recipient, value: mine_tx(
self.contract.functions.transfer(recipient, value).transact(
{'from': sender}), "transfer", self.contract_name)
self.transferFrom = lambda sender, frm, to, value: mine_tx(
self.contract.functions.transferFrom(frm, to, value).transact(
{'from': sender}), "transferFrom", self.contract_name)
self.transferSenderPaysFee = lambda sender, recipient, value: mine_tx(
self.contract.functions.transferSenderPaysFee(
recipient, value).transact({'from': sender}),
"transferSenderPaysFee", self.contract_name)
self.transferFromSenderPaysFee = lambda sender, frm, to, value: mine_tx(
self.contract.functions.transferFromSenderPaysFee(
frm, to, value).transact({'from': sender}),
"transferFromSenderPaysFee", self.contract_name)
self.approve = lambda sender, spender, value: mine_tx(
self.contract.functions.approve(spender, value).transact(
{'from': sender}), "approve", self.contract_name)
# onlyOwner
self.unfreezeAccount = lambda sender, target: mine_tx(
self.contract.functions.unfreezeAccount(target).transact(
{'from': sender}), "unfreezeAccount", self.contract_name)
# onlyHavven
self.burn = lambda sender, target, amount: mine_tx(
self.contract.functions.burn(target, amount).transact(
{'from': sender}), "burn", self.contract_name)
self.issue = lambda sender, target, amount: mine_tx(
self.contract.functions.issue(target, amount).transact(
{'from': sender}), "issue", self.contract_name)
def __init__(self, contract, name):
OwnedInterface.__init__(self, contract, name)
self.contract = contract
self.contract_name = name
self.target = lambda: self.contract.functions.target().call()
self.useDELEGATECALL = lambda: self.contract.functions.useDELEGATECALL().call()
self.setTarget = lambda sender, addr: mine_tx(
self.contract.functions.setTarget(addr).transact({'from': sender}), "setTarget", self.contract_name)
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 __init__(self, contract, name):
SafeDecimalMathInterface.__init__(self, contract, name)
SelfDestructibleInterface.__init__(self, contract, name)
self.contract = contract
self.contract_name = name
self.totalSupply = lambda: self.contract.functions.totalSupply().call()
self.tokenState = lambda: self.contract.functions.tokenState().call()
self.name = lambda: self.contract.functions.name().call()
self.symbol = lambda: self.contract.functions.symbol().call()
self.balanceOf = lambda account: self.contract.functions.balanceOf(account).call()
self.allowance = lambda account, spender: self.contract.functions.allowance(account, spender).call()
self.setTokenState = lambda sender, new_state: mine_tx(
self.contract.functions.setTokenState(new_state).transact({'from': sender}), "setTokenState", self.contract_name)
self.transfer = lambda sender, to, value: mine_tx(
self.contract.functions.transfer(to, value).transact({'from': sender}), "transfer", self.contract_name)
self.approve = lambda sender, spender, value: mine_tx(
self.contract.functions.approve(spender, value).transact({'from': sender}), "approve", self.contract_name)
self.transferFrom = lambda sender, frm, to, value: mine_tx(
self.contract.functions.transferFrom(frm, to, value).transact({'from': sender}), "transferFrom", self.contract_name)
def __init__(self, contract, name):
ExternStateTokenInterface.__init__(self, contract, name)
self.contract = contract
self.contract_name = name
self.feePool = lambda: self.contract.functions.feePool().call()
self.feeAuthority = lambda: self.contract.functions.feeAuthority().call()
self.transferFeeRate = lambda: self.contract.functions.transferFeeRate().call()
self.transferFeeIncurred = lambda value: self.contract.functions.transferFeeIncurred(value).call()
self.transferPlusFee = lambda value: self.contract.functions.transferPlusFee(value).call()
self.amountReceived = lambda value: self.contract.functions.amountReceived(value).call()
self.setTransferFeeRate = lambda sender, new_fee_rate: mine_tx(
self.contract.functions.setTransferFeeRate(new_fee_rate).transact({'from': sender}), "setTransferFeeRate", self.contract_name)
self.setFeeAuthority = lambda sender, new_fee_authority: mine_tx(
self.contract.functions.setFeeAuthority(new_fee_authority).transact({'from': sender}), "setFeeAuthority", self.contract_name)
self.transferSenderPaysFee = lambda sender, to, value: mine_tx(
self.contract.functions.transferSenderPaysFee(to, value).transact({'from': sender}), "transferSenderPaysFee", self.contract_name)
self.transferFromSenderPaysFee = lambda sender, frm, to, value: mine_tx(
self.contract.functions.transferFromSenderPaysFee(frm, to, value).transact({'from': sender}), "transferFromSenderPaysFee", self.contract_name)
self.withdrawFees = lambda sender, account, value: mine_tx(
self.contract.functions.withdrawFees(account, value).transact({'from': sender}), "withdrawFees", self.contract_name)
self.donateToFeePool = lambda sender, value: mine_tx(
self.contract.functions.donateToFeePool(value).transact({'from': sender}), "donateToFeePool", self.contract_name)
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 __init__(self, contract, name):
SafeDecimalMathInterface.__init__(self, contract, name)
OwnedInterface.__init__(self, contract, name)
LimitedSetupInterface.__init__(self, contract, name)
self.contract = contract
self.contract_name = name
self.havven = lambda: self.contract.functions.havven().call()
self.vestingSchedules = lambda account, index, i: self.contract.functions.vestingSchedules(
account, index, i).call()
self.numVestingEntries = lambda account: self.contract.functions.numVestingEntries(
account).call()
self.getVestingScheduleEntry = lambda account, index: self.contract.functions.getVestingScheduleEntry(
account, index).call()
self.getVestingTime = lambda account, index: self.contract.functions.getVestingTime(
account, index).call()
self.getVestingQuantity = lambda account, index: self.contract.functions.getVestingQuantity(
account, index).call()
self.totalVestedAccountBalance = lambda account: self.contract.functions.totalVestedAccountBalance(
account).call()
self.totalVestedBalance = lambda: self.contract.functions.totalVestedBalance(
).call()
self.getNextVestingIndex = lambda account: self.contract.functions.getNextVestingIndex(
account).call()
self.getNextVestingEntry = lambda account: self.contract.functions.getNextVestingEntry(
account).call()
self.getNextVestingTime = lambda account: self.contract.functions.getNextVestingTime(
account).call()
self.getNextVestingQuantity = lambda account: self.contract.functions.getNextVestingQuantity(
account).call()
self.balanceOf = lambda account: self.contract.functions.balanceOf(
account).call()
self.setHavven = lambda sender, account: mine_tx(
self.contract.functions.setHavven(account).transact(
{'from': sender}), "setHavven", self.contract_name)
self.purgeAccount = lambda sender, account: mine_tx(
self.contract.functions.purgeAccount(account).transact(
{'from': sender}), "purgeAccount", self.contract_name)
self.withdrawHavvens = lambda sender, quantity: mine_tx(
self.contract.functions.withdrawHavvens(quantity).transact(
{'from': sender}), "withdrawHavvens", self.contract_name)
self.appendVestingEntry = lambda sender, account, time, quantity: mine_tx(
self.contract.functions.appendVestingEntry(
account, time, quantity).transact({'from': sender}),
"appendVestingEntry", self.contract_name)
self.addVestingSchedule = lambda sender, account, times, quantities: mine_tx(
self.contract.functions.addVestingSchedule(
account, times, quantities).transact({'from': sender}),
"addVestingSchedule", self.contract_name)
self.vest = lambda sender: mine_tx(
self.contract.functions.vest().transact({'from': sender}), "vest",
self.contract_name)
def setUpClass(cls):
cls.havven, cls.nomin, cls.havven_proxy, cls.nomin_proxy, cls.havven_real, cls.nomin_real, cls.fake_court = deploy_public_contracts(
)
cls.assertClose = assertClose
cls.assertReverts = assertReverts
fast_forward(weeks=102)
# INHERITED
# OWNED
cls.h_owner = lambda self: self.havven.functions.owner().call()
cls.h_nominateOwner = lambda self, sender, addr: mine_tx(
self.havven.functions.nominateOwner(addr).transact(
{'from': sender}))
cls.h_acceptOwnership = lambda self, sender: mine_tx(
self.havven.functions.acceptOwnership().transact({'from': sender}))
# ExternStateProxyToken (transfer/transferFrom are overwritten)
# totalSupply
cls.h_totalSupply = lambda self: self.havven.functions.totalSupply(
).call()
cls.h_name = lambda self: self.havven.functions.name().call()
cls.h_symbol = lambda self: self.havven.functions.symbol().call()
cls.h_balanceOf = lambda self, a: self.havven.functions.balanceOf(
a).call()
cls.h_allowance = lambda self, owner, spender: self.havven.functions.allowance(
owner, spender).call()
cls.h_approve = lambda self, sender, spender, val: mine_tx(
self.havven.functions.approve(spender, val).transact(
{"from": sender}))
# HAVVEN
# GETTERS
cls.h_currentBalanceSum = lambda self, addr: self.havven.functions._currentBalanceSum(
addr).call()
cls.h_lastAverageBalance = lambda self, addr: self.havven.functions.lastAverageBalance(
addr).call()
cls.h_penultimateAverageBalance = lambda self, addr: self.havven.functions.penultimateAverageBalance(
addr).call()
cls.h_lastTransferTimestamp = lambda self, addr: self.havven.functions._lastTransferTimestamp(
addr).call()
cls.h_hasWithdrawnLastPeriodFees = lambda self, addr: self.havven.functions._hasWithdrawnLastPeriodFees(
addr).call()
cls.h_lastAverageBalanceNeedsRecomputation = lambda self, addr: \
self.havven.functions.lastAverageBalanceNeedsRecomputation(addr).call()
cls.h_feePeriodStartTime = lambda self: self.havven.functions.feePeriodStartTime(
).call()
cls.h_lastFeePeriodStartTime = lambda self: self.havven.functions._lastFeePeriodStartTime(
).call()
cls.h_penultimateFeePeriodStartTime = lambda self: self.havven.functions._penultimateFeePeriodStartTime(
).call()
cls.h_targetFeePeriodDurationSeconds = lambda \
self: self.havven.functions.targetFeePeriodDurationSeconds().call()
cls.h_minFeePeriodDurationSeconds = lambda self: self.havven.functions._minFeePeriodDurationSeconds(
).call()
cls.h_maxFeePeriodDurationSeconds = lambda self: self.havven.functions._maxFeePeriodDurationSeconds(
).call()
cls.h_lastFeesCollected = lambda self: self.havven.functions.lastFeesCollected(
).call()
cls.h_get_nomin = lambda self: self.havven.functions.nomin().call()
#
# SETTERS
cls.h_setNomin = lambda self, sender, addr: mine_tx(
self.havven.functions.setNomin(addr).transact({'from': sender}))
cls.h_setTargetFeePeriodDuration = lambda self, sender, dur: mine_tx(
self.havven.functions.setTargetFeePeriodDuration(dur).transact(
{'from': sender}))
#
# FUNCTIONS
cls.h_endow = lambda self, sender, addr, amt: mine_tx(
self.havven.functions.endow(addr, amt).transact({'from': sender}))
cls.h_transfer = lambda self, sender, addr, amt: mine_tx(
self.havven.functions.transfer(addr, amt).transact(
{'from': sender}))
cls.h_transferFrom = lambda self, sender, frm, to, amt: mine_tx(
self.havven.functions.transferFrom(frm, to, amt).transact(
{'from': sender}))
cls.h_recomputeLastAverageBalance = lambda self, sender: mine_tx(
self.havven.functions.recomputeLastAverageBalance().transact(
{'from': sender}))
cls.h_rolloverFeePeriod = lambda self, sender: mine_tx(
self.havven.functions.rolloverFeePeriod().transact(
{'from': sender}))
#
# INTERNAL
cls.h_adjustFeeEntitlement = lambda self, sender, acc, p_bal: mine_tx(
self.havven.functions._adjustFeeEntitlement(acc, p_bal).transact(
{'from': sender}))
# rolloverFee (ltt->last_transfer_time)
cls.h_rolloverFee = lambda self, sender, acc, ltt, p_bal: mine_tx(
self.havven.functions._rolloverFee(acc, ltt, p_bal).transact(
{'from': sender}))
# withdrawFeeEntitlement
cls.h_withdrawFeeEntitlement = lambda self, sender: mine_tx(
self.havven.functions.withdrawFeeEntitlement().transact(
{'from': sender}))
#
# MODIFIERS
# postCheckFeePeriodRollover
cls.h_checkFeePeriodRollover = lambda self, sender: mine_tx(
self.havven.functions._checkFeePeriodRollover().transact(
{'from': sender}))
cls.fake_court_setNomin = lambda sender, new_nomin: mine_tx(
cls.fake_court.functions.setNomin(new_nomin).transact(
{'from': sender}))
cls.fake_court_setConfirming = lambda sender, target, status: mine_tx(
cls.fake_court.functions.setConfirming(target, status).transact(
{'from': sender}))
cls.fake_court_setVotePasses = lambda sender, target, status: mine_tx(
cls.fake_court.functions.setVotePasses(target, status).transact(
{'from': sender}))
cls.fake_court_confiscateBalance = lambda sender, target: mine_tx(
cls.fake_court.functions.confiscateBalance(target).transact(
{'from': sender}))
cls.fake_court_setNomin(W3.eth.accounts[0], cls.nomin.address)
cls.n_owner = lambda self: cls.nomin.functions.owner().call()
cls.n_oracle = lambda self: cls.nomin.functions.oracle().call()
cls.n_court = lambda self: cls.nomin.functions.court().call()
cls.n_beneficiary = lambda self: cls.nomin.functions.beneficiary(
).call()
cls.n_nominPool = lambda self: cls.nomin.functions.nominPool().call()
cls.n_poolFeeRate = lambda self: cls.nomin.functions.poolFeeRate(
).call()
cls.n_liquidationPeriod = lambda self: cls.nomin.functions.liquidationPeriod(
).call()
cls.n_liquidationTimestamp = lambda self: cls.nomin.functions.liquidationTimestamp(
).call()
cls.n_etherPrice = lambda self: cls.nomin.functions.etherPrice().call()
cls.n_frozen = lambda self, address: cls.nomin.functions.frozen(
address).call()
cls.n_lastPriceUpdate = lambda self: cls.nomin.functions.lastPriceUpdate(
).call()
cls.n_stalePeriod = lambda self: cls.nomin.functions.stalePeriod(
).call()
cls.n_nominateOwner = lambda self, sender, address: mine_tx(
cls.nomin.functions.nominateOwner(address).transact(
{'from': sender}))
cls.n_acceptOwnership = lambda self, sender: mine_tx(
cls.nomin.functions.acceptOwnership().transact({'from': sender}))
cls.n_setOracle = lambda self, sender, address: mine_tx(
cls.nomin.functions.setOracle(address).transact({'from': sender}))
cls.n_setCourt = lambda self, sender, address: mine_tx(
cls.nomin.functions.setCourt(address).transact({'from': sender}))
cls.n_setBeneficiary = lambda self, sender, address: mine_tx(
cls.nomin.functions.setBeneficiary(address).transact(
{'from': sender}))
cls.n_setPoolFeeRate = lambda self, sender, rate: mine_tx(
cls.nomin.functions.setPoolFeeRate(rate).transact({'from': sender})
)
cls.n_updatePrice = lambda self, sender, price, timeSent: mine_tx(
cls.nomin_real.functions.updatePrice(price, timeSent).transact(
{'from': sender}))
cls.n_setStalePeriod = lambda self, sender, period: mine_tx(
cls.nomin.functions.setStalePeriod(period).transact(
{'from': sender}))
cls.n_fiatValue = lambda self, eth: cls.nomin.functions.fiatValue(
eth).call()
cls.n_fiatBalance = lambda self: cls.nomin.functions.fiatBalance(
).call()
cls.n_collateralisationRatio = lambda self: cls.nomin.functions.collateralisationRatio(
).call()
cls.n_etherValue = lambda self, fiat: cls.nomin.functions.etherValue(
fiat).call()
cls.n_etherValueAllowStale = lambda self, fiat: cls.nomin.functions.publicEtherValueAllowStale(
fiat).call()
cls.n_poolFeeIncurred = lambda self, n: cls.nomin.functions.poolFeeIncurred(
n).call()
cls.n_purchaseCostFiat = lambda self, n: cls.nomin.functions.purchaseCostFiat(
n).call()
cls.n_purchaseCostEther = lambda self, n: cls.nomin.functions.purchaseCostEther(
n).call()
cls.n_saleProceedsFiat = lambda self, n: cls.nomin.functions.saleProceedsFiat(
n).call()
cls.n_saleProceedsEther = lambda self, n: cls.nomin.functions.saleProceedsEther(
n).call()
cls.n_saleProceedsEtherAllowStale = lambda self, n: cls.nomin.functions.publicSaleProceedsEtherAllowStale(
n).call()
cls.n_priceIsStale = lambda self: cls.nomin.functions.priceIsStale(
).call()
cls.n_isLiquidating = lambda self: cls.nomin.functions.isLiquidating(
).call()
cls.n_canSelfDestruct = lambda self: cls.nomin.functions.canSelfDestruct(
).call()
cls.n_transferPlusFee = lambda self, value: cls.nomin.functions.transferPlusFee(
value).call()
cls.n_transfer = lambda self, sender, recipient, value: mine_tx(
cls.nomin.functions.transfer(recipient, value).transact(
{'from': sender}))
cls.n_transferFrom = lambda self, sender, fromAccount, to, value: mine_tx(
cls.nomin.functions.transferFrom(fromAccount, to, value).transact(
{'from': sender}))
cls.n_approve = lambda self, sender, spender, value: mine_tx(
cls.nomin.functions.approve(spender, value).transact(
{'from': sender}))
cls.n_replenishPool = lambda self, sender, n, value: mine_tx(
cls.nomin.functions.replenishPool(n).transact({
'from': sender,
'value': value
}))
cls.n_diminishPool = lambda self, sender, n: mine_tx(
cls.nomin.functions.diminishPool(n).transact({'from': sender}))
cls.n_buy = lambda self, sender, n, value: mine_tx(
cls.nomin.functions.buy(n).transact({
'from': sender,
'value': value
}))
cls.n_sell = lambda self, sender, n: mine_tx(
cls.nomin.functions.sell(n).transact({
'from': sender,
'gasPrice': 10
}))
cls.n_forceLiquidation = lambda self, sender: mine_tx(
cls.nomin.functions.forceLiquidation().transact({'from': sender}))
cls.n_liquidate = lambda self, sender: mine_tx(
cls.nomin.functions.liquidate().transact({'from': sender}))
cls.n_extendLiquidationPeriod = lambda self, sender, extension: mine_tx(
cls.nomin.functions.extendLiquidationPeriod(extension).transact(
{'from': sender}))
cls.n_terminateLiquidation = lambda self, sender: mine_tx(
cls.nomin.functions.terminateLiquidation().transact(
{'from': sender}))
cls.n_selfDestruct = lambda self, sender: mine_tx(
cls.nomin.functions.selfDestruct().transact({'from': sender}))
cls.n_confiscateBalance = lambda self, sender, target: mine_tx(
cls.nomin.functions.confiscateBalance(target).transact(
{'from': sender}))
cls.n_unfreezeAccount = lambda self, sender, target: mine_tx(
cls.nomin.functions.unfreezeAccount(target).transact(
{'from': sender}))
cls.n_name = lambda self: cls.nomin.functions.name().call()
cls.n_symbol = lambda self: cls.nomin.functions.symbol().call()
cls.n_totalSupply = lambda self: cls.nomin.functions.totalSupply(
).call()
cls.n_balanceOf = lambda self, account: cls.nomin.functions.balanceOf(
account).call()
cls.n_transferFeeRate = lambda self: cls.nomin.functions.transferFeeRate(
).call()
cls.n_feePool = lambda self: cls.nomin.functions.feePool().call()
cls.n_feeAuthority = lambda self: cls.nomin.functions.feeAuthority(
).call()
cls.n_debugWithdrawAllEther = lambda self, sender, recipient: mine_tx(
cls.nomin.functions.debugWithdrawAllEther(recipient).transact(
{'from': sender}))
cls.n_debugEmptyFeePool = lambda self, sender: mine_tx(
cls.nomin.functions.debugEmptyFeePool().transact({'from': sender}))
cls.n_debugFreezeAccount = lambda self, sender, target: mine_tx(
cls.nomin.functions.debugFreezeAccount(target).transact(
{'from': sender}))
def havven_updatePrice(self, sender, price, time):
return mine_tx(
self.havven_contract.functions.updatePrice(price, time).transact(
{'from': sender}), 'updatePrice', 'Havven')
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 __init__(self, contract, name):
SafeDecimalMathInterface.__init__(self, contract, name)
OwnedInterface.__init__(self, contract, name)
self.contract = contract
self.contract_name = name
# Public variables
self.motionTarget = lambda index: self.contract.functions.motionTarget(index).call()
self.targetMotionID = lambda address: self.contract.functions.targetMotionID(address).call()
self.motionStartTime = lambda account: self.contract.functions.motionStartTime(account).call()
self.votesFor = lambda account: self.contract.functions.votesFor(account).call()
self.votesAgainst = lambda account: self.contract.functions.votesAgainst(account).call()
self.vote = lambda account, motionID: self.contract.functions.vote(account, motionID).call()
# Setters
self.setMinStandingBalance = lambda sender, balance: mine_tx(
self.contract.functions.setMinStandingBalance(balance).transact({'from': sender}), "setMinStandingBalance", self.contract_name)
self.setVotingPeriod = lambda sender, duration: mine_tx(
self.contract.functions.setVotingPeriod(duration).transact({'from': sender}), "setVotingPeriod", self.contract_name)
self.setConfirmationPeriod = lambda sender, duration: mine_tx(
self.contract.functions.setConfirmationPeriod(duration).transact({'from': sender}), "setConfirmationPeriod", self.contract_name)
self.setRequiredParticipation = lambda sender, fraction: mine_tx(
self.contract.functions.setRequiredParticipation(fraction).transact({'from': sender}), "setRequiredParticipation", self.contract_name)
self.setRequiredMajority = lambda sender, fraction: mine_tx(
self.contract.functions.setRequiredMajority(fraction).transact({'from': sender}), "setRequiredMajority", self.contract_name)
# Views
self.hasVoted = lambda sender, motionID: self.contract.functions.hasVoted(sender, motionID).call()
self.motionVoting = lambda target: self.contract.functions.motionVoting(target).call()
self.motionConfirming = lambda target: self.contract.functions.motionConfirming(target).call()
self.motionWaiting = lambda target: self.contract.functions.motionWaiting(target).call()
self.motionPasses = lambda target: self.contract.functions.motionPasses(target).call()
# Mutators
self.beginMotion = lambda sender, target: mine_tx(
self.contract.functions.beginMotion(target).transact({'from': sender}), "beginMotion", self.contract_name)
self.voteFor = lambda sender, target: mine_tx(
self.contract.functions.voteFor(target).transact({'from': sender}), "voteFor", self.contract_name)
self.voteAgainst = lambda sender, target: mine_tx(
self.contract.functions.voteAgainst(target).transact({'from': sender}), "voteAgainst", self.contract_name)
self.cancelVote = lambda sender, target: mine_tx(
self.contract.functions.cancelVote(target).transact({'from': sender}), "cancelVote", self.contract_name)
self.closeMotion = lambda sender, target: mine_tx(
self.contract.functions.closeMotion(target).transact({'from': sender}), "closeMotion", self.contract_name)
# Owner only
self.approveMotion = lambda sender, target: mine_tx(
self.contract.functions.approveMotion(target).transact({'from': sender}), "approveMotion", self.contract_name)
self.vetoMotion = lambda sender, target: mine_tx(
self.contract.functions.vetoMotion(target).transact({'from': sender}), "vetoMotion", self.contract_name)
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}))
def setUpClass(cls):
cls.assertReverts = assertReverts
cls.assertClose = assertClose
cls.havven, cls.nomin, cls.havven_proxy, cls.nomin_proxy, cls.havven_real, cls.nomin_real, cls.court, cls.escrow, cls.construction_block, cls.escrow_event_dict = deploy_public_havven(
)
cls.initial_time = cls.nomin.functions.lastPriceUpdate().call()
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.h_withdrawFeeEntitlement = lambda self, sender: mine_tx(
cls.havven.functions.withdrawFeeEntitlement().transact(
{'from': sender}))
cls.n_updatePrice = lambda self, sender, price, timeSent: mine_tx(
cls.nomin_real.functions.updatePrice(price, timeSent).transact(
{'from': sender}))
cls.n_setTransferFeeRate = lambda self, sender, rate: mine_tx(
cls.nomin.functions.setTransferFeeRate(rate).transact(
{'from': sender}))
cls.n_replenishPool = lambda self, sender, quantity, value: mine_tx(
cls.nomin.functions.replenishPool(quantity).transact({
'from': sender,
'value': value
}))
cls.n_diminishPool = lambda self, sender, quantity: mine_tx(
cls.nomin.functions.diminishPool(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.nominateOwner = lambda self, sender, newOwner: mine_tx(
cls.escrow.functions.nominateOwner(newOwner).transact(
{'from': sender}))
cls.acceptOwnership = lambda self, sender: mine_tx(
cls.escrow.functions.acceptOwnership().transact({'from': sender}))
cls.e_havven = lambda self: cls.escrow.functions.havven().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.setHavven = lambda self, sender, account: mine_tx(
cls.escrow.functions.setHavven(account).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}))
def __init__(self, contract, name):
self.contract = contract
self.contract_name = name
self.priceStalePeriod = lambda: self.contract.functions.priceStalePeriod(
).call()
self.fundsWallet = lambda: self.contract.functions.fundsWallet().call()
self.havven = lambda: self.contract.functions.havven().call()
self.nomin = lambda: self.contract.functions.nomin().call()
self.oracle = lambda: self.contract.functions.oracle().call()
self.owner = lambda: self.contract.functions.owner().call()
self.usdToEthPrice = lambda: self.contract.functions.usdToEthPrice(
).call()
self.usdToHavPrice = lambda: self.contract.functions.usdToHavPrice(
).call()
self.lastPriceUpdateTime = lambda: self.contract.functions.lastPriceUpdateTime(
).call()
self.selfDestructDelay = lambda: self.contract.functions.selfDestructDelay(
).call()
self.selfDestructBeneficiary = lambda: self.contract.functions.selfDestructBeneficiary(
).call()
self.priceStalePeriod = lambda: self.contract.functions.priceStalePeriod(
).call()
self.havvensReceivedForNomins = lambda amount: self.contract.functions.havvensReceivedForNomins(
amount).call()
self.nominsReceivedForEther = lambda amount: self.contract.functions.nominsReceivedForEther(
amount).call()
self.setOracle = lambda sender, newAddress: mine_tx(
self.contract.functions.setOracle(newAddress).transact(
{'from': sender}), "setOracle", self.contract_name)
self.setHavven = lambda sender, newAddress: mine_tx(
self.contract.functions.setHavven(newAddress).transact(
{'from': sender}), "setHavven", self.contract_name)
self.setNomin = lambda sender, newAddress: mine_tx(
self.contract.functions.setNomin(newAddress).transact(
{'from': sender}), "setNomin", self.contract_name)
self.setFundsWallet = lambda sender, newAddress: mine_tx(
self.contract.functions.setFundsWallet(newAddress).transact(
{'from': sender}), "setFundsWallet", self.contract_name)
self.setPriceStalePeriod = lambda sender, newPriceStalePeriod: mine_tx(
self.contract.functions.setPriceStalePeriod(
newPriceStalePeriod).transact({'from': sender}),
"setPriceStalePeriod", self.contract_name)
self.updatePrices = lambda sender, newEthPrice, newHavPrice, timeSent: mine_tx(
self.contract.functions.updatePrices(
newEthPrice, newHavPrice, timeSent).transact({'from': sender}),
"updatePrices", self.contract_name)
self.exchangeEtherForNomins = lambda sender, value: mine_tx(
self.contract.functions.exchangeEtherForNomins().transact(
{
'from': sender,
'value': value
}), "exchangeEtherForNomins", self.contract_name)
self.exchangeNominsForHavvens = lambda sender, value: mine_tx(
self.contract.functions.exchangeNominsForHavvens(value).transact(
{'from': sender}), "exchangeNominsForHavvens", self.
contract_name)
self.withdrawHavvens = lambda sender, value: mine_tx(
self.contract.functions.withdrawHavvens(value).transact(
{'from': sender}), "withdrawHavvens", self.contract_name)
self.withdrawNomins = lambda sender, value: mine_tx(
self.contract.functions.withdrawNomins(value).transact(
{'from': sender}), "withdrawNomins", self.contract_name)
# TODO: Add inherited interface here instead
self.setPaused = lambda sender, paused: mine_tx(
self.contract.functions.setPaused(paused).transact(
{'from': sender}), "setPaused", self.contract_name)
def feetoken_withdrawFees(self, sender, beneficiary, quantity):
return mine_tx(
self.feetoken_contract.functions.withdrawFees(
beneficiary, quantity).transact({'from': sender}),
"withdrawFees", self.feetoken.contract_name)