def test_live(currency, interface, samdev, Contract, devychad, live_guest_list, live_Alpha_Homo, live_vault_weth, live_strat_weth_1, chain, whale, gov, rando, fn_isolation): gov = devychad decimals = currency.decimals() strategist = samdev strategy = live_strat_weth_1 vault = live_vault_weth addresses = [whale] permissions = [True] live_guest_list.setGuests(addresses, permissions, {"from": gov}) # strategy.addLender(live_dydxweth, {"from": strategist}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) currency.approve(vault, 2**256 - 1, {"from": whale}) currency.approve(vault, 2**256 - 1, {"from": strategist}) whale_deposit = 100 * (10**(decimals)) vault.deposit(whale_deposit, {"from": whale}) strategy.harvest({"from": strategist}) form = "{:.2%}" formS = "{:,.0f}" status = strategy.lendStatuses() for j in status: print( f"Lender: {j[0]}, Deposits: {formS.format(j[1]/1e18)}, APR: {form.format(j[2]/1e18)}" )
def test_zapper(currency, strategy, zapper, chain, vault, whale, gov, strategist, interface): rate_limit = 1_000_000_000 * 1e18 debt_ratio = 10_000 zapper.updateVaultAddress(vault) vault.addStrategy(strategy, debt_ratio, rate_limit, 1000, {"from": gov}) gov.transfer(zapper, 5 * 1e18) before = vault.balanceOf(gov) print(before / 1e18) assert vault.balanceOf(gov) > 0 zapper.zapEthIn(50, {"from": gov, "value": 5 * 1e18}) print(vault.balanceOf(gov) / 1e18) assert vault.balanceOf(gov) > before strategy.harvest({'from': strategist}) chain.sleep(2592000) chain.mine(1) strategy.harvest({'from': strategist}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) bBefore = gov.balance() vault.approve(zapper, 2**256 - 1, {"from": gov}) zapper.zapEthOut(vault.balanceOf(gov), 500, {"from": gov}) print(gov.balance() / 1e18 - bBefore / 1e18) #zapper.zapStEthOut(vault.balanceOf(gov), 50, {"from": gov}) assert vault.balanceOf(gov) == 0
def test_normal_activity(accounts, token, vault, strategy, strategist, whale, chain): amount = Wei("1 ether") balance_before = token.balanceOf(whale) # Deposit to the vault token.approve(vault, amount, {"from": whale}) vault.deposit(amount, {"from": whale}) assert token.balanceOf(vault) == amount # invest strategy.harvest() chain.sleep(8 * 3600) chain.mine(1) # harvest some profits strategy.harvest() chain.sleep(8 * 3600) chain.mine(1) # withdrawal vault.withdraw({"from": whale}) assert token.balanceOf(whale) > balance_before genericStateOfStrat(strategy, token, vault) genericStateOfVault(vault, token)
def test_no_liquidity(currency,Strategy,cdai, strategy, chain,vault, weth, cweth, ibDAI, whale,gov,strategist, interface): rate_limit = 1_000_000_000 *1e18 debt_ratio = 10_000 vault.addStrategy(strategy, debt_ratio, rate_limit, 1000, {"from": gov}) currency.approve(vault, 2 ** 256 - 1, {"from": whale} ) weth.approve(cweth, 2 ** 256 - 1, {"from": whale} ) cweth.mint(1000*1e18, {"from": whale}) cweth.borrow(1, {"from": whale}) whale_deposit = 1000 *1e18 vault.deposit(whale_deposit, {"from": whale}) strategy.harvest({'from': strategist}) cdai.borrow(currency.balanceOf(cdai)-10*1e18, {"from": whale}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) pre = vault.balanceOf(whale) vault.withdraw({"from": whale}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) assert vault.balanceOf(whale) > pre - 10.01*1e18
def test_apr_live_usdt(dai, interface, samdev, Contract, crUsdt, cUsdt, aUsdt, daddy, vault, currency, GenericDyDx, GenericCream, strategy, chain, whale, gov, weth, accounts, rando, fn_isolation): gov = accounts.at(vault.governance(), force=True) decimals = currency.decimals() strategist = samdev form = "{:.2%}" formS = "{:,.0f}" #manualAll = [[dydxPlugin, 0], [creamPlugin, 1000]] #strategy.manualAllocation(manualAll, {"from": strategist}) #print("new alloc") status = strategy.lendStatuses() for j in status: print( f"Lender: {j[0]}, Deposits: {formS.format(j[1]/1e18)}, APR: {form.format(j[2]/1e18)}" ) #strategy.setDebtThreshold(1_000_000 *1e18, {'from': strategist}) #strategy.setProfitFactor(1000, {'from': strategist}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency)
def test_wbtc_live_vault(wbtc, curvePool, Strategy, hCRV, yvault, orb, rewards, chain, yhbtcstrategy, wbtc_vault, ychad, whale, gov, strategist, interface): vault = wbtc_vault strategy = strategist.deploy(Strategy, vault, 2 * 1e8) currency = interface.ERC20(vault.token()) debt_ratio = 10_000 vault.addStrategy(strategy, debt_ratio, 0, 2**256 - 1, 1000, {"from": gov}) vault.setManagementFee(0, {"from": gov}) vault.setPerformanceFee(0, {"from": gov}) currency.approve(vault, 2**256 - 1, {"from": whale}) print(currency.balanceOf(whale) / 1e8) whalebefore = currency.balanceOf(whale) whale_deposit = 2 * 1e8 vault.deposit(whale_deposit, {"from": whale}) strategy.harvest({'from': gov}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) chain.sleep(1000) chain.mine(1) strategy.harvest({'from': gov}) #print(strategy.curveTokenToWant(1e8)) #print(yvault.totalSupply()) #assert strategy.curveTokensInYVault() == yvault.balanceOf(strategy) print(yvault.balanceOf(strategy) / 1e18) yvault.earn({'from': ychad}) print(hCRV.balanceOf(yvault)) #print("Virtual price: ", hCRV.get_virtual_price()) #yhbtcstrategy.deposit() #genericStateOfStrat(strategy, currency, vault) #genericStateOfVault(vault, currency) chain.sleep(2591000) chain.mine(1) yhbtcstrategy.harvest({'from': orb}) strategy.harvest({'from': gov}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) print("\nEstimated APR: ", "{:.2%}".format( ((vault.totalAssets() - 2 * 1e8) * 12) / (2 * 1e8))) chain.sleep(21600) # wait six hours so we get full harvest chain.mine(1) vault.withdraw(vault.balanceOf(whale), whale, 100, {"from": whale}) #vault.withdraw(vault.balanceOf(strategist), strategist, 100, {"from": strategist}) #vault.withdraw(vault.balanceOf(rewards), rewards, 100, {"from": rewards}) print("\nWithdraw") #genericStateOfStrat(strategy, currency, vault) #genericStateOfVault(vault, currency) balanceAfter = currency.balanceOf(whale) print("Whale profit: ", (currency.balanceOf(whale) - whalebefore) / 1e8) print( "Whale profit %: ", "{:.2%}".format( ((currency.balanceOf(whale) - whalebefore) / whale_deposit) * 12))
def test_live2(currency, interface, samdev, Contract, ychad, live_Alpha_Homo_2, live_vault_weth_2, live_strat_weth_2, chain, whale, gov, rando, fn_isolation, accounts): gov = ychad decimals = currency.decimals() strategist = samdev strategy = live_strat_weth_2 vault = live_vault_weth_2 ms = accounts.at("0x16388463d60ffe0661cf7f1f31a7d658ac790ff7", force=True) #genericStateOfStrat(strategy, currency, vault) #genericStateOfVault(vault, currency) vault.updateStrategyDebtRatio(strategy, 0, {"from": ms}) strategy.harvest({"from": ms}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) #currency.approve(vault, 2 ** 256 - 1, {"from": whale}) #currency.approve(vault, 2 ** 256 - 1, {"from": rando}) #whale_deposit = 100 * (10 ** (decimals)) #currency.transfer(rando, whale_deposit, {"from": whale}) #vault.deposit(whale_deposit, {"from": whale}) form = "{:.2%}" formS = "{:,.0f}" status = strategy.lendStatuses() for j in status: print( f"Lender: {j[0]}, Deposits: {formS.format(j[1]/1e18)}, APR: {form.format(j[2]/1e18)}" )
def test_add_strat(live_vault_dai3, Contract,usdc, web3, accounts, chain, cdai, comp, dai, live_strategy_usdc3,live_vault_usdc3, live_strategy_dai3,live_gov, currency, whale,samdev): strategist = samdev strategy = live_strategy_usdc3 vault = live_vault_usdc3 currency = usdc gov = live_gov stateOfStrat(strategy, currency, comp) genericStateOfVault(vault, currency) vault.addStrategy( strategy, 2 ** 256 - 1,2 ** 256 - 1, 1000, # 0.5% performance fee for Strategist {"from": gov} ) #amount = Wei('50000 ether') #print(dai.balanceOf(whale)/1e18) #dai.approve(vault, amount, {'from': whale}) #vault.deposit(amount, {'from': whale}) chain.mine(1) strategy.harvest({'from': strategist}) stateOfStrat(strategy, currency, comp) genericStateOfVault(vault, currency) genericStateOfStrat(strategy,currency, vault )
def test_end_market(live_strategy, interface, bpool, accounts, live_vault, chain, ntrumpWhale, samdev, dai, ntrump): marketAddress = "0x1EBb89156091EB0d59603C18379C03A5c84D7355" reporter = accounts.at('0xCea6572113dEA36f7d368df8679914b6187C7f18', force=True) market = interface.IMarket(marketAddress) assert market.isForkingMarket() == False toGo = market.getEndTime() - chain.time() chain.sleep(toGo + 1) assert chain.time() > market.getEndTime() #chain.sleep(0*3600) payouts = [0, 1000, 0] #market creator does initial report market.doInitialReport(payouts, "some", 0, {'from': reporter}) #wait for dispute window to end chain.sleep(86400 * 8) market.finalize({'from': reporter}) assert market.isFinalized() == True assert live_strategy.harvestTrigger(1e16) == False ntrump.claim(ntrumpWhale, {'from': ntrumpWhale}) genericStateOfStrat(live_strategy, dai, live_vault) genericStateOfVault(live_vault, dai) assert live_strategy.harvestTrigger(1e16) == True live_strategy.harvest({'from': samdev}) assert live_vault.pricePerShare() > 1e18 #profit genericStateOfStrat(live_strategy, dai, live_vault) genericStateOfVault(live_vault, dai)
def test_live_status2(web3, chain, live_vault, live_strategy, comp,dai, samdev): stateOfStrat(live_strategy, dai, comp) stateOfVault(live_vault, live_strategy) genericStateOfStrat(live_strategy, dai, live_vault) genericStateOfVault(live_vault, dai)
def test_usdt(Vault, StrategyUSDTypool, usdt_whale, gov, usdt): # deploy usdt vault usdt_vault = gov.deploy(Vault, usdt, gov, gov, '', '') print(f'type of vault: {type(usdt_vault)} @ {usdt_vault}') # deploy usdt strategy usdt_strategy = gov.deploy(StrategyUSDTypool, usdt_vault) print(f'type of strategy: {type(usdt_strategy)} @ {usdt_strategy}') # activate the strategy from vault view usdt_vault.addStrategy(usdt_strategy, 2**64, 2**64, 1000, {'from': gov}) print(f'credit of strategy: {usdt_vault.creditAvailable(usdt_strategy)}') # rm yvusdt's guestlist usdt_vault.setGuestList('0x0000000000000000000000000000000000000000', {'from': gov}) print(f'yvusdt guest list: {usdt_vault.guestList()}') # approve usdt vault to use usdt usdt.approve(usdt_vault, 2**256 - 1, {'from': usdt_whale}) # start deposit print('\n=== deposit 100 usdt ===') print( f'whale\'s usdt balance before deposit: {usdt.balanceOf(usdt_whale)/1e6}' ) deposit_amount = Wei('100 ether') / 1e12 usdt_vault.deposit(deposit_amount, {'from': usdt_whale}) print( f'whale\'s usdt balance after deposit: {usdt.balanceOf(usdt_whale)/1e6}' ) # start strategy print('\n=== harvest usdt ===') usdt_strategy.harvest({'from': gov}) print('harvest done') print('\n=== usdt status ===') genericStateOfStrat(usdt_strategy, usdt, usdt_vault) genericStateOfVault(usdt_vault, usdt) # withdraw print('\n=== withdraw usdt ===') print(f'whale\'s usdt vault share: {usdt_vault.balanceOf(usdt_whale)/1e6}') usdt_vault.withdraw(Wei('1 ether') / 1e12, {'from': usdt_whale}) print(f'withdraw 1 share of usdt done') print(f'whale\'s usdt vault share: {usdt_vault.balanceOf(usdt_whale)/1e6}') # withdraw all print('\n=== withdraw all usdt ===') print(f'whale\'s usdt vault share: {usdt_vault.balanceOf(usdt_whale)/1e6}') usdt_vault.withdraw({'from': usdt_whale}) print(f'withdraw all usdt') print(f'whale\'s usdt vault share: {usdt_vault.balanceOf(usdt_whale)/1e6}') # call tend print('\ncall tend') usdt_strategy.tend() print('tend done')
def test_add_keeper(live_vault_dai2, Contract, web3, accounts, chain, cdai, comp, dai, live_strategy_dai2,currency, whale,samdev): strategist = samdev strategy = live_strategy_dai2 vault = live_vault_dai2 #stateOfStrat(strategy, dai, comp) #genericStateOfVault(vault, dai) keeper = Contract.from_explorer("0x13dAda6157Fee283723c0254F43FF1FdADe4EEd6") kp3r = Contract.from_explorer("0x1cEB5cB57C4D4E2b2433641b95Dd330A33185A44") #strategy.setKeeper(keeper, {'from': strategist}) #carlos = accounts.at("0x73f2f3A4fF97B6A6d7afc03C449f0e9a0c0d90aB", force=True) #keeper.addStrategy(strategy, 1700000, 10, {'from': carlos}) bot = accounts.at("0xfe56a0dbdad44Dd14E4d560632Cc842c8A13642b", force=True) assert keeper.harvestable(strategy) == False depositAmount = Wei('3500 ether') deposit(depositAmount, whale, currency, vault) assert keeper.harvestable(strategy) == False depositAmount = Wei('1000 ether') deposit(depositAmount, whale, currency, vault) assert keeper.harvestable(strategy) == True keeper.harvest(strategy, {'from': bot}) balanceBefore = kp3r.balanceOf(bot) #print(tx.events) chain.mine(4) #assert kp3r.balanceOf(bot) > balanceBefore #strategy.harvest({'from': strategist}) assert keeper.harvestable(strategy) == False stateOfStrat(strategy, dai, comp) genericStateOfVault(vault, dai) #stateOfStrat(strategy, dai, comp) #stateOfVault(vault, strategy) #depositAmount = Wei('1000 ether') #deposit(depositAmount, whale, currency, vault) #stateOfStrat(strategy, dai, comp) #genericStateOfVault(vault, dai) #strategy.harvest({'from': strategist}) #stateOfStrat(strategy, dai, comp) #genericStateOfVault(vault, dai)
def test_snapshot(currency, Strategy, live_strategy2, live_vault, chain, whale, samdev, interface): strategy = live_strategy2 vault = live_vault currency = interface.ERC20(vault.token()) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) strategy.harvest({'from': samdev}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency)
def test_shutdown(live_strategy_dai2,live_vault_dai2,live_strategy_usdc3, live_strategy_usdc4,live_vault_usdc3, live_strategy_dai4, Contract, usdc, web3,live_gov, accounts, chain, cdai, comp, dai, currency, whale,samdev): stateOfStrat(live_strategy_dai2, dai, comp) live_vault_dai2.revokeStrategy(live_strategy_dai2, {'from': samdev}) stateOfStrat(live_strategy_dai2, dai, comp) live_strategy_dai2.harvest({'from': samdev}) live_strategy_dai2.harvest({'from': samdev}) stateOfStrat(live_strategy_dai2, dai, comp) genericStateOfVault(live_vault_dai2, dai)
def test_dai(Vault, StrategyDAI3pool, dai_vault, dai_whale, gov, dai): # deploy dai strategy dai_strategy = gov.deploy(StrategyDAI3pool, dai_vault) print(f'type of strategy: {type(dai_strategy)} @ {dai_strategy}') # activate the strategy from vault view dai_vault.addStrategy(dai_strategy, 2**64, 2**64, 1000, {'from': gov}) print(f'credit of strategy: {dai_vault.creditAvailable(dai_strategy)}') # rm yvdai's guestlist dai_vault.setGuestList('0x0000000000000000000000000000000000000000', {'from': gov}) print(f'yvdai guest list: {dai_vault.guestList()}') # approve dai vault to use dai dai.approve(dai_vault, 2**256 - 1, {'from': dai_whale}) # start deposit print('\n=== deposit 100 dai ===') print( f'whale\'s dai balance before deposit: {dai.balanceOf(dai_whale)/1e18}' ) deposit_amount = Wei('100 ether') dai_vault.deposit(deposit_amount, {'from': dai_whale}) print( f'whale\'s dai balance after deposit: {dai.balanceOf(dai_whale)/1e18}' ) # start strategy print('\n=== harvest dai ===') dai_strategy.harvest({'from': gov}) print('harvest done') print('\n=== dai status ===') genericStateOfStrat(dai_strategy, dai, dai_vault) genericStateOfVault(dai_vault, dai) # withdraw print('\n=== withdraw dai ===') print(f'whale\'s dai vault share: {dai_vault.balanceOf(dai_whale)/1e18}') dai_vault.withdraw(Wei('1 ether'), {'from': dai_whale}) print(f'withdraw 1 share of dai done') print(f'whale\'s dai vault share: {dai_vault.balanceOf(dai_whale)/1e18}') # withdraw all print('\n=== withdraw all dai ===') print(f'whale\'s dai vault share: {dai_vault.balanceOf(dai_whale)/1e18}') dai_vault.withdraw({'from': dai_whale}) print(f'withdraw all dai') print(f'whale\'s dai vault share: {dai_vault.balanceOf(dai_whale)/1e18}') # call tend print('\ncall tend') dai_strategy.tend() print('tend done')
def test_hbtc_1(currency,strategy,curvePool, hCRV,yvaultv2, orb,rewards,chain,yhbtcstrategyv2,vault, ychad, whale,gov,strategist, interface): yvault = yvaultv2 yvault.setDepositLimit(10_000 * 1e18, {'from': ychad}) debt_ratio = 10_000 vault.addStrategy(strategy, debt_ratio,0, 2 ** 256 - 1, 1000, {"from": gov}) vault.setManagementFee(0, {"from": gov}) vault.setPerformanceFee(0, {"from": gov}) currency.approve(vault, 2 ** 256 - 1, {"from": whale} ) whalebefore = currency.balanceOf(whale) whale_deposit = 2 *1e18 vault.deposit(whale_deposit, {"from": whale}) strategy.harvest({'from': strategist}) #print(strategy.curveTokenToWant(1e18)) #print(yvault.totalSupply()) #assert strategy.curveTokensInYVault() == yvault.balanceOf(strategy) #print(yvault.balanceOf(strategy)) #yvault.earn({'from': ychad}) yhbtcstrategyv2.harvest({'from': ychad}) print(hCRV.balanceOf(yvault)) #yhbtcstrategy.deposit() #genericStateOfStrat(strategy, currency, vault) #genericStateOfVault(vault, currency) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) chain.sleep(2592000) chain.mine(1) yhbtcstrategyv2.harvest({'from': orb}) chain.sleep(21600) chain.mine(1) strategy.harvest({'from': strategist}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) print("\nEstimated APR: ", "{:.2%}".format(((vault.totalAssets()-2*1e18)*12)/(2*1e18))) chain.sleep(21600) chain.mine(1) vault.transferFrom(strategy, strategist, vault.balanceOf(strategy), {"from": strategist}) print("\nWithdraw") vault.withdraw(vault.balanceOf(whale), whale, 100, {"from": whale}) vault.withdraw(vault.balanceOf(strategist), strategist, 100, {"from": strategist}) #vault.withdraw(vault.balanceOf(rewards), rewards, 100, {"from": rewards}) #genericStateOfStrat(strategy, currency, vault) #genericStateOfVault(vault, currency) balanceAfter = currency.balanceOf(whale) print("Whale profit: ", (currency.balanceOf(whale) - whalebefore)/1e18) print("Whale profit %: ", "{:.2%}".format(((currency.balanceOf(whale) - whalebefore)/whale_deposit)*12))
def test_live2( currency, interface, samdev, Contract, ychad, live_Alpha_Homo_2, live_vault_weth_2, live_strat_weth_2, chain, whale, gov, rando, fn_isolation, ): gov = ychad decimals = currency.decimals() strategist = samdev strategy = live_strat_weth_2 vault = live_vault_weth_2 addresses = [whale] permissions = [True] print(strategy) print(vault) guestList = Contract("0xcB16133a37Ef19F90C570B426292BDcca185BF47") vault.setDepositLimit(500 * 1e18, {"from": gov}) vault.setGuestList(guestList, {"from": gov}) print("guest list, ", vault.guestList()) vault.addStrategy(strategy, 500 * 1e18, 0, 2**256 - 1, 1000, {"from": gov}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) currency.approve(vault, 2**256 - 1, {"from": whale}) currency.approve(vault, 2**256 - 1, {"from": rando}) whale_deposit = 100 * (10**(decimals)) currency.transfer(rando, whale_deposit, {"from": whale}) vault.deposit(whale_deposit, {"from": whale}) strategy.harvest({"from": strategist}) form = "{:.2%}" formS = "{:,.0f}" status = strategy.lendStatuses() for j in status: print( f"Lender: {j[0]}, Deposits: {formS.format(j[1]/1e18)}, APR: {form.format(j[2]/1e18)}" )
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 test_screenshot(live_vault_dai2,live_vault_dai3,live_strategy_dai3, Contract, web3,live_gov, accounts, chain, cdai, comp, dai, live_strategy_dai2,currency, whale,samdev): strategist = samdev strategy = live_strategy_dai3 vault = live_vault_dai3 stateOfStrat(strategy, dai, comp) genericStateOfVault(vault, dai) strategy.harvest({'from': strategist}) stateOfStrat(strategy, currency, comp) genericStateOfVault(vault, currency) genericStateOfStrat(strategy,currency, vault )
def test_live_status(web3, chain, live_vault, live_strategy, comp,dai, samdev): stateOfStrat(live_strategy, dai, comp) stateOfVault(live_vault, live_strategy) genericStateOfStrat(live_strategy, dai, live_vault) genericStateOfVault(live_vault, dai) #withdraw(100,samdev, dai, live_vault) genericStateOfStrat(live_strategy, dai, live_vault) genericStateOfVault(live_vault, dai) wait(10, chain) print('\n Harvest') live_strategy.harvest({'from': samdev}) genericStateOfStrat(live_strategy, dai, live_vault) genericStateOfVault(live_vault, dai) stateOfStrat(live_strategy, dai, comp) stateOfVault(live_vault, live_strategy) wait(10, chain) print('\n Harvest') live_strategy.harvest({'from': samdev}) genericStateOfStrat(live_strategy, dai, live_vault) genericStateOfVault(live_vault, dai) stateOfStrat(live_strategy, dai, comp) stateOfVault(live_vault, live_strategy)
def test_revoke_all( dai, interface, samdev, Contract, Strategy, daddy, live_guest_list, GenericDyDx, GenericCream, live_vault_dai_030, live_strat_weth_032, live_strat_dai_030, live_dydxdai, live_creamdai, chain, whale, gov, weth, accounts, rando, fn_isolation, ): whale = accounts.at('0x014de182c147f8663589d77eadb109bf86958f13', force=True) gov = daddy currency = dai decimals = currency.decimals() strategist = samdev #dydxPlugin = strategist.deploy(GenericDyDx, strategy, "DyDx") #creamPlugin = strategist.deploy(GenericCream, strategy, "Cream", crDai) dydxPlugin = live_dydxdai creamPlugin = live_creamdai vault = live_vault_dai_030 #tx = live_strat_weth_032.clone(vault, {'from': strategist}) #strategy = Strategy.at(tx.events['Cloned']["clone"]) strategy = Strategy.at(vault.withdrawalQueue(0)) vault.revokeStrategy(strategy, {'from': gov}) vault.removeStrategyFromQueue(s1, {'from': gov}) #vault.updateStrategyDebtRatio(strategy, 0, {'from': gov}) strategy.harvest({"from": strategist}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency)
def test_snapshot_both(live_vault_dai_030, live_strategy_dai_030, live_vault_usdc_030, live_strategy_usdc_030, Contract, whale, web3, live_gov, accounts, chain, cdai, comp, dai, usdc, currency, samdev): strategist = samdev strategy = live_strategy_dai_030 vault = live_vault_dai_030 print("\nDAI") stateOfStrat(live_strategy_dai_030, dai, comp) genericStateOfVault(live_vault_dai_030, dai) genericStateOfStrat(live_strategy_dai_030, dai, live_vault_dai_030) print("\nUSDC") stateOfStrat(live_strategy_usdc_030, usdc, comp) genericStateOfVault(live_vault_usdc_030, usdc) genericStateOfStrat(live_strategy_usdc_030, usdc, live_vault_usdc_030)
def test_migrate_live(currency, Strategy, live_strategy, live_vault, chain, whale, samdev, interface): strategy = live_strategy vault = live_vault strategist = samdev gov = samdev strategy.harvest({'from': strategist}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) strategy2 = strategist.deploy(Strategy, vault) vault.migrateStrategy(strategy, strategy2, {'from': gov}) genericStateOfStrat(strategy, currency, vault) genericStateOfStrat(strategy2, currency, vault) genericStateOfVault(vault, currency)
def test_migrate(currency,Strategy, ychad, strategy,yvault, chain,vault, whale,gov,strategist, interface): rate_limit = 1_000_000_000 *1e18 debt_ratio = 10_000 vault.addStrategy(strategy, debt_ratio, 0, 2 ** 256 - 1, 1000, {"from": gov}) currency.approve(vault, 2 ** 256 - 1, {"from": whale} ) whale_deposit = 100 *1e18 vault.deposit(whale_deposit, {"from": whale}) strategy.harvest({'from': strategist}) yvault.earn({'from': ychad}) strategy2 = strategist.deploy(Strategy, vault, 2*1e8) vault.migrateStrategy(strategy, strategy2, {'from': gov}) genericStateOfStrat(strategy, currency, vault) genericStateOfStrat(strategy2, currency, vault) genericStateOfVault(vault, currency)
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_030_live( currency, interface, samdev, Contract, devychad, live_guest_list, AlphaHomo, live_vault_weth_031, live_strat_weth_031, chain, whale, gov, weth, rando, fn_isolation, ): gov = samdev decimals = currency.decimals() strategist = samdev vault = live_vault_weth_031 strategy = live_strat_weth_031 weth.approve(vault, 2**256 - 1, {"from": whale}) firstDeposit = 100 * 1e18 vault.deposit(firstDeposit, {"from": whale}) strategy.harvest({"from": strategist}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) form = "{:.2%}" formS = "{:,.0f}" status = strategy.lendStatuses() for j in status: print( f"Lender: {j[0]}, Deposits: {formS.format(j[1]/1e18)}, APR: {form.format(j[2]/1e18)}" )
def test_deposit_live_dai(live_vault_dai_030, live_strategy_dai_030, Contract, whale, web3, live_gov, accounts, chain, cdai, comp, dai, currency, samdev): strategist = samdev strategy = live_strategy_dai_030 vault = live_vault_dai_030 stateOfStrat(strategy, currency, comp) genericStateOfVault(vault, currency) genericStateOfStrat(strategy, currency, vault) amount = Wei('499000 ether') dai.approve(vault, amount, {'from': whale}) vault.deposit(amount, {'from': whale}) strategy.harvest({'from': strategist}) stateOfStrat(strategy, currency, comp) genericStateOfVault(vault, currency) genericStateOfStrat(strategy, currency, vault)
def test_weth_mkrdaidelegate(web3, chain, Vault, Strategy, GuestList, live_dai_vault, live_weth_vault, live_dai_strategy, whale, gov, dai, weth, dev): weth.approve(live_weth_vault, 2 ** 256 - 1, {"from": whale} ) # deploy weth strategy strategy = dev.deploy(Strategy, live_weth_vault) print('cdp id: {}'.format(strategy.cdpId())) print(f'type of strategy: {type(strategy)} @ {strategy}') print(f'type of weth vault: {type(live_weth_vault)} @ {live_weth_vault}') # activate the strategy from vault view live_weth_vault.addStrategy(strategy, 2**256 - 1, 2**256 - 1, 1000, {"from": gov}) print(f'credit of strategy: {live_weth_vault.creditAvailable(strategy)}') # uplift the dai vault deposit limit for weth strategy live_dai_vault.setDepositLimit(1_000_000*1e18, {'from': gov}) # start deposit deposit_amount = Wei('10 ether') live_weth_vault.deposit(deposit_amount, {"from": whale}) # let bouncer to put weth strategy in the yvdai guestlist guest_list = GuestList.at(live_dai_vault.guestList()) print(f'yvdai guest list: {guest_list}') guest_list.invite_guest(strategy, {'from': dev}) print(f'successfully added: {guest_list.authorized(strategy, 1e18)}') print("\n****** Harvest Weth ******") #print(f'price: {strategy._getPrice({"from": dev})} ') strategy.harvest({'from': dev}) print("\n****** Weth ******") genericStateOfStrat(strategy, weth, live_weth_vault) genericStateOfVault(live_weth_vault, weth) print("\n****** Dai ******") genericStateOfStrat(live_dai_strategy, dai, live_dai_vault) genericStateOfVault(live_dai_vault, dai) print("\n****** Harvest Dai ******") live_dai_strategy.harvest({'from': dev}) print("\n****** Weth ******") genericStateOfStrat(strategy, weth, live_weth_vault) genericStateOfVault(live_weth_vault, weth) print("\n****** Dai ******") genericStateOfStrat(live_dai_strategy, dai, live_dai_vault) genericStateOfVault(live_dai_vault, dai) # call tend print('\ncall tend') strategy.tend() print('tend done')
def test_live_add_usdc(currency,Strategy, live_strategy, Contract, usdc, strategist, ibUSDC, live_usdc_comp_strategy, live_vault_usdc, ychad): vault = live_vault_usdc strategy = strategist.deploy(Strategy, vault, ibUSDC) currency = usdc vault.updateStrategyDebtRatio(live_usdc_comp_strategy, 8_800, {'from': ychad}) vault.addStrategy(strategy, 1_000, 0, 1000, {"from": ychad}) live_usdc_comp_strategy.harvest({'from': ychad}) live_usdc_comp_strategy.harvest({'from': ychad}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) strategy.harvest({'from': ychad}) genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency)
def test_immediate_withdraw(currency,strategy, rewards,chain,vault,cdai, ibDAI,whale,gov,strategist, interface): rate_limit = 1_000_000_000 *1e18 debt_ratio = 10_000 vault.addStrategy(strategy, debt_ratio, rate_limit, 1000, {"from": gov}) currency.approve(vault, 2 ** 256 - 1, {"from": whale} ) whalebefore = currency.balanceOf(whale) whale_deposit = 10_000 *1e18 vault.deposit(whale_deposit, {"from": whale}) strategy.harvest({'from': strategist}) assert currency.balanceOf(strategy) ==0 vault.withdraw({"from": whale}) vault.withdraw({"from": rewards}) print("\nWithdraw") genericStateOfStrat(strategy, currency, vault) genericStateOfVault(vault, currency) whaleP = (currency.balanceOf(whale) - whalebefore) print("Whale profit: ", whaleP/1e18)