Fix: hasUnderlying param was used incorrectly when set to true

tests/test_dai_ib_live.py

@@ -1,8 +1,8 @@
 from itertools import count
-from brownie import Wei, reverts
+from brownie import Wei, reverts, Contract
 import eth_abi
 from brownie.convert import to_bytes
-from useful_methods import genericStateOfStrat,genericStateOfVault
+from useful_methods import genericStateOfStrat, genericStateOfVault
 import random
 import brownie
 
@@ -12,87 +12,127 @@
 #           - change in loading (from low to high and high to low)
 #           - strategy operation at different loading levels (anticipated and "extreme")
 
-def test_dai_1(usdt,stratms, whale,Strategy, ibCurvePool,strategy_dai_ib, accounts, ib3CRV,ibyvault, orb,rewards,chain,strategy_usdt_ib,live_vault_dai, ychad, gov,strategist, interface):
-
+
+def test_dai_1(
+    usdt,
+    stratms,
+    whale,
+    Strategy,
+    ibCurvePool,
+    strategy_dai_ib,
+    accounts,
+    ib3CRV,
+    ibyvault,
+    orb,
+    rewards,
+    chain,
+    strategy_usdt_ib,
+    live_vault_dai,
+    ychad,
+    gov,
+    strategist,
+    interface,
+):
+
     vault = live_vault_dai
     currency = interface.ERC20(vault.token())
     decimals = currency.decimals()
     gov = accounts.at(vault.governance(), force=True)
     strategy = strategy_dai_ib
 
     yvault = ibyvault
-    #amount = 1000*1e6
-    #amounts = [0, 0, amount]
+    # amount = 1000*1e6
+    # amounts = [0, 0, amount]
     print("curveid: ", strategy.curveId())
-    #print("slip: ", strategy._checkSlip(amount))
-    #print("expectedOut: ", amount/strategy.virtualPriceToWant())
+    # print("slip: ", strategy._checkSlip(amount))
+    # print("expectedOut: ", amount/strategy.virtualPriceToWant())
     print("curve token: ", strategy.curveToken())
     print("ytoken: ", strategy.yvToken())
-    yvault.setDepositLimit(2 **256 -1 , {'from': yvault.governance()})
-    #print("real: ", ibCurvePool.calc_token_amount(amounts, True))
+    yvault.setDepositLimit(2 ** 256 - 1, {"from": yvault.governance()})
+    # print("real: ", ibCurvePool.calc_token_amount(amounts, True))
     currency.approve(vault, 2 ** 256 - 1, {"from": whale})
     whale_before = currency.balanceOf(whale)
     whale_deposit = 1_000_000 * (10 ** (decimals))
     vault.deposit(whale_deposit, {"from": whale})
     vault.setManagementFee(0, {"from": gov})
 
     idl = Strategy.at(vault.withdrawalQueue(1))
-    vault.updateStrategyDebtRatio(idl, 0 , {"from": gov})
+    vault.updateStrategyDebtRatio(idl, 0, {"from": gov})
     debt_ratio = 2000
-    #v0.3.0
+    # v0.3.0
+    fStrat = Contract(vault.withdrawalQueue(0))
+    vault.updateStrategyDebtRatio(fStrat, 0, {"from": gov})
     vault.addStrategy(strategy, debt_ratio, 0, 1000, {"from": gov})
-    idl.harvest({'from': gov})
-    idl.harvest({'from': gov})
+    idl.harvest({"from": gov})
+    idl.harvest({"from": gov})
 
-    strategy.harvest({'from': strategist})
-    #genericStateOfStrat(strategy, currency, vault)
-    #genericStateOfVault(vault, currency)
+    strategy.harvest({"from": strategist})
+    # genericStateOfStrat(strategy, currency, vault)
+    # genericStateOfVault(vault, currency)
 
     ibcrvStrat = Strategy.at(ibyvault.withdrawalQueue(0))
-    
+
     vGov = accounts.at(ibyvault.governance(), force=True)
     ibcrvStrat.harvest({"from": vGov})
     chain.sleep(201600)
     chain.mine(1)
     ibcrvStrat.harvest({"from": vGov})
     chain.sleep(21600)
     chain.mine(1)
-    strategy.harvest({'from': strategist})
+    strategy.harvest({"from": strategist})
     print(vault.strategies(strategy))
     genericStateOfStrat(strategy, currency, vault)
     genericStateOfVault(vault, currency)
- 
+
     vault.withdraw({"from": whale})
     whale_after = currency.balanceOf(whale)
-    print("profit =", (whale_after - whale_before)/(10 ** (decimals)))
+    print("profit =", (whale_after - whale_before) / (10 ** (decimals)))
     print("balance left =", vault.balanceOf(whale))
     genericStateOfStrat(strategy, currency, vault)
     genericStateOfVault(vault, currency)
     chain.sleep(21600)
     chain.mine(1)
 
-    strategy.harvest({'from': strategist})
+    strategy.harvest({"from": strategist})
     genericStateOfStrat(strategy, currency, vault)
 
-def test_migrate(usdt,stratms, ibCurvePool,Strategy, accounts, ib3CRV,ibyvault, orb,rewards,chain,strategy_usdt_ib,live_usdt_vault, ychad, gov,strategist, interface):
+
+def test_migrate(
+    usdt,
+    stratms,
+    ibCurvePool,
+    Strategy,
+    accounts,
+    ib3CRV,
+    ibyvault,
+    orb,
+    rewards,
+    chain,
+    strategy_usdt_ib,
+    live_usdt_vault,
+    ychad,
+    gov,
+    strategist,
+    interface,
+):
     gov = stratms
     vault = live_usdt_vault
     strategy = strategy_usdt_ib
     currency = usdt
     yvault = ibyvault
-    
-    yvault.setDepositLimit(2 **256 -1 , {'from': yvault.governance()})
-    #print("real: ", ibCurvePool.calc_token_amount(amounts, True))
+
+    yvault.setDepositLimit(2 ** 256 - 1, {"from": yvault.governance()})
+    # print("real: ", ibCurvePool.calc_token_amount(amounts, True))
 
     idl = Strategy.at(vault.withdrawalQueue(0))
-    vault.updateStrategyDebtRatio(idl, 0 , {"from": gov})
+    vault.updateStrategyDebtRatio(idl, 0, {"from": vault.governance()})
     debt_ratio = 9500
     vault.addStrategy(strategy, debt_ratio, 0, 2 ** 256 - 1, 1000, {"from": gov})
-    idl.harvest({'from': gov})
+    idl.harvest({"from": gov})
 
-    strategy.harvest({'from': strategist})
-    #genericStateOfStrat(strategy, currency, vault)
-    #genericStateOfVault(vault, currency)
+    strategy.harvest({"from": strategist})
+    # genericStateOfStrat(strategy, currency, vault)
+    # genericStateOfVault(vault, currency)
 
     ibcrvStrat = Strategy.at(ibyvault.withdrawalQueue(0))
     vGov = accounts.at(ibyvault.governance(), force=True)
@@ -101,20 +141,33 @@ def test_migrate(usdt,stratms, ibCurvePool,Strategy, accounts, ib3CRV,ibyvault,
     ibcrvStrat.harvest({"from": vGov})
     chain.sleep(21600)
     chain.mine(1)
-
-    strategy.harvest({'from': strategist})
 
-    tx = strategy.cloneSingleSidedCurve(vault, strategist, strategist, strategist, 500_000*1e6, 3600, 500, ibCurvePool, ib3CRV, ibyvault,3, True)
+    strategy.harvest({"from": strategist})
+
+    tx = strategy.cloneSingleSidedCurve(
+        vault,
+        strategist,
+        strategist,
+        strategist,
+        500_000 * 1e6,
+        3600,
+        500,
+        ibCurvePool,
+        ib3CRV,
+        ibyvault,
+        3,
+        True,
+    )
     new_strategy = Strategy.at(tx.return_value)
 
-    vault.migrateStrategy(strategy, new_strategy, {'from': gov})
+    vault.migrateStrategy(strategy, new_strategy, {"from": gov})
 
     genericStateOfStrat(strategy, currency, vault)
     genericStateOfVault(vault, currency)
-    new_strategy.harvest({'from': strategist})
+    new_strategy.harvest({"from": strategist})
     assert yvault.balanceOf(new_strategy) > 0
     assert yvault.balanceOf(strategy) == 0
     assert strategy.estimatedTotalAssets() == 0
     assert new_strategy.estimatedTotalAssets() > 0
     genericStateOfStrat(new_strategy, currency, vault)
-    genericStateOfVault(vault, currency)
+    genericStateOfVault(vault, currency)

tests/test_live.py

@@ -2,7 +2,7 @@
 from brownie import Wei, reverts
 import eth_abi
 from brownie.convert import to_bytes
-from useful_methods import genericStateOfStrat,genericStateOfVault
+from useful_methods import genericStateOfStrat, genericStateOfVault
 import random
 import brownie
 
@@ -12,56 +12,65 @@
 #           - change in loading (from low to high and high to low)
 #           - strategy operation at different loading levels (anticipated and "extreme")
 
-def test_opsss_lvie(currency,live_strategy, chain,live_vault, gov, samdev,strategist, interface):
+
+def test_opsss_lvie(
+    currency, live_strategy, chain, live_vault, gov, samdev, strategist, interface
+):
     strategy = live_strategy
     vault = live_vault
     strategist = samdev
     gov = samdev
 
-    #currency.approve(vault, 2 ** 256 - 1, {"from": whale} )
-    #whalebefore = currency.balanceOf(whale)
-   # whale_deposit  = 100 *1e18
-    #vault.deposit(whale_deposit, {"from": whale})
-    strategy.harvest({'from': strategist})
+    # currency.approve(vault, 2 ** 256 - 1, {"from": whale} )
+    # whalebefore = currency.balanceOf(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})
-    steth = interface.ERC20('0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84')
+    strategy.harvest({"from": strategist})
+    steth = interface.ERC20("0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84")
 
-    print("steth = ", steth.balanceOf(strategy)/1e18)
-    print("eth = ", strategy.balance()/1e18)
+    print("steth = ", steth.balanceOf(strategy) / 1e18)
+    print("eth = ", strategy.balance() / 1e18)
 
     genericStateOfStrat(strategy, currency, vault)
     genericStateOfVault(vault, currency)
 
-    print("\nEstimated APR: ", "{:.2%}".format(((vault.totalAssets()-1000*1e18)*12)/(1000*1e18)))
+    print(
+        "\nEstimated APR: ",
+        "{:.2%}".format(((vault.totalAssets() - 1000 * 1e18) * 12) / (1000 * 1e18)),
+    )
 
-   # vault.withdraw({"from": whale})
+    # vault.withdraw({"from": whale})
     print("\nWithdraw")
     genericStateOfStrat(strategy, currency, vault)
     genericStateOfVault(vault, currency)
-  # print("Whale profit: ", (currency.balanceOf(whale) - whalebefore)/1e18)
 
 
-def test_migrate_live(currency,Strategy, live_strategy,live_vault, chain, whale,samdev, interface):
+# print("Whale profit: ", (currency.balanceOf(whale) - whalebefore)/1e18)
+
+
+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})
+    strategy.harvest({"from": strategist})
 
     genericStateOfStrat(strategy, currency, vault)
     genericStateOfVault(vault, currency)
 
-
     strategy2 = strategist.deploy(Strategy, vault)
-    vault.migrateStrategy(strategy, strategy2, {'from': gov})
+    vault.migrateStrategy(strategy, strategy2, {"from": gov})
     genericStateOfStrat(strategy, currency, vault)
     genericStateOfStrat(strategy2, currency, vault)
-    genericStateOfVault(vault, currency)
+    genericStateOfVault(vault, currency)