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
