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)
