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 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 setUpClass(cls):
cls.proxy, cls.proxied_token, cls.compiled, cls.token_contract, cls.token_abi, cls.token_event_dict, cls.tokenstate, cls.token_recipient, cls.token_recipient_event_dict, cls.empty_token_recipient, cls.re_entrant_token_recipient = cls.deploy_contracts(
)
cls.event_map = cls.event_maps['ExternStateToken']
cls.token = ExternStateTokenInterface(cls.proxied_token,
"ExternStateToken")
def __init__(self, contract, name):
ExternStateTokenInterface.__init__(self, contract, name)
self.contract = contract
self.contract_name = name
# HAVVEN
# getters
self.feePeriodStartTime = lambda: self.contract.functions.feePeriodStartTime(
).call()
self.lastFeePeriodStartTime = lambda: self.contract.functions.lastFeePeriodStartTime(
).call()
self.feePeriodDuration = lambda: self.contract.functions.feePeriodDuration(
).call()
self.lastFeesCollected = lambda: self.contract.functions.lastFeesCollected(
).call()
self.nomin = lambda: self.contract.functions.nomin().call()
self.escrow = lambda: self.contract.functions.escrow().call()
self.oracle = lambda: self.contract.functions.oracle().call()
self.price = lambda: self.contract.functions.price().call()
self.lastPriceUpdateTime = lambda: self.contract.functions.lastPriceUpdateTime(
).call()
self.priceStalePeriod = lambda: self.contract.functions.priceStalePeriod(
).call()
self.issuanceRatio = lambda: self.contract.functions.issuanceRatio(
).call()
self.priceIsStale = lambda: self.contract.functions.priceIsStale(
).call()
self.hasWithdrawnFees = lambda acc: self.contract.functions.hasWithdrawnFees(
acc).call()
self.isIssuer = lambda acc: self.contract.functions.isIssuer(acc).call(
)
self.nominsIssued = lambda acc: self.contract.functions.nominsIssued(
acc).call()
self.issuanceData = lambda acc: self.contract.functions.issuanceData(
acc).call()
self.totalIssuanceData = lambda: self.contract.functions.totalIssuanceData(
).call()
self.issuanceCurrentBalanceSum = lambda acc: self.contract.functions.issuanceCurrentBalanceSum(
acc).call()
self.issuanceLastAverageBalance = lambda acc: self.contract.functions.issuanceLastAverageBalance(
acc).call()
self.issuanceLastModified = lambda acc: self.contract.functions.issuanceLastModified(
acc).call()
self.totalIssuanceCurrentBalanceSum = lambda: self.contract.functions.totalIssuanceCurrentBalanceSum(
).call()
self.totalIssuanceLastAverageBalance = lambda: self.contract.functions.totalIssuanceLastAverageBalance(
).call()
self.totalIssuanceLastModified = lambda: self.contract.functions.totalIssuanceLastModified(
).call()
self.availableHavvens = lambda acc: self.contract.functions.availableHavvens(
acc).call()
self.lockedHavvens = lambda acc: self.contract.functions.lockedHavvens(
acc).call()
self.maxIssuableNomins = lambda acc: self.contract.functions.maxIssuableNomins(
acc).call()
self.remainingIssuableNomins = lambda acc: self.contract.functions.remainingIssuableNomins(
acc).call()
# utility function
self.havValue = lambda havWei: self.contract.functions.havValue(
havWei).call()
# mutable functions
self.setNomin = lambda sender, addr: mine_tx(
self.contract.functions.setNomin(addr).transact({'from': sender}),
"setNomin", self.contract_name)
self.setEscrow = lambda sender, addr: mine_tx(
self.contract.functions.setEscrow(addr).transact({'from': sender}),
"setEscrow", self.contract_name)
self.setFeePeriodDuration = lambda sender, duration: mine_tx(
self.contract.functions.setFeePeriodDuration(duration).transact(
{'from': sender}), "setFeePeriodDuration", self.contract_name)
self.setOracle = lambda sender, addr: mine_tx(
self.contract.functions.setOracle(addr).transact({'from': sender}),
"setOracle", self.contract_name)
self.setIssuanceRatio = lambda sender, val: mine_tx(
self.contract.functions.setIssuanceRatio(val).transact(
{'from': sender}), "setIssuanceRatio", self.contract_name)
self.setPriceStalePeriod = lambda sender, val: mine_tx(
self.contract.functions.setPriceStalePeriod(val).transact(
{'from': sender}), "setPriceStalePeriod", self.contract_name)
self.endow = lambda sender, to, val: mine_tx(
self.contract.functions.endow(to, val).transact({'from': sender}),
"endow", self.contract_name)
self.setIssuer = lambda sender, acc, val: mine_tx(
self.contract.functions.setIssuer(acc, val).transact(
{'from': sender}), "setIssuer", self.contract_name)
self.transfer = lambda sender, to, val: mine_tx(
self.contract.functions.transfer(to, val).transact(
{'from': sender}), "transfer", self.contract_name)
self.transferFrom = lambda sender, frm, to, val: mine_tx(
self.contract.functions.transferFrom(frm, to, val).transact(
{'from': sender}), "transferFrom", self.contract_name)
self.withdrawFees = lambda sender: mine_tx(
self.contract.functions.withdrawFees().transact({'from': sender}),
"withdrawFees", self.contract_name)
self.recomputeLastAverageBalance = lambda sender, acc: mine_tx(
self.contract.functions.recomputeLastAverageBalance(acc).transact(
{'from': sender}), "recomputeLastAverageBalance", self.
contract_name)
self.rolloverFeePeriodIfElapsed = lambda sender: mine_tx(
self.contract.functions.rolloverFeePeriodIfElapsed().transact(
{'from': sender}), "rolloverFeePeriodIfElapsed", self.
contract_name)
self.issueMaxNomins = lambda sender: mine_tx(
self.contract.functions.issueMaxNomins().transact(
{'from': sender}), "issueMaxNomins", self.contract_name)
self.issueNomins = lambda sender, amt: mine_tx(
self.contract.functions.issueNomins(amt).transact(
{'from': sender}), "issueNomins", self.contract_name)
self.burnNomins = lambda sender, amt: mine_tx(
self.contract.functions.burnNomins(amt).transact({'from': sender}),
"burnNomins", self.contract_name)
self.updatePrice = lambda sender, price, time: mine_tx(
self.contract.functions.updatePrice(price, time).transact(
{'from': sender}), "updatePrice", self.contract_name)