def test_exchangeFailsNotEnoughNomins(self):
amount = 10 * UNIT
nominsBalance = (int(amount / 2) * self.usdToEthPrice) // UNIT
base = self.nomin.amountReceived(nominsBalance)
feesToPayInNomins = nominsBalance - base
exchanger = self.participantAddresses[0]
startingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
# Set up the contract so it contains some nomins for folks to convert Ether for
self.nomin.giveNomins(MASTER, self.issuanceControllerContract.address,
nominsBalance)
self.assertEqual(
self.nomin.balanceOf(self.issuanceControllerContract.address),
nominsBalance)
# Ensure the transfer fails due to there not being enough nomins in the contract
self.assertReverts(self.issuanceController.exchangeEtherForNomins,
exchanger, amount)
# Ensure the result of the transfer is correct.
endingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
self.assertEqual(
self.nomin.balanceOf(self.issuanceControllerContract.address),
nominsBalance)
self.assertEqual(self.nomin.balanceOf(exchanger), 0)
self.assertEqual(self.nomin.feePool(), 0)
self.assertEqual(startingFundsWalletEthBalance,
endingFundsWalletEthBalance)
def test_cannotExchangeEtherForNominsIfPaused(self):
amount = 10 * UNIT
nominsBalance = (amount * self.usdToEthPrice) // UNIT
base = self.nomin.amountReceived(nominsBalance)
self.issuanceController.setPaused(self.contractOwner, True)
exchanger = self.participantAddresses[0]
startingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
# Set up the contract so it contains some nomins for folks to convert Ether for
self.nomin.giveNomins(MASTER, self.issuanceControllerContract.address,
nominsBalance)
self.assertEqual(
self.nomin.balanceOf(self.issuanceControllerContract.address),
nominsBalance)
# Attmpt transfer
self.assertReverts(self.issuanceController.exchangeEtherForNomins,
exchanger, amount)
endingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
self.assertEqual(
self.nomin.balanceOf(self.issuanceControllerContract.address),
nominsBalance)
self.assertEqual(self.nomin.balanceOf(exchanger), 0)
self.assertEqual(self.nomin.feePool(), 0)
self.assertEqual(startingFundsWalletEthBalance,
endingFundsWalletEthBalance)
def test_exchangeForZeroEth(self):
amount = 3 * UNIT
ethToSend = 0 * UNIT
nominsBalance = (amount * self.usdToEthPrice) // UNIT
nominsToSend = (ethToSend * self.usdToEthPrice) // UNIT
baseToSend = 0
feesToPayInNomins = 0
exchanger = self.participantAddresses[0]
startingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
# Set up the contract so it contains some nomins for folks to convert Ether for
self.nomin.giveNomins(MASTER, self.issuanceControllerContract.address,
nominsBalance)
self.assertEqual(
self.nomin.balanceOf(self.issuanceControllerContract.address),
nominsBalance)
# Transfer the amount to the receiver
txr = self.issuanceController.exchangeEtherForNomins(
exchanger, ethToSend)
# Ensure the result of the transfer is correct.
endingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
self.assertEqual(
self.nomin.balanceOf(self.issuanceControllerContract.address),
nominsBalance)
self.assertEqual(self.nomin.balanceOf(exchanger), 0)
self.assertEqual(self.nomin.feePool(), 0)
self.assertEqual(startingFundsWalletEthBalance,
endingFundsWalletEthBalance)
def test_ensureRateOnEtherToHavvensExchangeSucceedsWithCorrectRate(self):
ethToSend = 1 * UNIT
havvensBalance = 10000 * UNIT
havvensReceived = self.issuanceController.havvensReceivedForEther(
ethToSend)
exchanger = self.participantAddresses[0]
startingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
# Set up the contract so it contains some havvens for folks to convert Ether for
self.havven.endow(MASTER, self.issuanceControllerContract.address,
havvensBalance)
self.assertEqual(
self.havven.balanceOf(self.issuanceControllerContract.address),
havvensBalance)
# The transfer should succeed with a correct rate
txr = self.issuanceController.exchangeEtherForHavvensAtRate(
exchanger, ethToSend, self.usdToEthPrice, self.usdToHavPrice)
# Ensure the result of the transfer is correct.
endingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
self.assertEqual(
self.havven.balanceOf(self.issuanceControllerContract.address),
havvensBalance - havvensReceived)
self.assertEqual(self.havven.balanceOf(exchanger), havvensReceived)
self.assertEqual(startingFundsWalletEthBalance + ethToSend,
endingFundsWalletEthBalance)
def test_cannotExchangeEtherForNominsIfPriceStale(self):
amount = 10 * UNIT
nominsBalance = (amount * self.usdToEthPrice) // UNIT
base = self.nomin.amountReceived(nominsBalance)
self.issuanceController.setPriceStalePeriod(self.contractOwner, 1)
timeSent = block_time()
self.issuanceController.updatePrices(self.oracleAddress,
self.usdToEthPrice,
self.usdToHavPrice, timeSent)
exchanger = self.participantAddresses[0]
startingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
fast_forward(2) # Wait so the lastPriceUpdateTime is different to now
# Set up the contract so it contains some nomins for folks to convert Ether for
self.nomin.giveNomins(MASTER, self.issuanceControllerContract.address,
nominsBalance)
self.assertEqual(
self.nomin.balanceOf(self.issuanceControllerContract.address),
nominsBalance)
# Attmpt transfer
self.assertReverts(self.issuanceController.exchangeEtherForNomins,
exchanger, amount)
endingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
self.assertEqual(
self.nomin.balanceOf(self.issuanceControllerContract.address),
nominsBalance)
self.assertEqual(self.nomin.balanceOf(exchanger), 0)
self.assertEqual(self.nomin.feePool(), 0)
self.assertEqual(startingFundsWalletEthBalance,
endingFundsWalletEthBalance)
def test_exchangeEtherFailsNotEnoughHavvens(self):
havvensBalance = 1 * UNIT
ethToSend = 1 * UNIT
exchanger = self.participantAddresses[0]
startingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
# Set up the contract so it contains some havvens for folks to convert Ether for
self.havven.endow(MASTER, self.issuanceControllerContract.address,
havvensBalance)
self.assertEqual(
self.havven.balanceOf(self.issuanceControllerContract.address),
havvensBalance)
# Ensure the transfer fails due to there not being enough havvens in the contract
self.assertReverts(self.issuanceController.exchangeEtherForHavvens,
exchanger, ethToSend)
# Ensure the result of the transfer is correct.
endingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
self.assertEqual(
self.havven.balanceOf(self.issuanceControllerContract.address),
havvensBalance)
self.assertEqual(self.havven.balanceOf(exchanger), 0)
self.assertEqual(startingFundsWalletEthBalance,
endingFundsWalletEthBalance)
def test_exchangeHavvensForZeroEth(self):
ethToSend = 0
exchanger = self.participantAddresses[0]
havvensBalance = 100000 * UNIT
startingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
# Set up the contract so it contains some havvens for folks to convert Ether for
self.havven.endow(MASTER, self.issuanceControllerContract.address,
havvensBalance)
self.assertEqual(
self.havven.balanceOf(self.issuanceControllerContract.address),
havvensBalance)
# Transfer the amount to the receiver
txr = self.issuanceController.exchangeEtherForHavvens(
exchanger, ethToSend)
# Ensure the result of the transfer is correct.
endingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
self.assertEqual(
self.havven.balanceOf(self.issuanceControllerContract.address),
havvensBalance)
self.assertEqual(self.havven.balanceOf(exchanger), 0)
self.assertEqual(startingFundsWalletEthBalance,
endingFundsWalletEthBalance)
def test_cannotExchangeEtherForHavvensIfPaused(self):
amount = 10 * UNIT
havvenAmount = 10000 * UNIT
exchanger = self.participantAddresses[0]
startingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
# Set up the contract so it contains some havvens for folks to convert Ether for
self.havven.endow(MASTER, self.issuanceControllerContract.address,
havvenAmount)
self.assertEqual(
self.havven.balanceOf(self.issuanceControllerContract.address),
havvenAmount)
# Pause the contract
self.issuanceController.setPaused(self.contractOwner, True)
# Attempt transfer
self.assertReverts(self.issuanceController.exchangeEtherForHavvens,
exchanger, amount)
endingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
self.assertEqual(
self.havven.balanceOf(self.issuanceControllerContract.address),
havvenAmount)
self.assertEqual(self.havven.balanceOf(exchanger), 0)
self.assertEqual(startingFundsWalletEthBalance,
endingFundsWalletEthBalance)
def test_cannotExchangeEtherForHavvensIfPriceStale(self):
amount = 10 * UNIT
havvenAmount = 10000 * UNIT
exchanger = self.participantAddresses[0]
startingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
# Push a price update
self.issuanceController.setPriceStalePeriod(self.contractOwner, 1)
timeSent = block_time()
self.issuanceController.updatePrices(self.oracleAddress,
self.usdToEthPrice,
self.usdToHavPrice, timeSent)
# Wait so the lastPriceUpdateTime is different to now
fast_forward(2)
# Set up the contract so it contains some havvens for folks to convert Ether for
self.havven.endow(MASTER, self.issuanceControllerContract.address,
havvenAmount)
self.assertEqual(
self.havven.balanceOf(self.issuanceControllerContract.address),
havvenAmount)
# Attempt transfer
self.assertReverts(self.issuanceController.exchangeEtherForHavvens,
exchanger, amount)
endingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
self.assertEqual(
self.havven.balanceOf(self.issuanceControllerContract.address),
havvenAmount)
self.assertEqual(self.havven.balanceOf(exchanger), 0)
self.assertEqual(startingFundsWalletEthBalance,
endingFundsWalletEthBalance)
def test_ensureRateOnEtherToNominsExchangeSucceedsWithCorrectRate(self):
amount = 3 * UNIT
ethToSend = 1 * UNIT
nominsBalance = (amount * self.usdToEthPrice) // UNIT
nominsToSend = (ethToSend * self.usdToEthPrice) // UNIT
baseToSend = self.nomin.amountReceived(nominsToSend)
feesToPayInNomins = nominsToSend - baseToSend
exchanger = self.participantAddresses[0]
startingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
# Set up the contract so it contains some nomins for folks to convert Ether for
self.nomin.giveNomins(MASTER, self.issuanceControllerContract.address,
nominsBalance)
self.assertEqual(
self.nomin.balanceOf(self.issuanceControllerContract.address),
nominsBalance)
# The transfer should succeed with a correct rate
txr = self.issuanceController.exchangeEtherForNominsAtRate(
exchanger, ethToSend, self.usdToEthPrice)
# Ensure the result of the transfer is correct.
endingFundsWalletEthBalance = get_eth_balance(self.fundsWallet)
self.assertEqual(
self.nomin.balanceOf(self.issuanceControllerContract.address),
nominsBalance - nominsToSend)
self.assertEqual(self.nomin.balanceOf(exchanger), baseToSend)
self.assertEqual(self.nomin.feePool(), feesToPayInNomins)
self.assertEqual(startingFundsWalletEthBalance + ethToSend,
endingFundsWalletEthBalance)