def test_unknown_2(web3,StrategyUniswapPairPickle, strategy_generic, Vault, interface, chain,uni_wethwbtc, whaleU, accounts):
starting_balance = uni_wethwbtc.balanceOf(whaleU)
pjar = interface.PickleJar('0xc80090aa05374d336875907372ee4ee636cbc562')
pboss = accounts.at('0xf00d98806a785bb0e1854a0ccc8a39c9c4f4316a', force=True)
#deploy vault
vault = whaleU.deploy(
Vault, uni_wethwbtc, whaleU, whaleU, "ss", "sss"
)
strategy = whaleU.deploy(StrategyUniswapPairPickle, vault, pjar, 15)
deposit_limit = Wei('10 ether')
vault.addStrategy(strategy, deposit_limit, deposit_limit, 50, {"from": whaleU})
deposit(Wei('0.0001 ether'), whaleU, uni_wethwbtc, vault)
strategy.harvest( {'from': whaleU})
for i in range(20):
pjar.earn({'from': pboss})
chain.mine(10)
withdraw( 10, whaleU, uni_wethwbtc, vault)
strategy.harvest( {'from': whaleU})
strState = vault.strategies(strategy)
totalDebt = strState[5]
estimateAssets = strategy.estimatedTotalAssets()
percentd = totalDebt/estimateAssets
print(f'totalDebt/estimateAssets: {percentd:.5%}')
def normal_operation(chain, ychad, vault, user, whale, strategy, dai):
print('\n---starting normal operations----')
for i in count(1):
waitBlock = random.randint(0,20)
print(f'\n----wait {waitBlock} blocks----')
chain.mine(waitBlock)
action = random.randint(0,3)
if action ==0:
harvest(strategy, user)
elif action == 1:
withdraw(random.randint(10,100), strategy,whale, dai, vault)
elif action == 2:
earn(strategy, vault, user)
elif action == 3:
deposit(str(f'{random.randint(1,100000)} ether'), whale, dai, vault)
def test_withdraw_all(web3, chain, comp, vault, largerunningstrategy, whale,
gov, dai, strategist, isolation):
balance_before = dai.balanceOf(strategist)
stateOfStrat(largerunningstrategy, dai, comp)
stateOfVault(vault, largerunningstrategy)
amount = Wei('10000 ether')
deposit(amount, strategist, dai, vault)
harvest(largerunningstrategy, gov, vault)
wait(50, chain)
harvest(largerunningstrategy, gov, vault)
stateOfStrat(largerunningstrategy, dai, comp)
stateOfVault(vault, largerunningstrategy)
withdraw(1, strategist, dai, vault)
profitW = dai.balanceOf(strategist) - balance_before
profit = profitW.to('ether')
print(f'profit: {profit:.5f}')
def test_full_generic(strategy_changeable, web3, chain, Vault, currency, whale,
strategist):
#our humble strategist is going to publish both the vault and the strategy
starting_balance = currency.balanceOf(strategist)
#deploy vault
vault = strategist.deploy(Vault, currency, strategist, strategist,
"TestVault", "Amount")
deposit_limit = Wei('1000000 ether')
#set limit to the vault
vault.setDepositLimit(deposit_limit, {"from": strategist})
#deploy strategy
strategy = strategist.deploy(strategy_changeable, vault)
vault.addStrategy(strategy, deposit_limit, deposit_limit, 50,
{"from": strategist})
genericStateOfStrat(strategy, currency, vault)
genericStateOfVault(vault, currency)
#our humble strategist deposits some test funds
depositAmount = Wei('501 ether')
deposit(depositAmount, strategist, currency, vault)
#print(vault.creditAvailable(strategy))
genericStateOfStrat(strategy, currency, vault)
genericStateOfVault(vault, currency)
assert strategy.estimatedTotalAssets() == 0
assert strategy.harvestTrigger(1) == True
harvest(strategy, strategist, vault)
genericStateOfStrat(strategy, currency, vault)
genericStateOfVault(vault, currency)
assert strategy.estimatedTotalAssets(
) >= depositAmount * 0.999999 #losing some dust is ok
assert strategy.harvestTrigger(1) == False
#whale deposits as well
whale_deposit = Wei('1000 ether')
deposit(whale_deposit, whale, currency, vault)
assert strategy.harvestTrigger(1000000 * 30 * 1e9) == True
harvest(strategy, strategist, vault)
genericStateOfStrat(strategy, currency, vault)
genericStateOfVault(vault, currency)
for i in range(15):
waitBlock = random.randint(10, 50)
print(f'\n----wait {waitBlock} blocks----')
chain.mine(waitBlock)
#if harvest condition harvest. if tend tend
harvest(strategy, strategist, vault)
tend(strategy, strategist)
something = True
action = random.randint(0, 9)
if action == 1:
withdraw(random.randint(50, 100), whale, currency, vault)
elif action == 2:
withdraw(random.randint(50, 100), whale, currency, vault)
elif action == 3:
deposit(Wei(str(f'{random.randint(10,100)} ether')), whale,
currency, vault)
else:
something = False
if something:
genericStateOfStrat(strategy, currency, vault)
genericStateOfVault(vault, currency)
#strategist withdraws
withdraw(1, strategist, currency, vault)
genericStateOfStrat(strategy, currency, vault)
genericStateOfVault(vault, currency)
profit = currency.balanceOf(strategist) - starting_balance
print(Wei(profit).to('ether'), ' profit')
print(vault.strategies(strategy)[6].to('ether'), ' total returns of strat')
def test_full_live(web3, chain, comp, Vault, YearnDaiCompStratV2, dai, whale,
strategist, cdai):
#our humble strategist is going to publish both the vault and the strategy
# this is to mint small amount of dai reguarly to replicate people interacting with cdai contract
dai.approve(cdai, 2**256 - 1, {"from": whale})
starting_balance = dai.balanceOf(strategist)
#deploy vault
vault = strategist.deploy(Vault, dai, strategist, strategist,
"Ytest DAI Vault V2", "ytDAI2")
#100k dai limit to begin with
deposit_limit = Wei('1000000 ether')
#set limit to the vault
vault.setDepositLimit(deposit_limit, {"from": strategist})
#deploy strategy
strategy = strategist.deploy(YearnDaiCompStratV2, vault)
strategy.setGasFactor(1, {"from": strategist})
assert (strategy.gasFactor() == 1)
strategy.setMinCompToSell(Wei('0.1 ether'), {"from": strategist})
assert (strategy.minCompToSell() == Wei('0.1 ether'))
#Current comp/eth rate
compEthRate = strategy.getCompValInWei(Wei('1 ether'))
print('Current comp/eth rate:', compEthRate)
#enable the strategy
rate_limit = deposit_limit
vault.addStrategy(strategy, rate_limit, rate_limit, 50,
{"from": strategist})
#our humble strategist deposits some test funds
deposit(Wei('1000 ether'), strategist, dai, vault)
stateOfStrat(strategy, dai, comp)
stateOfVault(vault, strategy)
assert strategy.estimatedTotalAssets() == 0
harvest(strategy, strategist, vault)
#whale deposits as well
deposit(Wei('1000 ether'), whale, dai, vault)
for i in range(15):
#assertCollateralRatio(strategy)
waitBlock = random.randint(10, 50)
print(f'\n----wait {waitBlock} blocks----')
chain.mine(waitBlock)
#if harvest condition harvest. if tend tend
print(strategy.predictCompAccrued().to('ether'), ' comp prediction')
print(comp.balanceOf(strategy).to('ether'), ' comp in balance')
harvest(strategy, strategist, vault)
tend(strategy, strategist)
something = True
action = random.randint(0, 9)
if action == 1:
withdraw(random.randint(50, 100), whale, dai, vault)
elif action == 2:
withdraw(random.randint(50, 100), whale, dai, vault)
elif action == 3:
deposit(Wei(str(f'{random.randint(10000,100000)} ether')), whale,
dai, vault)
elif action > 3 and action < 6:
cdai.mint(1, {"from": whale})
else:
something = False
if something:
stateOfStrat(strategy, dai, comp)
stateOfVault(vault, strategy)
#strategist withdraws
withdraw(1, strategist, dai, vault)
stateOfStrat(strategy, dai, comp)
stateOfVault(vault, strategy)
profit = dai.balanceOf(strategist) - starting_balance
print(Wei(profit).to('ether'), ' profit')
print(vault.strategies(strategy)[6], ' total returns of strat')
def test_full_generic(Strategy, web3, chain, cdai, crdai, Vault, currency,
whale, strategist):
# our humble strategist is going to publish both the vault and the strategy
# deploy vault
vault = strategist.deploy(Vault)
vault.initialize(currency, strategist, strategist, "", "", strategist)
deposit_limit = Wei("1_000_000 ether")
# set limit to the vault
vault.setDepositLimit(deposit_limit, {"from": strategist})
# deploy strategy
strategy = strategist.deploy(Strategy, vault, cdai, crdai)
strategy.setMinCompToSell(0.01 * 1e18, {"from": strategist})
rate_limit = 1_000_000_000 * 1e18
debt_ratio = 9_500 # 100%
vault.addStrategy(strategy, debt_ratio, 0, rate_limit, 1000,
{"from": strategist})
genericStateOfStrat(strategy, currency, vault)
genericStateOfVault(vault, currency)
# our humble strategist deposits some test funds
depositAmount = Wei("501 ether")
currency.transfer(strategist, depositAmount, {"from": whale})
starting_balance = currency.balanceOf(strategist)
deposit(depositAmount, strategist, currency, vault)
# print(vault.creditAvailable(strategy))
genericStateOfStrat(strategy, currency, vault)
genericStateOfVault(vault, currency)
assert strategy.estimatedTotalAssets() == 0
assert strategy.harvestTrigger(1e15) == True
strategy.harvest({"from": strategist})
genericStateOfStrat(strategy, currency, vault)
genericStateOfVault(vault, currency)
assert strategy.estimatedTotalAssets() >= depositAmount * 0.999999 * (
debt_ratio / 10_000) # losing some dust is ok
assert strategy.harvestTrigger(1) == False
# whale deposits as well
whale_deposit = Wei("2000 ether")
deposit(whale_deposit, whale, currency, vault)
assert strategy.harvestTrigger(1 * 30 * 1e9) == True
harvest(strategy, strategist, vault)
genericStateOfStrat(strategy, currency, vault)
genericStateOfVault(vault, currency)
for i in range(5):
waitBlock = random.randint(10, 50)
print(f"\n----wait {waitBlock} blocks----")
sleep(chain, waitBlock)
# if harvest condition harvest. if tend tend
harvest(strategy, strategist, vault)
tend(strategy, strategist)
something = True
action = random.randint(0, 9)
if action == 1:
withdraw(random.randint(50, 100), whale, currency, vault)
elif action == 2:
withdraw(random.randint(50, 100), whale, currency, vault)
elif action == 3:
deposit(Wei(str(f"{random.randint(10000,50000)} ether")), whale,
currency, vault)
else:
something = False
if something:
genericStateOfStrat(strategy, currency, vault)
genericStateOfVault(vault, currency)
# strategist withdraws
vault.withdraw({"from": strategist})
genericStateOfStrat(strategy, currency, vault)
genericStateOfVault(vault, currency)
profit = currency.balanceOf(strategist) - starting_balance
print(Wei(profit).to("ether"), " profit")
print(vault.strategies(strategy)[6].to("ether"), " total returns of strat")
def test_optimiser_full_run(usdc, chain, whale, gov, strategist, Vault,
LenderYieldOptimiser, GenericCompound,
GenericCream, GenericDyDx, interface):
starting_balance = usdc.balanceOf(strategist)
currency = usdc
#deploy vault
vault = strategist.deploy(Vault, usdc, strategist, strategist, "", "")
usdc.approve(vault, 2**256 - 1, {"from": whale})
usdc.approve(vault, 2**256 - 1, {"from": strategist})
#deploy strategy
strategy = strategist.deploy(LenderYieldOptimiser, vault)
#cDai = interface.CErc20I('0x5d3a536e4d6dbd6114cc1ead35777bab948e3643')
solo = interface.ISoloMargin('0x1E0447b19BB6EcFdAe1e4AE1694b0C3659614e4e')
cUsdc = interface.CErc20I('0x39AA39c021dfbaE8faC545936693aC917d5E7563')
assert cUsdc.underlying() == vault.token()
crUsdc = interface.CErc20I('0x44fbeBd2F576670a6C33f6Fc0B00aA8c5753b322')
assert crUsdc.underlying() == vault.token()
compoundPlugin = strategist.deploy(GenericCompound, strategy, "Compound",
cUsdc)
creamPlugin = strategist.deploy(GenericCream, strategy, "Cream", crUsdc)
dydxPlugin = strategist.deploy(GenericDyDx, strategy, "DyDx")
strategy.addLender(compoundPlugin, {"from": strategist})
assert strategy.numLenders() == 1
strategy.addLender(creamPlugin, {"from": strategist})
assert strategy.numLenders() == 2
strategy.addLender(dydxPlugin, {"from": strategist})
assert strategy.numLenders() == 3
deposit_limit = 1_000_000_000 * 1e6
vault.addStrategy(strategy, deposit_limit, deposit_limit, 500,
{"from": strategist})
#our humble strategist deposits some test funds
depositAmount = 501 * 1e6
vault.deposit(depositAmount, {"from": strategist})
#print(vault.creditAvailable(strategy))
assert strategy.estimatedTotalAssets() == 0
assert strategy.harvestTrigger(1) == True
strategy.harvest({"from": strategist})
assert strategy.estimatedTotalAssets(
) >= depositAmount * 0.999999 #losing some dust is ok
assert strategy.harvestTrigger(1) == False
#whale deposits as well
whale_deposit = 100_000 * 1e6
vault.deposit(whale_deposit, {"from": whale})
assert strategy.harvestTrigger(1000) == True
strategy.harvest({"from": strategist})
genericStateOfStrat(strategy, currency, vault)
genericStateOfVault(vault, currency)
form = "{:.2%}"
formS = "{:,.0f}"
for i in range(15):
waitBlock = random.randint(10, 50)
cUsdc.mint(0, {"from": whale})
crUsdc.mint(0, {"from": whale})
print(f'\n----wait {waitBlock} blocks----')
chain.mine(waitBlock)
chain.sleep(15 * 30)
#if harvest condition harvest. if tend tend
strategy.harvest({"from": strategist})
something = True
action = random.randint(0, 9)
if action == 1:
withdraw(random.randint(50, 100), whale, currency, vault)
elif action == 2:
withdraw(random.randint(50, 100), whale, currency, vault)
elif action == 3:
depositAm = random.randint(10, 100) * 1e6
print(f'\n----user deposits {depositAm/1e6}----')
vault.deposit(depositAm, {"from": whale})
else:
something = False
if something:
genericStateOfStrat(strategy, currency, vault)
genericStateOfVault(vault, currency)
status = strategy.lendStatuses()
for j in status:
print(
f"Lender: {j[0]}, Deposits: {formS.format(j[1]/1e6)}, APR: {form.format(j[2]/1e18)}"
)
#strategist withdraws
withdraw(1, strategist, currency, vault)
genericStateOfStrat(strategy, currency, vault)
genericStateOfVault(vault, currency)
profit = currency.balanceOf(strategist) - starting_balance
print(profit / 1e6, ' profit')
print(vault.strategies(strategy)[6] / 1e6, ' total returns of strat')
def test_strat_sam(accounts, interface, web3, chain, vault, comp, whale,
YearnDaiCompStratV2, dai, gov):
strategist_and_keeper = accounts[1]
print(strategist_and_keeper)
assert vault.governance() == gov
assert vault.guardian() == gov
assert vault.rewards() == gov
assert vault.token() == dai
# Deploy the Strategy
strategy = strategist_and_keeper.deploy(YearnDaiCompStratV2, vault)
# Addresses
assert strategy.strategist() == strategist_and_keeper
assert strategy.keeper() == strategist_and_keeper
assert strategy.want() == vault.token()
stateOfStrat(strategy, dai, comp)
# Add strategy to the Vault
assert vault.strategies(strategy) == [0, 0, 0, 0, 0, 0, 0]
_debtLimit = Wei('1000000 ether')
_rateLimit = Wei('1000000 ether')
vault.addStrategy(strategy, _debtLimit, _rateLimit, 50, {"from": gov})
assert vault.strategies(strategy) == [
50,
web3.eth.blockNumber,
_debtLimit,
_rateLimit,
web3.eth.blockNumber,
0,
0,
]
print(strategy._predictCompAccrued(), ' comp prediction')
# Nothing was reported yet from the strategy
assert vault.expectedReturn(strategy) == 0
depositLimit = Wei('500000 ether')
vault.setDepositLimit(depositLimit, {"from": gov})
assert vault.depositLimit() == depositLimit
#set compToSell
# Provide funds to the Vault from whale
# Test first with simply 5k as it is the current rate DAI/block
amount = Wei('100000 ether')
deposit(amount, whale, dai, vault)
stateOfStrat(strategy, dai, comp)
stateOfVault(vault, strategy)
# Call harvest in Strategy only when harvestTrigger() --> (true)
harvest(strategy, strategist_and_keeper)
# assert( !strategy.harvestTrigger(0, {'from': strategist_and_keeper}))
stateOfStrat(strategy, dai, comp)
stateOfVault(vault, strategy)
# now lets see 90k
amount = Wei('320000 ether')
deposit(amount, whale, dai, vault)
stateOfStrat(strategy, dai, comp)
stateOfVault(vault, strategy)
harvest(strategy, strategist_and_keeper)
stateOfStrat(strategy, dai, comp)
stateOfVault(vault, strategy)
# Claim COMP and check balance in strategy -> for testing _claimComp() needs to be public
#strategy._claimComp({'from': strategist_and_keeper})
#comp_balance = comp.balanceOf(strategy)
#print(comp_balance.to('ether'), 'comp claimed')
# Call harvest in Strategy only when harvestTrigger() --> (true)
#harvest(strategy, strategist_and_keeper)
stateOfStrat(strategy, dai, comp)
stateOfVault(vault, strategy)
#withdraw(1, strategy, whale, dai, vault)
#vault.setEmergencyShutdown(True, {"from": gov})
while strategy.harvestTrigger(0) == False:
wait(25, chain)
print(strategy._predictCompAccrued().to('ether'), ' comp prediction')
#print('Emergency Exit')
#strategy.setEmergencyExit({"from": gov})
stateOfStrat(strategy, dai, comp)
stateOfVault(vault, strategy)
harvest(strategy, strategist_and_keeper)
stateOfStrat(strategy, dai, comp)
stateOfVault(vault, strategy)
##test migration
print('test migration')
strategy2 = strategist_and_keeper.deploy(YearnDaiCompStratV2, vault)
vault.migrateStrategy(strategy, strategy2, {"from": gov})
print('old strat')
stateOfStrat(strategy, dai, comp)
stateOfVault(vault, strategy)
print('new strat')
stateOfStrat(strategy2, dai, comp)
stateOfVault(vault, strategy2)
withdraw(1, whale, dai, vault)
stateOfStrat(strategy2, dai, comp)
stateOfVault(vault, strategy2)
amount = Wei('320000 ether')
deposit(amount, whale, dai, vault)
stateOfStrat(strategy2, dai, comp)
stateOfVault(vault, strategy2)
harvest(strategy2, strategist_and_keeper)
stateOfStrat(strategy2, dai, comp)
stateOfVault(vault, strategy2)
withdraw(1, whale, dai, vault)
stateOfStrat(strategy2, dai, comp)
stateOfVault(vault, strategy2)
def test_strat_sam(accounts, interface, web3, chain, Vault,
YearnDaiCompStratV2):
gov = accounts[0]
print(gov)
strategist_and_keeper = accounts[1]
print(strategist_and_keeper)
dai = interface.ERC20('0x6b175474e89094c44da98b954eedeac495271d0f')
cdai = interface.ERC20('0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643')
comp = interface.ERC20('0xc00e94Cb662C3520282E6f5717214004A7f26888')
comptroller = interface.ComptrollerI(
'0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B')
# Current COMP speeds
print('COMP speed: ', comptroller.compSpeeds(cdai))
ydai = interface.ERC20('0x16de59092dae5ccf4a1e6439d611fd0653f0bd01')
whale = accounts.at("0xBE0eB53F46cd790Cd13851d5EFf43D12404d33E8",
force=True)
# Deploy the Vault
vault = gov.deploy(Vault, dai, gov, gov, "Yearn DAI v2", "y2DAI")
assert vault.governance() == gov
assert vault.guardian() == gov
assert vault.rewards() == gov
assert vault.token() == dai
# Deploy the Strategy
strategy = strategist_and_keeper.deploy(YearnDaiCompStratV2, vault)
# Addresses
assert strategy.strategist() == strategist_and_keeper
assert strategy.keeper() == strategist_and_keeper
assert strategy.want() == vault.token()
stateOfStrat(strategy, dai)
# Test current price for COMP and DAI using Chainlink
lastExchangeRate = strategy.getLatestExchangeRate()
print('Current exchange rate (COMP/DAI): ', lastExchangeRate)
# Add strategy to the Vault
assert vault.strategies(strategy) == [0, 0, 0, 0, 0, 0, 0]
_debtLimit = Wei('1000000 ether')
_rateLimit = Wei('1000000 ether')
vault.addStrategy(strategy, _debtLimit, _rateLimit, 50, {"from": gov})
assert vault.strategies(strategy) == [
50,
web3.eth.blockNumber,
_debtLimit,
_rateLimit,
web3.eth.blockNumber,
0,
0,
]
print(strategy._predictCompAccrued(), ' comp prediction')
# Nothing was reported yet from the strategy
assert vault.expectedReturn(strategy) == 0
stateOfStrat(strategy, dai)
depositLimit = Wei('500000 ether')
vault.setDepositLimit(depositLimit, {"from": gov})
assert vault.depositLimit() == depositLimit
# Provide funds to the Vault from whale
# Test first with simply 5k as it is the current rate DAI/block
amount = Wei('100000 ether')
deposit(amount, whale, dai, vault)
stateOfStrat(strategy, dai)
stateOfVault(vault, strategy)
# Call harvest in Strategy only when harvestTrigger() --> (true)
harvest(strategy, strategist_and_keeper)
# assert( !strategy.harvestTrigger(0, {'from': strategist_and_keeper}))
stateOfStrat(strategy, dai)
stateOfVault(vault, strategy)
# now lets see 90k
amount = Wei('320000 ether')
deposit(amount, whale, dai, vault)
stateOfStrat(strategy, dai)
stateOfVault(vault, strategy)
harvest(strategy, strategist_and_keeper)
stateOfStrat(strategy, dai)
stateOfVault(vault, strategy)
# Call harvest in Strategy only when harvestTrigger() --> (true)
#harvest(strategy, strategist_and_keeper)
stateOfStrat(strategy, dai)
stateOfVault(vault, strategy)
#withdraw(1, strategy, whale, dai, vault)
#vault.setEmergencyShutdown(True, {"from": gov})
while strategy.harvestTrigger(0) == False:
wait(25, chain)
print(strategy._predictCompAccrued().to('ether'), ' comp prediction')
#print('Emergency Exit')
#strategy.setEmergencyExit({"from": gov})
# Claim COMP and check balance in strategy -> for testing _claimComp() needs to be public
strategy._claimComp({'from': strategist_and_keeper})
comp_balance = comp.balanceOf(strategy)
print(comp_balance.to('ether'), 'comp claimed')
stateOfStrat(strategy, dai)
stateOfVault(vault, strategy)
harvest(strategy, strategist_and_keeper)
stateOfStrat(strategy, dai)
stateOfVault(vault, strategy)
##test migration
print('test migration')
strategy2 = strategist_and_keeper.deploy(YearnDaiCompStratV2, vault)
vault.migrateStrategy(strategy, strategy2, {"from": gov})
print('old strat')
stateOfStrat(strategy, dai)
stateOfVault(vault, strategy)
print('new strat')
stateOfStrat(strategy2, dai)
stateOfVault(vault, strategy2)
withdraw(1, whale, dai, vault)
stateOfStrat(strategy2, dai)
stateOfVault(vault, strategy2)
amount = Wei('320000 ether')
deposit(amount, whale, dai, vault)
stateOfStrat(strategy2, dai)
stateOfVault(vault, strategy2)
harvest(strategy2, strategist_and_keeper)
stateOfStrat(strategy2, dai)
stateOfVault(vault, strategy2)
withdraw(1, whale, dai, vault)
stateOfStrat(strategy2, dai)
stateOfVault(vault, strategy2)
