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_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_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_wind_down_orb(Contract, web3, accounts, chain):
daihard = Contract("0xBFa4D8AA6d8a379aBFe7793399D3DdaCC5bBECBB")
orbStrat = Contract("0x2476eC85e55625Eb658CAFAFe5fdc0FAE2954C85")
gov = accounts.at(daihard.governance(), force=True)
daiStrat = Contract(daihard.withdrawalQueue(0))
daihard.revokeStrategy(daiStrat, {'from': gov})
dai = Contract(daihard.token())
daiStrat.harvest({'from': gov})
orb_vault = Contract(orbStrat.vault())
weth = Contract(orb_vault.token())
gov = accounts.at(orb_vault.governance(), force=True)
orb_vault.revokeStrategy(orbStrat, {'from': gov})
strategist = accounts.at(orbStrat.strategist(), force=True)
orbStrat.harvest({'from': strategist})
print("\n Deposit limit: ", orb_vault)
print("\nEnd balances Strat")
print("WETH: ", weth.balanceOf(orbStrat) / 1e18)
print("yvDAI: ", daihard.balanceOf(orbStrat) / 1e18)
print("DAI: ", dai.balanceOf(orbStrat) / 1e18)
print("\nEnd balances Vault")
print("WETH: ", weth.balanceOf(orb_vault) / 1e18)
print("yvDAI: ", daihard.balanceOf(orb_vault) / 1e18)
print("DAI: ", dai.balanceOf(orb_vault) / 1e18)
genericStateOfStrat(orbStrat, weth, orb_vault)
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_collat_zero(web3, chain, cream, vault, enormousrunningstrategy, whale,
gov, currency, strategist):
dai = currency
stateOfStrat(enormousrunningstrategy, dai, cream)
stateOfVault(vault, enormousrunningstrategy)
enormousrunningstrategy.setCollateralTarget(0, {"from": gov})
lastCollat = enormousrunningstrategy.storedCollateralisation()
while enormousrunningstrategy.storedCollateralisation() > 0.05 * 1e18:
enormousrunningstrategy.harvest({"from": gov})
newCollat = enormousrunningstrategy.storedCollateralisation()
assert lastCollat > newCollat
lastCollat = newCollat
stateOfStrat(enormousrunningstrategy, dai, cream)
stateOfVault(vault, enormousrunningstrategy)
enormousrunningstrategy.setEmergencyExit({"from": gov})
enormousrunningstrategy.harvest({'from': gov})
stateOfStrat(enormousrunningstrategy, dai, cream)
genericStateOfStrat(enormousrunningstrategy, dai, vault)
stateOfVault(vault, enormousrunningstrategy)
strState = vault.strategies(enormousrunningstrategy)
#losses == 0 with elegent big withdrawal
assert strState[7] < 1e16
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_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_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_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_enourmous_exit(web3, chain, comp, vault, enormousrunningstrategy,
whale, gov, dai, strategist):
stateOfStrat(enormousrunningstrategy, dai, comp)
stateOfVault(vault, enormousrunningstrategy)
enormousrunningstrategy.setEmergencyExit({"from": gov})
assert enormousrunningstrategy.emergencyExit()
# genericStateOfStrat(strategy, currency, vault)
# genericStateOfVault(vault, currency)
## emergency shutdown
enormousrunningstrategy.harvest({"from": gov})
stateOfStrat(enormousrunningstrategy, dai, comp)
genericStateOfStrat(enormousrunningstrategy, dai, vault)
stateOfVault(vault, enormousrunningstrategy)
strState = vault.strategies(enormousrunningstrategy)
assert strState[7] == 0 # loss 0
assert strState[5] > 0 # debt > 0
enormousrunningstrategy.harvest({"from": gov})
enormousrunningstrategy.harvest({"from": gov})
stateOfStrat(enormousrunningstrategy, dai, comp)
genericStateOfStrat(enormousrunningstrategy, dai, vault)
stateOfVault(vault, enormousrunningstrategy)
strState = vault.strategies(enormousrunningstrategy)
assert strState[5] == 0 # debt > 0
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_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_debt_increment_weth(weth, Strategy, ironbank, ironWeth, creamdev,
chain, rewards, whale, gov, strategist, rando,
Vault, GenericDyDx, AlphaHomo, interface,
EthCream, EthCompound):
currency = weth
crETH = interface.CEtherI('0xD06527D5e56A3495252A528C4987003b712860eE')
cETH = interface.CEtherI('0x4Ddc2D193948926D02f9B1fE9e1daa0718270ED5')
bank = interface.Bank('0x67B66C99D3Eb37Fa76Aa3Ed1ff33E8e39F0b9c7A')
vault = gov.deploy(Vault)
vault.initialize(weth, gov, rewards, "", "", gov)
vault.setDepositLimit(2**256 - 1, {"from": gov})
weth.approve(vault, 2**256 - 1, {"from": whale})
strategy = strategist.deploy(Strategy, vault, ironWeth)
ironbank._setCreditLimit(strategy, 1_000_000 * 1e18, {'from': creamdev})
ethCreamPlugin = strategist.deploy(EthCream, strategy, "Cream")
strategy.addLender(ethCreamPlugin, {"from": gov})
alphaHomoPlugin = strategist.deploy(AlphaHomo, strategy, "Alpha H**o")
strategy.addLender(alphaHomoPlugin, {"from": gov})
compoundPlugin = strategist.deploy(EthCompound, strategy, "Compound")
strategy.addLender(compoundPlugin, {"from": gov})
dydxPlugin = strategist.deploy(GenericDyDx, strategy, "DyDx")
strategy.addLender(dydxPlugin, {"from": gov})
assert strategy.numLenders() == 4
rate_limit = 1_000_000_000 * 1e18
debt_ratio = 10_000
vault.addStrategy(strategy, debt_ratio, rate_limit, 1000, {"from": gov})
form = "{:.2%}"
formS = "{:,.0f}"
for i in range(10):
firstDeposit = 100 * 1e18
vault.deposit(firstDeposit, {"from": whale})
print("\nDeposit: ", formS.format(firstDeposit / 1e18))
strategy.harvest({"from": strategist})
realApr = strategy.estimatedAPR()
genericStateOfStrat(strategy, currency, vault)
print("\nCurrent APR: ", form.format(realApr / 1e18))
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_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_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_operation(web3, chain, vault, strategy, token, amount, dai, dai_vault,
whale, gov, guardian, strategist):
# whale approve weth vault to use weth
token.approve(vault, 2**256 - 1, {"from": whale})
print('cdp id: {}'.format(strategy.cdpId()))
print(f'type of strategy: {type(strategy)} @ {strategy}')
print(f'type of weth vault: {type(vault)} @ {vault}')
print()
# start deposit
vault.deposit(amount, {"from": whale})
print(f'whale deposit done with {amount/1e18} weth\n')
print("\n****** Initial Status ******")
print("\n****** yfi ******")
genericStateOfStrat(strategy, token, vault)
genericStateOfVault(vault, token)
print("\n****** Dai ******")
genericStateOfVault(dai_vault, dai)
print("\n****** Harvest yfi ******")
strategy.harvest({'from': strategist})
print("\n****** yfi ******")
genericStateOfStrat(strategy, token, vault)
genericStateOfVault(vault, token)
print("\n****** Dai ******")
genericStateOfVault(dai_vault, dai)
# withdraw yfi
print('\n****** withdraw yfi ******')
print(f'whale\'s yfi vault share: {vault.balanceOf(whale)/1e18}')
vault.withdraw(Wei('1 ether'), {"from": whale})
print(f'withdraw 1 ether done')
print(f'whale\'s yfi vault share: {vault.balanceOf(whale)/1e18}')
# transfer dai to strategy due to rounding issue
dai.transfer(strategy, Wei('1 wei'), {"from": gov})
# withdraw all yfi
print('\n****** withdraw all yfi ******')
print(f'whale\'s yfi vault share: {vault.balanceOf(whale)/1e18}')
vault.withdraw({"from": whale})
print(f'withdraw all yfi')
print(f'whale\'s yfi vault share: {vault.balanceOf(whale)/1e18}')
# try call tend
print('\ncall tend')
strategy.tend()
print('tend done')
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_huge_withdrawal(web3, chain, comp, vault, enormousrunningstrategy,
whale, gov, dai, strategist):
stateOfStrat(enormousrunningstrategy, dai, comp)
stateOfVault(vault, enormousrunningstrategy)
print("\nwhale withdraws")
vault.withdraw({"from": whale})
assert (enormousrunningstrategy.estimatedTotalAssets() <
vault.strategies(enormousrunningstrategy)[5])
stateOfStrat(enormousrunningstrategy, dai, comp)
genericStateOfStrat(enormousrunningstrategy, dai, vault)
stateOfVault(vault, enormousrunningstrategy)
enormousrunningstrategy.harvest({"from": gov})
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_migrate(currency, Strategy, strategy, chain, vault, 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})
whale_deposit = 100 * 1e18
vault.deposit(whale_deposit, {"from": whale})
strategy.harvest({'from': strategist})
genericStateOfStrat(strategy, currency, vault)
genericStateOfVault(vault, currency)
chain.sleep(2592000)
chain.mine(1)
strategy.harvest({'from': strategist})
genericStateOfStrat(strategy, currency, vault)
genericStateOfVault(vault, currency)
print(
"\nEstimated APR: ", "{:.2%}".format(
((vault.totalAssets() - 100 * 1e18) * 12) / (100 * 1e18)))
strategy2 = strategist.deploy(Strategy, vault)
vault.migrateStrategy(strategy, strategy2, {'from': gov})
genericStateOfStrat(strategy, currency, vault)
genericStateOfStrat(strategy2, currency, vault)
genericStateOfVault(vault, currency)
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(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)}"
)
