def test_migration(token, strategy, chain, vault, whale, gov, strategist,
StrategyCurveLINKVoterProxy):
debt_ratio = 10_000
vault.addStrategy(strategy, debt_ratio, 0, 2**256 - 1, 1000, {"from": gov})
token.approve(vault, 2**256 - 1, {"from": whale})
vault.deposit(Wei("100 ether"), {"from": whale})
strategy.harvest({"from": strategist})
genericStateOfStrat(strategy, token, vault)
genericStateOfVault(vault, token)
chain.sleep(2592000)
chain.mine(1)
print(
"\nEstimated APR: ",
"{:.2%}".format(
((vault.totalAssets() - 100 * 1e18) * 12) / (100 * 1e18)),
)
strategy2 = strategist.deploy(StrategyCurveLINKVoterProxy, vault)
vault.migrateStrategy(strategy, strategy2, {"from": gov})
genericStateOfStrat(strategy, token, vault)
genericStateOfStrat(strategy2, token, vault)
genericStateOfVault(vault, token)
def test_clone(accounts, strategy, strategist, rewards, keeper, vault, Strategy, gov, dai, dai_vault, rook, rook_whale,
amount, marketplace, pool, rook_distributor, weth, zero_address):
with brownie.reverts():
strategy.init(dai_vault, strategist, rewards, keeper, pool, gov, rook_distributor, zero_address, {"from": gov})
transaction = strategy.clone(dai_vault, strategist, rewards, keeper, pool, gov, rook_distributor, zero_address,
{"from": gov})
cloned_strategy = Strategy.at(transaction.return_value)
assert cloned_strategy.name() == "StrategyRook Dai Stablecoin"
with brownie.reverts():
cloned_strategy.init(dai_vault, strategist, rewards, keeper, pool, gov, rook_distributor, zero_address,
{"from": gov})
# test harvest for cloned strategy
# dai whale
amount = 1 * 10 ** dai.decimals()
reserve = accounts.at("0xd551234ae421e3bcba99a0da6d736074f22192ff", force=True)
dai.transfer(accounts[0], amount, {"from": reserve})
token = dai
vault = dai_vault
strategy = cloned_strategy
# Deposit to the vault
token.approve(vault.address, amount, {"from": accounts[0]})
vault.deposit(amount, {"from": accounts[0]})
vault.addStrategy(strategy, 10_000, 0, 1000, {"from": gov})
assert token.balanceOf(vault.address) == amount
#
# harvest
strategy.harvest({"from": gov})
# assert eta is there, accouting for deposit fee
assert pytest.approx(strategy.estimatedTotalAssets(), rel=amount * 0.0064) == amount
assets_before = vault.totalAssets()
# There isn't a way to simulate rewards from the distributor as it requires data from an offchain heroku app
# The heroku app is updated from mainnet data and is not open sourced
# arbitrary reward amount from a whale
rook.transfer(strategy.address, 100 * 10 ** 18, {"from": rook_whale})
print(f'\n---- before harvest')
strategyBreakdown(strategy, token, vault)
genericStateOfVault(vault, token)
strategy.harvest({"from": gov})
print(f'\n---- after harvest')
strategyBreakdown(strategy, token, vault)
genericStateOfVault(vault, token)
assert vault.totalAssets() > assets_before
def test_emergency_exit(accounts, token, vault, strategy, strategist, amount):
# Deposit to the vault
token.approve(vault.address, amount, {"from": accounts[0]})
vault.deposit(amount, {"from": accounts[0]})
strategy.harvest()
assert strategy.estimatedTotalAssets() > amount * .99
# set emergency and exit
strategy.setEmergencyExit()
strategy.harvest()
assert strategy.estimatedTotalAssets() == 0
genericStateOfVault(vault, token)
def test_revoke_strategy_from_vault(token, vault, strategy, amount, gov):
# Deposit to the vault and harvest
token.approve(vault.address, amount, {"from": gov})
vault.deposit(amount, {"from": gov})
strategy.harvest()
genericStateOfVault(vault, token)
strategyBreakdown(strategy, token, vault)
assert strategy.estimatedTotalAssets() > amount * .99
# In order to pass this tests, you will need to implement prepareReturn.
vault.revokeStrategy(strategy.address, {"from": gov})
strategy.harvest()
genericStateOfVault(vault, token)
strategyBreakdown(strategy, token, vault)
assert token.balanceOf(vault.address) > amount * .99
def test_revoke_from_vault(token, strategy, vault, whale, gov, strategist):
print("\n----test revoke----")
debt_ratio = 10_000
vault.addStrategy(strategy, debt_ratio, 0, 2**256 - 1, 1000, {"from": gov})
token.approve(vault, 2**256 - 1, {"from": whale})
initial_deposit = 100 * 1e18
vault.deposit(initial_deposit, {"from": whale})
strategy.harvest({"from": strategist})
genericStateOfStrat(strategy, token, vault)
genericStateOfVault(vault, token)
vault.revokeStrategy(strategy, {"from": gov})
print("\n-----revoked-----")
strategy.harvest({"from": strategist})
genericStateOfStrat(strategy, token, vault)
genericStateOfVault(vault, token)
def test_ops(token, strategy, chain, vault, whale, gov, strategist):
print("\n----test ops----")
debt_ratio = 10_000
vault.addStrategy(strategy, debt_ratio, 0, 2**256 - 1, 1000, {"from": gov})
token.approve(vault, 2**256 - 1, {"from": whale})
initial_deposit = 100 * 1e18
whalebefore = token.balanceOf(whale)
vault.deposit(initial_deposit, {"from": whale})
strategy.harvest({"from": strategist})
print("\n-----harvest-----")
genericStateOfStrat(strategy, token, vault)
genericStateOfVault(vault, token)
print("\n-----sleep for a month-----")
chain.sleep(2592000)
chain.mine(1)
strategy.harvest({"from": strategist})
print("\n-----harvest-----")
print("crvIB = ", token.balanceOf(strategy) / 1e18)
genericStateOfStrat(strategy, token, vault)
genericStateOfVault(vault, token)
print(
"\nEstimated APR: ",
"{:.2%}".format(
((vault.totalAssets() - initial_deposit) * 12) / initial_deposit),
)
vault.withdraw({"from": whale})
print("\n-----withdraw-----")
genericStateOfStrat(strategy, token, vault)
genericStateOfVault(vault, token)
print(f"\nWhale profit: ", (token.balanceOf(whale) - whalebefore) / 1e18)
def test_profitable_harvest(accounts, token, vault, strategy, strategist,
amount, rook_whale, rook, chain):
# Deposit to the vault
token.approve(vault.address, amount, {"from": accounts[0]})
vault.deposit(amount, {"from": accounts[0]})
assert token.balanceOf(vault.address) == amount
#
# harvest
strategy.harvest()
assert pytest.approx(strategy.estimatedTotalAssets(),
rel=amount * 0.0064) == amount
assets_before = vault.totalAssets()
before_pps = vault.pricePerShare()
strategy.harvest()
chain.sleep(3600 * 6) # 6 hrs needed for profits to unlock
chain.mine(1)
# There isn't a way to simulate rewards from the distributor as it requires data from an offchain heroku app
# The heroku app is updated from mainnet data and is not open sourced
# arbitrary reward amount from a whale
rook.transfer(strategy.address, 100 * 10**18, {"from": rook_whale})
print(f'\n---- sell some rewards')
strategyBreakdown(strategy, token, vault)
genericStateOfVault(vault, token)
strategy.sellSome(10 * 10**18, {"from": strategist})
print(f'\n---- before harvest')
strategyBreakdown(strategy, token, vault)
genericStateOfVault(vault, token)
strategy.harvest()
print(f'\n---- after harvest')
strategyBreakdown(strategy, token, vault)
genericStateOfVault(vault, token)
assert vault.totalAssets() > assets_before
assert vault.pricePerShare() > before_pps