def test_good_migration(strategy, chain, Strategy, web3, vault, currency, whale, rando, gov, strategist): # Call this once to seed the strategy with debt vault.addStrategy(strategy, 2**256 - 1, 2**256 - 1, 50, {"from": gov}) amount1 = Wei("50_000 ether") deposit(amount1, whale, currency, vault) amount1 = Wei("500 ether") deposit(amount1, gov, currency, vault) strategy.harvest({"from": gov}) sleep(chain, 10) strategy.harvest({"from": gov}) strategy_debt = vault.strategies(strategy)[4] # totalDebt prior_position = strategy.estimatedTotalAssets() assert strategy_debt > 0 new_strategy = strategist.deploy(Strategy, vault, "", strategy.cToken()) assert vault.strategies(new_strategy)[4] == 0 assert currency.balanceOf(new_strategy) == 0 # Only Governance can migrate with brownie.reverts(): vault.migrateStrategy(strategy, new_strategy, {"from": rando}) vault.migrateStrategy(strategy, new_strategy, {"from": gov}) assert vault.strategies(strategy)[4] == 0 assert vault.strategies(new_strategy)[4] == strategy_debt assert (new_strategy.estimatedTotalAssets() > prior_position * 0.999 or new_strategy.estimatedTotalAssets() < prior_position * 1.001)
def test_strat_emergency_exit_generic(strategy, web3, chain, interface, vault, currency, whale, strategist, gov): deposit_limit = Wei("1000000 ether") vault.addStrategy(strategy, deposit_limit, deposit_limit, 50, {"from": gov}) amount0 = Wei("500 ether") deposit(amount0, whale, currency, vault) amount1 = Wei("50 ether") deposit(amount1, gov, currency, vault) strategy.harvest({"from": gov}) sleep(chain, 31) assert strategy.emergencyExit() == False strategy.setEmergencyExit({"from": gov}) assert strategy.emergencyExit() # genericStateOfStrat(strategy, currency, vault) # genericStateOfVault(vault, currency) ## emergency shutdown strategy.harvest({"from": gov}) assert currency.balanceOf(vault) >= amount0 + amount1 # Emergency shut down + harvest done # genericStateOfStrat(strategy, currency, vault) # genericStateOfVault(vault, currency) # Withdraw All vault.withdraw(vault.balanceOf(gov), {"from": gov})
def test_strat_graceful_exit_generic(strategy, web3, chain, vault, currency, whale, strategist, gov): deposit_limit = Wei("1000000 ether") vault.addStrategy(strategy, deposit_limit, deposit_limit, 50, {"from": gov}) amount0 = Wei("500 ether") deposit(amount0, whale, currency, vault) amount1 = Wei("50 ether") deposit(amount1, gov, currency, vault) strategy.harvest({"from": gov}) sleep(chain, 30) vault.revokeStrategy(strategy, {"from": gov}) # genericStateOfStrat(strategy, currency, vault) # genericStateOfVault(vault, currency) ## emergency shutdown strategy.harvest({"from": gov}) strategy.harvest({"from": gov}) assert currency.balanceOf(vault) >= amount0 + amount1
def test_apr_generic(strategy, web3, chain, vault, currency, whale, strategist, gov): deposit_limit = Wei("1000000 ether") vault.setDepositLimit(deposit_limit, {"from": gov}) vault.addStrategy(strategy, 10_000, 0, 2 ** 256 - 1, 50, {"from": gov}) deposit_amount = Wei("1000 ether") deposit(deposit_amount, whale, currency, vault) # invest strategy.harvest({"from": gov}) startingBalance = vault.totalAssets() for i in range(2): waitBlock = 25 print(f"\n----wait {waitBlock} blocks----") sleep(chain, waitBlock) strategy.harvest({"from": strategist}) profit = (vault.totalAssets() - startingBalance).to("ether") strState = vault.strategies(strategy).dict() totalReturns = strState["totalGain"] totaleth = totalReturns.to("ether") difff = profit - totaleth blocks_per_year = 2_300_000 assert startingBalance != 0 time = (i + 1) * waitBlock assert time != 0 apr = (totalReturns / startingBalance) * (blocks_per_year / time) print(apr) print(f"implied apr: {apr:.8%}") vault.withdraw(vault.balanceOf(whale), {"from": whale})
def test_strat_emergency_exit_generic( strategy, web3, chain, vault, currency, whale, strategist, gov ): deposit_limit = Wei("1000000 ether") vault.setDepositLimit(deposit_limit, {"from": gov}) vault.addStrategy(strategy, 10_000, 0, 2 ** 256 - 1, 50, {"from": gov}) amount0 = Wei("500 ether") deposit(amount0, whale, currency, vault) amount1 = Wei("50 ether") deposit(amount1, gov, currency, vault) strategy.harvest({"from": gov}) sleep(chain, 30) assert strategy.emergencyExit() == False strategy.setEmergencyExit({"from": gov}) assert strategy.emergencyExit() ## emergency shutdown strategy.harvest({"from": gov}) assert currency.balanceOf(vault) >= amount0 + amount1 # Withdraw All vault.withdraw(vault.balanceOf(gov), {"from": gov})
def test_vault_emergency_exit_generic( strategy, web3, chain, vault, currency, whale, strategist, gov ): deposit_limit = Wei("1000000 ether") vault.setDepositLimit(deposit_limit, {"from": gov}) vault.addStrategy(strategy, 10_000, 0, 2 ** 256 - 1, 50, {"from": gov}) amount0 = Wei("500 ether") deposit(amount0, whale, currency, vault) amount1 = Wei("50 ether") deposit(amount1, gov, currency, vault) strategy.harvest({"from": gov}) sleep(chain, 30) assert vault.emergencyShutdown() == False vault.setEmergencyShutdown(True, {"from": gov}) assert vault.emergencyShutdown() ## emergency shutdown strategy.harvest({"from": gov}) strategy.harvest({"from": gov}) assert currency.balanceOf(vault) > amount0 + amount1 assert strategy.estimatedTotalAssets() < Wei("0.01 ether") # Restore power vault.setEmergencyShutdown(False, {"from": gov}) strategy.harvest({"from": gov}) assert strategy.estimatedTotalAssets() > amount0 + amount1 assert currency.balanceOf(vault) == 0 # Withdraw All vault.withdraw(vault.balanceOf(gov), {"from": gov})
def test_vault_shares_generic( strategy, web3, chain, vault, currency, whale, strategist, gov ): deposit_limit = Wei("1000 ether") # set limit to the vault vault.setDepositLimit(deposit_limit, {"from": gov}) vault.addStrategy(strategy, 10_000, 0, 2 ** 256 - 1, 0, {"from": gov}) print(currency) assert vault.totalSupply() == 0 amount1 = Wei("50 ether") deposit(amount1, whale, currency, vault) whale_share = vault.balanceOf(whale) deposit(amount1, gov, currency, vault) gov_share = vault.balanceOf(gov) assert gov_share == whale_share assert vault.pricePerShare() == 1e18 assert vault.pricePerShare() * whale_share / 1e18 == amount1 assert vault.pricePerShare() * whale_share / 1e18 == vault.totalAssets() / 2 assert gov_share == whale_share strategy.harvest({"from": gov}) chain.mine(2) chain.sleep(2) strategy.harvest({"from": gov}) # no profit yet whale_share = vault.balanceOf(whale) gov_share = vault.balanceOf(gov) assert gov_share > whale_share sleep(chain, 100) whale_share = vault.balanceOf(whale) gov_share = vault.balanceOf(gov) # no profit just aum fee. meaning total balance should be the same assert (gov_share + whale_share) * vault.pricePerShare() / 1e18 == 100 * 1e18 strategy.harvest({"from": gov}) whale_share = vault.balanceOf(whale) gov_share = vault.balanceOf(gov) # add strategy return assert vault.totalSupply() == whale_share + gov_share value = (gov_share + whale_share) * vault.pricePerShare() / 1e18 assert ( value * 0.99999 < vault.totalAssets() and value * 1.00001 > vault.totalAssets() ) # check we are within 0.1% of expected returns assert ( value < strategy.estimatedTotalAssets() * 1.001 and value > strategy.estimatedTotalAssets() * 0.999 ) assert gov_share > whale_share
def test_apr_generic(strategy, web3, chain, vault, currency, whale, strategist, gov): deposit_limit = Wei("1000000 ether") vault.addStrategy(strategy, deposit_limit, deposit_limit, 50, {"from": gov}) deposit_amount = Wei("1000 ether") deposit(deposit_amount, whale, currency, vault) # invest strategy.harvest({"from": gov}) startingBalance = vault.totalAssets() # genericStateOfStrat(strategy, currency, vault) # genericStateOfVault(vault, currency) for i in range(2): waitBlock = 25 print(f"\n----wait {waitBlock} blocks----") sleep(chain, waitBlock) strategy.harvest({"from": strategist}) # genericStateOfStrat(strategy, currency, vault) # genericStateOfVault(vault, currency) profit = (vault.totalAssets() - startingBalance).to("ether") strState = vault.strategies(strategy) totalReturns = strState[6] totaleth = totalReturns.to("ether") # print(f'Real Profit: {profit:.5f}') difff = profit - totaleth # print(f'Diff: {difff}') blocks_per_year = 2_300_000 assert startingBalance != 0 time = (i + 1) * waitBlock assert time != 0 apr = (totalReturns / startingBalance) * (blocks_per_year / time) print(apr) print(f"implied apr: {apr:.8%}") vault.withdraw(vault.balanceOf(whale), {"from": whale})
def test_apr_generic(strategy, web3, chain, vault, currency, whale, interface, strategist, gov): dai = currency deposit_limit = Wei('100_000_000 ether') vault.addStrategy(strategy, deposit_limit, deposit_limit, 50, {"from": gov}) deposit_amount = Wei('10_000_000 ether') deposit(deposit_amount, whale, currency, vault) #invest strategy.harvest({'from': gov}) strategy.setProfitFactor(1, {"from": strategist}) strategy.setMinCompToSell(1, {"from": gov}) strategy.setMinWant(0, {"from": gov}) startingBalance = vault.totalAssets() genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) for i in range(10): waitBlock = 25 print(f'\n----wait {waitBlock} blocks----') sleep(chain, waitBlock) strategy.harvest({'from': strategist}) profit = (vault.totalAssets() - startingBalance).to('ether') strState = vault.strategies(strategy) totalReturns = strState[6] totaleth = totalReturns.to('ether') print(f'Real Profit: {profit:.5f}') difff = profit - totaleth print(f'Diff: {difff}') blocks_per_year = 2_300_000 assert startingBalance != 0 time = (i + 1) * waitBlock assert time != 0 apr = (totalReturns / startingBalance) * (blocks_per_year / time) print(f'implied apr: {apr:.8%}') vault.withdraw(vault.balanceOf(whale), {'from': whale})
def test_vault_emergency_exit_generic(strategy, web3, chain, interface, vault, currency, whale, strategist, gov): deposit_limit = Wei("1000000 ether") vault.addStrategy(strategy, deposit_limit, deposit_limit, 50, {"from": gov}) amount0 = Wei("500 ether") deposit(amount0, whale, currency, vault) amount1 = Wei("50 ether") deposit(amount1, gov, currency, vault) strategy.harvest({"from": gov}) sleep(chain, 30) assert vault.emergencyShutdown() == False vault.setEmergencyShutdown(True, {"from": gov}) assert vault.emergencyShutdown() # genericStateOfStrat(strategy, currency, vault) # genericStateOfVault(vault, currency) ## emergency shutdown # stateOfStrat(strategy, interface) strategy.harvest({"from": gov}) # stateOfStrat(strategy, interface) strategy.harvest({"from": gov}) assert currency.balanceOf(vault) > amount0 + amount1 assert strategy.estimatedTotalAssets() < Wei("0.01 ether") # Emergency shut down + harvest done # genericStateOfStrat(strategy, currency, vault) # genericStateOfVault(vault, currency) # Restore power vault.setEmergencyShutdown(False, {"from": gov}) strategy.harvest({"from": gov}) assert strategy.estimatedTotalAssets() > amount0 + amount1 assert currency.balanceOf(vault) == 0 # Withdraw All vault.withdraw(vault.balanceOf(gov), {"from": gov})
def test_donations(strategy, web3, chain, vault, currency, whale, strategist, gov): deposit_limit = Wei('1_000_000 ether') vault.addStrategy(strategy, deposit_limit, deposit_limit, 50, {"from": gov}) amount = Wei('500_000 ether') deposit(amount, whale, currency, vault) assert vault.strategies(strategy)[5] == 0 strategy.harvest({'from': gov}) assert vault.strategies(strategy)[6] == 0 donation = Wei('1000 ether') #donation to strategy currency.transfer(strategy, donation, {'from': whale}) assert vault.strategies(strategy)[6] == 0 sleep(chain, 10) strategy.harvest({'from': gov}) assert vault.strategies(strategy)[6] >= donation * 0.9999 assert currency.balanceOf(vault) >= donation * 0.99999 strategy.harvest({'from': gov}) assert vault.strategies(strategy)[5] >= (donation + amount) * 0.99999 #donation to vault currency.transfer(vault, donation, {'from': whale}) assert vault.strategies( strategy)[6] >= donation * 0.9999 and vault.strategies( strategy)[6] < donation * 2 strategy.harvest({'from': gov}) assert vault.strategies(strategy)[5] >= (donation * 2 + amount) * 0.9999 strategy.harvest({'from': gov}) assert vault.strategies(strategy)[ 6] >= donation * 0.999 and vault.strategies(strategy)[6] < donation * 2 #check share price is close to expected assert vault.pricePerShare() > ( (donation * 2 + amount) / amount) * 0.95 * 1e18 and vault.pricePerShare() < ( (donation * 2 + amount) / amount) * 1.05 * 1e18
def test_withdrawals_work( usdc, Strategy, crUsdc, cUsdc, interface, chain, whale, gov, strategist, rando, vault, strategy, fn_isolation, ): starting_balance = usdc.balanceOf(strategist) currency = usdc decimals = currency.decimals() usdc.approve(vault, 2**256 - 1, {"from": whale}) usdc.approve(vault, 2**256 - 1, {"from": strategist}) deposit_limit = 1_000_000_000 * (10**(decimals)) debt_ratio = 10000 vault.addStrategy(strategy, debt_ratio, 0, 2**256 - 1, 500, {"from": gov}) vault.setDepositLimit(deposit_limit, {"from": gov}) status = strategy.lendStatuses() depositAmount = 501 * (10**(decimals)) vault.deposit(depositAmount, {"from": strategist}) # whale deposits as well whale_deposit = 100_000 * (10**(decimals)) vault.deposit(whale_deposit, {"from": whale}) strategy.harvest({"from": strategist}) sleep(chain, 25) strategy.harvest({"from": strategist}) for j in status: plugin = interface.IGeneric(j[3]) strategy.safeRemoveLender(plugin) status2 = strategy.lendStatuses() assert currency.balanceOf(strategy) > (depositAmount + whale_deposit) * 0.999 form = "{:.2%}" formS = "{:,.0f}" for j in status: plugin = interface.IGeneric(j[3]) print("Testing ", j[0]) strategy.addLender(j[3], {"from": gov}) strategy.harvest({"from": strategist}) assert plugin.nav() > (depositAmount + whale_deposit) * 0.999 shareprice = vault.pricePerShare() shares = vault.balanceOf(strategist) expectedout = shares * (shareprice / 1e18) * (10**(decimals * 2)) balanceBefore = currency.balanceOf(strategist) # print(f"Lender: {j[0]}, Deposits: {formS.format(plugin.nav()/1e6)}") vault.withdraw(vault.balanceOf(strategist), {"from": strategist}) balanceAfter = currency.balanceOf(strategist) # print(f"after Lender: {j[0]}, Deposits: {formS.format(plugin.nav()/1e6)}") withdrawn = balanceAfter - balanceBefore assert withdrawn > expectedout * 0.99 and withdrawn < expectedout * 1.01 shareprice = vault.pricePerShare() shares = vault.balanceOf(whale) expectedout = shares * (shareprice / 1e18) * (10**(decimals * 2)) balanceBefore = currency.balanceOf(whale) vault.withdraw(vault.balanceOf(whale), {"from": whale}) balanceAfter = currency.balanceOf(whale) withdrawn = balanceAfter - balanceBefore assert withdrawn > expectedout * 0.99 and withdrawn < expectedout * 1.01 vault.deposit(whale_deposit, {"from": whale}) vault.deposit(depositAmount, {"from": strategist}) strategy.harvest({"from": strategist}) strategy.safeRemoveLender(j[3]) assert plugin.nav() < 1000000 assert currency.balanceOf(strategy) > (depositAmount + whale_deposit) * 0.999 # our humble strategist deposits some test funds # strategist withdraws shareprice = vault.pricePerShare() shares = vault.balanceOf(strategist) expectedout = shares * (shareprice / 1e18) * (10**(decimals * 2)) balanceBefore = currency.balanceOf(strategist) # genericStateOfStrat(strategy, currency, vault) # genericStateOfVault(vault, currency) vault.withdraw(vault.balanceOf(strategist), {"from": strategist}) balanceAfter = currency.balanceOf(strategist) # genericStateOfStrat(strategy, currency, vault) # genericStateOfVault(vault, currency) status = strategy.lendStatuses() chain.mine(1) withdrawn = balanceAfter - balanceBefore assert withdrawn > expectedout * 0.99 and withdrawn < expectedout * 1.01 shareprice = vault.pricePerShare() shares = vault.balanceOf(whale) expectedout = shares * (shareprice / 1e18) * (10**(decimals * 2)) balanceBefore = currency.balanceOf(whale) vault.withdraw(vault.balanceOf(whale), {"from": whale}) balanceAfter = currency.balanceOf(whale) withdrawn = balanceAfter - balanceBefore assert withdrawn > expectedout * 0.99 and withdrawn < expectedout * 1.01
def test_full_generic(Strategy, web3, chain, cdai, crdai, Vault, currency, whale, strategist): # our humble strategist is going to publish both the vault and the strategy # deploy vault vault = strategist.deploy(Vault) vault.initialize(currency, strategist, strategist, "", "", strategist) deposit_limit = Wei("1_000_000 ether") # set limit to the vault vault.setDepositLimit(deposit_limit, {"from": strategist}) # deploy strategy strategy = strategist.deploy(Strategy, vault, cdai, crdai) strategy.setMinCompToSell(0.01 * 1e18, {"from": strategist}) rate_limit = 1_000_000_000 * 1e18 debt_ratio = 9_500 # 100% vault.addStrategy(strategy, debt_ratio, 0, rate_limit, 1000, {"from": strategist}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) # our humble strategist deposits some test funds depositAmount = Wei("501 ether") currency.transfer(strategist, depositAmount, {"from": whale}) starting_balance = currency.balanceOf(strategist) deposit(depositAmount, strategist, currency, vault) # print(vault.creditAvailable(strategy)) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) assert strategy.estimatedTotalAssets() == 0 assert strategy.harvestTrigger(1e15) == True strategy.harvest({"from": strategist}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) assert strategy.estimatedTotalAssets() >= depositAmount * 0.999999 * ( debt_ratio / 10_000) # losing some dust is ok assert strategy.harvestTrigger(1) == False # whale deposits as well whale_deposit = Wei("2000 ether") deposit(whale_deposit, whale, currency, vault) assert strategy.harvestTrigger(1 * 30 * 1e9) == True harvest(strategy, strategist, vault) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) for i in range(5): waitBlock = random.randint(10, 50) print(f"\n----wait {waitBlock} blocks----") sleep(chain, waitBlock) # if harvest condition harvest. if tend tend harvest(strategy, strategist, vault) tend(strategy, strategist) something = True action = random.randint(0, 9) if action == 1: withdraw(random.randint(50, 100), whale, currency, vault) elif action == 2: withdraw(random.randint(50, 100), whale, currency, vault) elif action == 3: deposit(Wei(str(f"{random.randint(10000,50000)} ether")), whale, currency, vault) else: something = False if something: genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) # strategist withdraws vault.withdraw({"from": strategist}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) profit = currency.balanceOf(strategist) - starting_balance print(Wei(profit).to("ether"), " profit") print(vault.strategies(strategy)[6].to("ether"), " total returns of strat")
def test_withdrawals_weth_work(currency,interface, chain, whale,gov,strategist,rando,vault, strategy, fn_isolation): starting_balance = currency.balanceOf(strategist) decimals = currency.decimals() currency.approve(vault, 2 ** 256 - 1, {"from": whale} ) currency.approve(vault, 2 ** 256 - 1, {"from": strategist} ) rate_limit = 1_000_000_000 *1e18 debt_ratio = 10_000 #100% vault.addStrategy(strategy, debt_ratio, rate_limit, 1000, {"from": gov}) status = strategy.lendStatuses() depositAmount = 5 * (10 ** (decimals)) vault.deposit(depositAmount, {"from": strategist}) #whale deposits as well whale_deposit =1000 *(10 ** (decimals)) vault.deposit(whale_deposit, {"from": whale}) strategy.harvest({"from": strategist}) sleep(chain, 25) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) strategy.harvest({"from": strategist}) #genericStateOfStrat(strategy, currency, vault) #genericStateOfVault(vault, currency) shareprice = vault.pricePerShare() shares = vault.balanceOf(gov) expectedout = (shares*shareprice)/(10 ** (decimals)) balanceBefore = currency.balanceOf(gov) vault.withdraw(vault.balanceOf(gov), {'from': gov}) balanceAfter = currency.balanceOf(gov) withdrawn = balanceAfter - balanceBefore assert withdrawn > expectedout*0.99 and withdrawn < expectedout*1.01 form = "{:.2%}" formS = "{:,.0f}" for j in status: print('Removing ', j[0]) plugin = interface.IGeneric(j[3]) #print(f"Lender: {j[0]}, Deposits: {plugin.nav()/1e18}") #print(currency.balanceOf(plugin)) strategy.safeRemoveLender(plugin) #print(f"Lender: {j[0]}, Deposits: {plugin.nav()/1e18}") status2 = strategy.lendStatuses() assert currency.balanceOf(strategy) > (depositAmount + whale_deposit)*.999 strategy.harvest({"from": strategist}) for j in status: plugin = interface.IGeneric(j[3]) print('Testing ', j[0]) strategy.addLender(j[3], {'from': gov}) strategy.harvest({"from": strategist}) assert plugin.nav() > (depositAmount + whale_deposit)*.999 shareprice = vault.pricePerShare() shares = vault.balanceOf(strategist) expectedout = (shares*shareprice)/(10 ** (decimals)) balanceBefore = currency.balanceOf(strategist) #print(f"Lender: {j[0]}, Deposits: {formS.format(plugin.nav()/1e6)}") vault.withdraw(vault.balanceOf(strategist), {'from': strategist}) balanceAfter = currency.balanceOf(strategist) #print(f"after Lender: {j[0]}, Deposits: {formS.format(plugin.nav()/1e6)}") withdrawn = balanceAfter - balanceBefore assert withdrawn > expectedout*0.99 and withdrawn < expectedout*1.01 shareprice = vault.pricePerShare() shares = vault.balanceOf(whale) expectedout = (shares*shareprice)/(10 ** (decimals)) balanceBefore = currency.balanceOf(whale) vault.withdraw(vault.balanceOf(whale), {'from': whale}) balanceAfter = currency.balanceOf(whale) withdrawn = balanceAfter - balanceBefore assert withdrawn > expectedout*0.99 and withdrawn < expectedout*1.01 vault.withdraw(vault.balanceOf(gov), {'from': gov}) vault.deposit(whale_deposit, {"from": whale}) vault.deposit(depositAmount, {"from": strategist}) strategy.harvest({"from": strategist}) strategy.safeRemoveLender(j[3]) assert plugin.nav() < 1000000 assert currency.balanceOf(strategy) > (depositAmount + whale_deposit)*.999 #our humble strategist deposits some test funds #strategist withdraws shareprice = vault.pricePerShare() shares = vault.balanceOf(strategist) expectedout = (shares*shareprice)/(10 ** (decimals)) balanceBefore = currency.balanceOf(strategist) #genericStateOfStrat(strategy, currency, vault) #genericStateOfVault(vault, currency) vault.withdraw(vault.balanceOf(strategist), {'from': strategist}) balanceAfter = currency.balanceOf(strategist) #genericStateOfStrat(strategy, currency, vault) #genericStateOfVault(vault, currency) status = strategy.lendStatuses() chain.mine(1) withdrawn = balanceAfter - balanceBefore assert withdrawn > expectedout*0.99 and withdrawn < expectedout*1.01 shareprice = vault.pricePerShare() shares = vault.balanceOf(whale) expectedout = (shares*shareprice)/(10 ** (decimals)) balanceBefore = currency.balanceOf(whale) vault.withdraw(vault.balanceOf(whale), {'from': whale}) balanceAfter = currency.balanceOf(whale) withdrawn = balanceAfter - balanceBefore assert withdrawn > expectedout*0.99 and withdrawn < expectedout*1.01