def test_profit_is_expected(web3, chain, comp, vault, enormousrunningstrategy, whale, gov, dai, strategist): enormousrunningstrategy.setGasFactor(1, {"from": strategist}) assert (enormousrunningstrategy.gasFactor() == 1) startingBalance = vault.totalAssets() stateOfStrat(enormousrunningstrategy, dai, comp) stateOfVault(vault, enormousrunningstrategy) for i in range(50): assert vault.creditAvailable(enormousrunningstrategy) == 0 waitBlock = 25 print(f'\n----wait {waitBlock} blocks----') chain.mine(waitBlock) harvest(enormousrunningstrategy, strategist, vault) stateOfStrat(enormousrunningstrategy, dai, comp) stateOfVault(vault, enormousrunningstrategy) profit = (vault.totalAssets() - startingBalance).to('ether') strState = vault.strategies(enormousrunningstrategy) 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_profit_is_registered(web3, chain, comp, vault, largerunningstrategy, whale, gov, dai): stateOfStrat(largerunningstrategy, dai, comp) stateOfVault(vault, largerunningstrategy) #1m deposit amount = Wei('1000000 ether') deposit(amount, whale, dai, vault) harvest(largerunningstrategy, gov) #all money in vault assert largerunningstrategy.estimatedTotalAssets() > amount * 0.99 stateOfStrat(largerunningstrategy, dai, comp) stateOfVault(vault, largerunningstrategy) sample = 500 wait(sample, chain) harvest(largerunningstrategy, gov) stateOfStrat(largerunningstrategy, dai, comp) stateOfVault(vault, largerunningstrategy) debt = vault.strategies(largerunningstrategy)[5] returns = vault.strategies(largerunningstrategy)[6] assert returns > 0 blocks_per_year = 2_300_000 apr = returns / debt * (blocks_per_year / sample) print(f'implied apr: {apr:.8%}') assert apr > 0
def test_apr_generic(strategy_changeable, web3, chain, Vault, currency, whale, strategist): vault = strategist.deploy(Vault, currency, strategist, strategist, "TestVault", "Amount") deposit_limit = Wei('1000000 ether') #set limit to the vault vault.setDepositLimit(deposit_limit, {"from": strategist}) #deploy strategy strategy = strategist.deploy(strategy_changeable, vault) vault.addStrategy(strategy, deposit_limit, deposit_limit, 50, {"from": strategist}) deposit_amount = Wei('1000 ether') deposit(deposit_amount, whale, currency, vault) harvest(strategy, strategist, vault) startingBalance = vault.totalAssets() genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) for i in range(10): waitBlock = 25 print(f'\n----wait {waitBlock} blocks----') chain.mine(waitBlock) print(f'\n----harvest----') 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 normal_operation(chain, ychad, vault, user, whale, strategy, dai): print('\n---starting normal operations----') for i in count(1): waitBlock = random.randint(0,20) print(f'\n----wait {waitBlock} blocks----') chain.mine(waitBlock) action = random.randint(0,3) if action ==0: harvest(strategy, user) elif action == 1: withdraw(random.randint(10,100), strategy,whale, dai, vault) elif action == 2: earn(strategy, vault, user) elif action == 3: deposit(str(f'{random.randint(1,100000)} ether'), whale, dai, vault)
def test_apr_dai(web3, chain, comp, vault, enormousrunningstrategy, whale, gov, dai, strategist): enormousrunningstrategy.setProfitFactor(1, {"from": strategist}) assert enormousrunningstrategy.profitFactor() == 1 enormousrunningstrategy.setMinCompToSell(1, {"from": gov}) enormousrunningstrategy.setMinWant(0, {"from": gov}) assert enormousrunningstrategy.minCompToSell() == 1 startingBalance = vault.totalAssets() stateOfStrat(enormousrunningstrategy, dai, comp) stateOfVault(vault, enormousrunningstrategy) for i in range(6): waitBlock = 25 print(f"\n----wait {waitBlock} blocks----") chain.sleep(21600) wait(waitBlock, chain) ppsBefore = vault.pricePerShare() harvest(enormousrunningstrategy, strategist, vault) ppsAfter = vault.pricePerShare() # stateOfStrat(enormousrunningstrategy, dai, comp) # stateOfVault(vault, enormousrunningstrategy) profit = (vault.totalAssets() - startingBalance).to("ether") strState = vault.strategies(enormousrunningstrategy) 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 ppsProfit = (ppsAfter - ppsBefore) / 1e18 / waitBlock * blocks_per_year apr = (totalReturns / startingBalance) * (blocks_per_year / time) print(f"implied apr assets: {apr:.8%}") print(f"implied apr pps: {ppsProfit:.8%}") vault.withdraw(vault.balanceOf(whale), {"from": whale})
def test_leverage_up_and_down(web3, chain, comp, vault, largerunningstrategy, whale, gov, dai, strategist, isolation): stateOfStrat(largerunningstrategy, dai, comp) stateOfVault(vault, largerunningstrategy) deposit(dai.balanceOf(whale), whale, dai, vault) balanceBefore = vault.totalAssets() collat = 0 while collat < largerunningstrategy.collateralTarget() / 1.001e18: # while collat < largerunningstrategy.collateralTarget() : largerunningstrategy.harvest({'from': gov}) deposits, borrows = largerunningstrategy.getCurrentPosition() collat = borrows / deposits print(collat) stateOfStrat(largerunningstrategy, dai, comp) stateOfVault(vault, largerunningstrategy) assertCollateralRatio(largerunningstrategy) harvest(largerunningstrategy, gov, vault) stateOfStrat(largerunningstrategy, dai, comp) stateOfVault(vault, largerunningstrategy) largerunningstrategy.setCollateralTarget(Wei('0.1 ether'), {"from": gov}) largerunningstrategy.tend({'from': gov}) stateOfStrat(largerunningstrategy, dai, comp) stateOfVault(vault, largerunningstrategy) while collat > largerunningstrategy.collateralTarget() / 1e18: # while collat < largerunningstrategy.collateralTarget() : largerunningstrategy.tend({'from': gov}) deposits, borrows = largerunningstrategy.getCurrentPosition() collat = borrows / deposits print(collat) stateOfStrat(largerunningstrategy, dai, comp) stateOfVault(vault, largerunningstrategy)
def test_apr_creth(web3, chain, cream, vault, enormousrunningstrategy, whale, gov, currency, strategist): enormousrunningstrategy.setProfitFactor(1, {"from": strategist}) assert (enormousrunningstrategy.profitFactor() == 1) enormousrunningstrategy.setMinCompToSell(1, {"from": gov}) enormousrunningstrategy.setMinWant(0, {"from": gov}) assert enormousrunningstrategy.minCompToSell() == 1 startingBalance = vault.totalAssets() stateOfStrat(enormousrunningstrategy, currency, cream) stateOfVault(vault, enormousrunningstrategy) for i in range(10): waitBlock = 100 print(f'\n----wait {waitBlock} blocks----') wait(waitBlock, chain) harvest(enormousrunningstrategy, strategist, vault) stateOfStrat(enormousrunningstrategy, currency, cream) stateOfVault(vault, enormousrunningstrategy) #print(vault.creditAvailable(enormousrunningstrategy)/1e18) profit = (vault.totalAssets() - startingBalance).to('ether') strState = vault.strategies(enormousrunningstrategy) 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}) stateOfStrat(enormousrunningstrategy, currency, cream) stateOfVault(vault, enormousrunningstrategy)
def test_withdraw_all(web3, chain, comp, vault, largerunningstrategy, whale, gov, dai, strategist, isolation): balance_before = dai.balanceOf(strategist) stateOfStrat(largerunningstrategy, dai, comp) stateOfVault(vault, largerunningstrategy) amount = Wei('10000 ether') deposit(amount, strategist, dai, vault) harvest(largerunningstrategy, gov, vault) wait(50, chain) harvest(largerunningstrategy, gov, vault) stateOfStrat(largerunningstrategy, dai, comp) stateOfVault(vault, largerunningstrategy) withdraw(1, strategist, dai, vault) profitW = dai.balanceOf(strategist) - balance_before profit = profitW.to('ether') print(f'profit: {profit:.5f}')
def test_full_generic(strategy_changeable, web3, chain, Vault, currency, whale, strategist): #our humble strategist is going to publish both the vault and the strategy starting_balance = currency.balanceOf(strategist) #deploy vault vault = strategist.deploy(Vault, currency, strategist, strategist, "TestVault", "Amount") deposit_limit = Wei('1000000 ether') #set limit to the vault vault.setDepositLimit(deposit_limit, {"from": strategist}) #deploy strategy strategy = strategist.deploy(strategy_changeable, vault) vault.addStrategy(strategy, deposit_limit, deposit_limit, 50, {"from": strategist}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) #our humble strategist deposits some test funds depositAmount = Wei('501 ether') deposit(depositAmount, strategist, currency, vault) #print(vault.creditAvailable(strategy)) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) assert strategy.estimatedTotalAssets() == 0 assert strategy.harvestTrigger(1) == True harvest(strategy, strategist, vault) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) assert strategy.estimatedTotalAssets( ) >= depositAmount * 0.999999 #losing some dust is ok assert strategy.harvestTrigger(1) == False #whale deposits as well whale_deposit = Wei('1000 ether') deposit(whale_deposit, whale, currency, vault) assert strategy.harvestTrigger(1000000 * 30 * 1e9) == True harvest(strategy, strategist, vault) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) for i in range(15): waitBlock = random.randint(10, 50) print(f'\n----wait {waitBlock} blocks----') chain.mine(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(10,100)} ether')), whale, currency, vault) else: something = False if something: genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) #strategist withdraws withdraw(1, strategist, currency, vault) 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_full_live(web3, chain, comp, Vault, YearnDaiCompStratV2, dai, whale, strategist, cdai): #our humble strategist is going to publish both the vault and the strategy # this is to mint small amount of dai reguarly to replicate people interacting with cdai contract dai.approve(cdai, 2**256 - 1, {"from": whale}) starting_balance = dai.balanceOf(strategist) #deploy vault vault = strategist.deploy(Vault, dai, strategist, strategist, "Ytest DAI Vault V2", "ytDAI2") #100k dai limit to begin with deposit_limit = Wei('1000000 ether') #set limit to the vault vault.setDepositLimit(deposit_limit, {"from": strategist}) #deploy strategy strategy = strategist.deploy(YearnDaiCompStratV2, vault) strategy.setGasFactor(1, {"from": strategist}) assert (strategy.gasFactor() == 1) strategy.setMinCompToSell(Wei('0.1 ether'), {"from": strategist}) assert (strategy.minCompToSell() == Wei('0.1 ether')) #Current comp/eth rate compEthRate = strategy.getCompValInWei(Wei('1 ether')) print('Current comp/eth rate:', compEthRate) #enable the strategy rate_limit = deposit_limit vault.addStrategy(strategy, rate_limit, rate_limit, 50, {"from": strategist}) #our humble strategist deposits some test funds deposit(Wei('1000 ether'), strategist, dai, vault) stateOfStrat(strategy, dai, comp) stateOfVault(vault, strategy) assert strategy.estimatedTotalAssets() == 0 harvest(strategy, strategist, vault) #whale deposits as well deposit(Wei('1000 ether'), whale, dai, vault) for i in range(15): #assertCollateralRatio(strategy) waitBlock = random.randint(10, 50) print(f'\n----wait {waitBlock} blocks----') chain.mine(waitBlock) #if harvest condition harvest. if tend tend print(strategy.predictCompAccrued().to('ether'), ' comp prediction') print(comp.balanceOf(strategy).to('ether'), ' comp in balance') harvest(strategy, strategist, vault) tend(strategy, strategist) something = True action = random.randint(0, 9) if action == 1: withdraw(random.randint(50, 100), whale, dai, vault) elif action == 2: withdraw(random.randint(50, 100), whale, dai, vault) elif action == 3: deposit(Wei(str(f'{random.randint(10000,100000)} ether')), whale, dai, vault) elif action > 3 and action < 6: cdai.mint(1, {"from": whale}) else: something = False if something: stateOfStrat(strategy, dai, comp) stateOfVault(vault, strategy) #strategist withdraws withdraw(1, strategist, dai, vault) stateOfStrat(strategy, dai, comp) stateOfVault(vault, strategy) profit = dai.balanceOf(strategist) - starting_balance print(Wei(profit).to('ether'), ' profit') print(vault.strategies(strategy)[6], ' total returns of strat')
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_apr_optimser(usdc, chain, whale, gov, strategist, Vault, LenderYieldOptimiser, GenericCompound, GenericCream, GenericDyDx, interface): currency = usdc solo = interface.ISoloMargin('0x1E0447b19BB6EcFdAe1e4AE1694b0C3659614e4e') cUsdc = interface.CErc20I('0x39AA39c021dfbaE8faC545936693aC917d5E7563') crUsdc = interface.CErc20I('0x44fbeBd2F576670a6C33f6Fc0B00aA8c5753b322') vault = strategist.deploy(Vault, usdc, strategist, strategist, "", "") usdc.approve(vault, 2**256 - 1, {"from": whale}) usdc.approve(vault, 2**256 - 1, {"from": strategist}) #deploy strategy strategy = strategist.deploy(LenderYieldOptimiser, vault) #cDai = interface.CErc20I('0x5d3a536e4d6dbd6114cc1ead35777bab948e3643') solo = interface.ISoloMargin('0x1E0447b19BB6EcFdAe1e4AE1694b0C3659614e4e') cUsdc = interface.CErc20I('0x39AA39c021dfbaE8faC545936693aC917d5E7563') assert cUsdc.underlying() == vault.token() crUsdc = interface.CErc20I('0x44fbeBd2F576670a6C33f6Fc0B00aA8c5753b322') assert crUsdc.underlying() == vault.token() compoundPlugin = strategist.deploy(GenericCompound, strategy, "Compound", cUsdc) creamPlugin = strategist.deploy(GenericCream, strategy, "Cream", crUsdc) dydxPlugin = strategist.deploy(GenericDyDx, strategy, "DyDx") strategy.addLender(compoundPlugin, {"from": strategist}) assert strategy.numLenders() == 1 strategy.addLender(creamPlugin, {"from": strategist}) assert strategy.numLenders() == 2 strategy.addLender(dydxPlugin, {"from": strategist}) assert strategy.numLenders() == 3 deposit_limit = 1_000_000_000 * 1e6 vault.addStrategy(strategy, deposit_limit, deposit_limit, 500, {"from": strategist}) whale_deposit = 100_000 * 1e6 vault.deposit(whale_deposit, {"from": whale}) harvest(strategy, strategist, vault) startingBalance = vault.totalAssets() genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) for i in range(10): cUsdc.mint(0, {"from": whale}) crUsdc.mint(0, {"from": whale}) waitBlock = 25 print(f'\n----wait {waitBlock} blocks----') chain.mine(waitBlock) print(f'\n----harvest----') strategy.harvest({'from': strategist}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) profit = (vault.totalAssets() - startingBalance) / 1e6 strState = vault.strategies(strategy) totalReturns = strState[6] totaleth = totalReturns / 1e6 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_strat_sam(accounts, interface, web3, chain, vault, comp, whale, YearnDaiCompStratV2, dai, gov): strategist_and_keeper = accounts[1] print(strategist_and_keeper) assert vault.governance() == gov assert vault.guardian() == gov assert vault.rewards() == gov assert vault.token() == dai # Deploy the Strategy strategy = strategist_and_keeper.deploy(YearnDaiCompStratV2, vault) # Addresses assert strategy.strategist() == strategist_and_keeper assert strategy.keeper() == strategist_and_keeper assert strategy.want() == vault.token() stateOfStrat(strategy, dai, comp) # Add strategy to the Vault assert vault.strategies(strategy) == [0, 0, 0, 0, 0, 0, 0] _debtLimit = Wei('1000000 ether') _rateLimit = Wei('1000000 ether') vault.addStrategy(strategy, _debtLimit, _rateLimit, 50, {"from": gov}) assert vault.strategies(strategy) == [ 50, web3.eth.blockNumber, _debtLimit, _rateLimit, web3.eth.blockNumber, 0, 0, ] print(strategy._predictCompAccrued(), ' comp prediction') # Nothing was reported yet from the strategy assert vault.expectedReturn(strategy) == 0 depositLimit = Wei('500000 ether') vault.setDepositLimit(depositLimit, {"from": gov}) assert vault.depositLimit() == depositLimit #set compToSell # Provide funds to the Vault from whale # Test first with simply 5k as it is the current rate DAI/block amount = Wei('100000 ether') deposit(amount, whale, dai, vault) stateOfStrat(strategy, dai, comp) stateOfVault(vault, strategy) # Call harvest in Strategy only when harvestTrigger() --> (true) harvest(strategy, strategist_and_keeper) # assert( !strategy.harvestTrigger(0, {'from': strategist_and_keeper})) stateOfStrat(strategy, dai, comp) stateOfVault(vault, strategy) # now lets see 90k amount = Wei('320000 ether') deposit(amount, whale, dai, vault) stateOfStrat(strategy, dai, comp) stateOfVault(vault, strategy) harvest(strategy, strategist_and_keeper) stateOfStrat(strategy, dai, comp) stateOfVault(vault, strategy) # Claim COMP and check balance in strategy -> for testing _claimComp() needs to be public #strategy._claimComp({'from': strategist_and_keeper}) #comp_balance = comp.balanceOf(strategy) #print(comp_balance.to('ether'), 'comp claimed') # Call harvest in Strategy only when harvestTrigger() --> (true) #harvest(strategy, strategist_and_keeper) stateOfStrat(strategy, dai, comp) stateOfVault(vault, strategy) #withdraw(1, strategy, whale, dai, vault) #vault.setEmergencyShutdown(True, {"from": gov}) while strategy.harvestTrigger(0) == False: wait(25, chain) print(strategy._predictCompAccrued().to('ether'), ' comp prediction') #print('Emergency Exit') #strategy.setEmergencyExit({"from": gov}) stateOfStrat(strategy, dai, comp) stateOfVault(vault, strategy) harvest(strategy, strategist_and_keeper) stateOfStrat(strategy, dai, comp) stateOfVault(vault, strategy) ##test migration print('test migration') strategy2 = strategist_and_keeper.deploy(YearnDaiCompStratV2, vault) vault.migrateStrategy(strategy, strategy2, {"from": gov}) print('old strat') stateOfStrat(strategy, dai, comp) stateOfVault(vault, strategy) print('new strat') stateOfStrat(strategy2, dai, comp) stateOfVault(vault, strategy2) withdraw(1, whale, dai, vault) stateOfStrat(strategy2, dai, comp) stateOfVault(vault, strategy2) amount = Wei('320000 ether') deposit(amount, whale, dai, vault) stateOfStrat(strategy2, dai, comp) stateOfVault(vault, strategy2) harvest(strategy2, strategist_and_keeper) stateOfStrat(strategy2, dai, comp) stateOfVault(vault, strategy2) withdraw(1, whale, dai, vault) stateOfStrat(strategy2, dai, comp) stateOfVault(vault, strategy2)
def test_strat_sam(accounts, interface, web3, chain, Vault, YearnDaiCompStratV2): gov = accounts[0] print(gov) strategist_and_keeper = accounts[1] print(strategist_and_keeper) dai = interface.ERC20('0x6b175474e89094c44da98b954eedeac495271d0f') cdai = interface.ERC20('0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643') comp = interface.ERC20('0xc00e94Cb662C3520282E6f5717214004A7f26888') comptroller = interface.ComptrollerI( '0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B') # Current COMP speeds print('COMP speed: ', comptroller.compSpeeds(cdai)) ydai = interface.ERC20('0x16de59092dae5ccf4a1e6439d611fd0653f0bd01') whale = accounts.at("0xBE0eB53F46cd790Cd13851d5EFf43D12404d33E8", force=True) # Deploy the Vault vault = gov.deploy(Vault, dai, gov, gov, "Yearn DAI v2", "y2DAI") assert vault.governance() == gov assert vault.guardian() == gov assert vault.rewards() == gov assert vault.token() == dai # Deploy the Strategy strategy = strategist_and_keeper.deploy(YearnDaiCompStratV2, vault) # Addresses assert strategy.strategist() == strategist_and_keeper assert strategy.keeper() == strategist_and_keeper assert strategy.want() == vault.token() stateOfStrat(strategy, dai) # Test current price for COMP and DAI using Chainlink lastExchangeRate = strategy.getLatestExchangeRate() print('Current exchange rate (COMP/DAI): ', lastExchangeRate) # Add strategy to the Vault assert vault.strategies(strategy) == [0, 0, 0, 0, 0, 0, 0] _debtLimit = Wei('1000000 ether') _rateLimit = Wei('1000000 ether') vault.addStrategy(strategy, _debtLimit, _rateLimit, 50, {"from": gov}) assert vault.strategies(strategy) == [ 50, web3.eth.blockNumber, _debtLimit, _rateLimit, web3.eth.blockNumber, 0, 0, ] print(strategy._predictCompAccrued(), ' comp prediction') # Nothing was reported yet from the strategy assert vault.expectedReturn(strategy) == 0 stateOfStrat(strategy, dai) depositLimit = Wei('500000 ether') vault.setDepositLimit(depositLimit, {"from": gov}) assert vault.depositLimit() == depositLimit # Provide funds to the Vault from whale # Test first with simply 5k as it is the current rate DAI/block amount = Wei('100000 ether') deposit(amount, whale, dai, vault) stateOfStrat(strategy, dai) stateOfVault(vault, strategy) # Call harvest in Strategy only when harvestTrigger() --> (true) harvest(strategy, strategist_and_keeper) # assert( !strategy.harvestTrigger(0, {'from': strategist_and_keeper})) stateOfStrat(strategy, dai) stateOfVault(vault, strategy) # now lets see 90k amount = Wei('320000 ether') deposit(amount, whale, dai, vault) stateOfStrat(strategy, dai) stateOfVault(vault, strategy) harvest(strategy, strategist_and_keeper) stateOfStrat(strategy, dai) stateOfVault(vault, strategy) # Call harvest in Strategy only when harvestTrigger() --> (true) #harvest(strategy, strategist_and_keeper) stateOfStrat(strategy, dai) stateOfVault(vault, strategy) #withdraw(1, strategy, whale, dai, vault) #vault.setEmergencyShutdown(True, {"from": gov}) while strategy.harvestTrigger(0) == False: wait(25, chain) print(strategy._predictCompAccrued().to('ether'), ' comp prediction') #print('Emergency Exit') #strategy.setEmergencyExit({"from": gov}) # Claim COMP and check balance in strategy -> for testing _claimComp() needs to be public strategy._claimComp({'from': strategist_and_keeper}) comp_balance = comp.balanceOf(strategy) print(comp_balance.to('ether'), 'comp claimed') stateOfStrat(strategy, dai) stateOfVault(vault, strategy) harvest(strategy, strategist_and_keeper) stateOfStrat(strategy, dai) stateOfVault(vault, strategy) ##test migration print('test migration') strategy2 = strategist_and_keeper.deploy(YearnDaiCompStratV2, vault) vault.migrateStrategy(strategy, strategy2, {"from": gov}) print('old strat') stateOfStrat(strategy, dai) stateOfVault(vault, strategy) print('new strat') stateOfStrat(strategy2, dai) stateOfVault(vault, strategy2) withdraw(1, whale, dai, vault) stateOfStrat(strategy2, dai) stateOfVault(vault, strategy2) amount = Wei('320000 ether') deposit(amount, whale, dai, vault) stateOfStrat(strategy2, dai) stateOfVault(vault, strategy2) harvest(strategy2, strategist_and_keeper) stateOfStrat(strategy2, dai) stateOfVault(vault, strategy2) withdraw(1, whale, dai, vault) stateOfStrat(strategy2, dai) stateOfVault(vault, strategy2)