def tend_all(badger: BadgerSystem, skip): table = [] for key, vault in badger.sett_system.vaults.items(): if key in skip: continue strategy = badger.getStrategy(key) if not strategy.isTendable(): continue console.print("\n[bold green]===== Tend: " + key + " =====[/bold green]\n") snap = SnapshotManager(badger, key) strategy = badger.getStrategy(key) keeper = accounts.at(badger.keeper) before = snap.snap() if strategy.keeper() == badger.badgerRewardsManager: snap.settTendViaManager( strategy, {"from": keeper, "gas_limit": 1000000}, confirm=False, ) else: snap.settTend( {"from": keeper, "gas_limit": 1000000}, confirm=False, ) tx_wait() if rpc.is_active(): chain.mine() after = snap.snap() snap.printCompare(before, after)
def single_user_harvest_flow(badger: BadgerSystem, settConfig, user): strategy = badger.getStrategy(settConfig["id"]) want = interface.IERC20(registry.pancake.chefPairs.bnbBtcb) snap = SnapshotManager(badger, settConfig["id"]) sett = badger.getSett(settConfig["id"]) settKeeper = accounts.at(sett.keeper(), force=True) strategyKeeper = accounts.at(strategy.keeper(), force=True) randomUser = accounts[6] tendable = strategy.isTendable() startingBalance = want.balanceOf(user) depositAmount = startingBalance // 200 assert startingBalance >= depositAmount assert startingBalance >= 0 # Deposit want.approve(sett, MaxUint256, {"from": user}) snap.settDeposit(depositAmount, {"from": user}) assert want.balanceOf(sett) > 0 print("want.balanceOf(sett)", want.balanceOf(sett)) # Earn snap.settEarn({"from": settKeeper}) if tendable: with brownie.reverts("onlyAuthorizedActors"): strategy.tend({"from": randomUser}) numTends = 48 timeBetweenTends = days(365) // numTends console.print({"numTends": numTends, "timeBetweenTends": timeBetweenTends}) for i in range(0, numTends): console.print("Tend {}".format(i)) snap.settTend({"from": strategyKeeper}) chain.sleep(timeBetweenTends) chain.mine() with brownie.reverts("onlyAuthorizedActors"): strategy.harvest({"from": randomUser}) snap.settHarvest({"from": strategyKeeper})
def test_single_user_harvest_flow(settId): suiteName = "test_single_user_harvest_flow" + ": " + settId testRecorder = TestRecorder(suiteName) badger = badger_single_sett(settId) controller = badger.getController(settId) sett = badger.getSett(settId) strategy = badger.getStrategy(settId) want = badger.getStrategyWant(settId) snap = SnapshotManager(badger, settId) deployer = badger.deployer randomUser = accounts[6] tendable = strategy.isTendable() startingBalance = want.balanceOf(deployer) depositAmount = Wei("1 ether") assert startingBalance >= depositAmount # Deposit want.approve(sett, MaxUint256, {"from": deployer}) snap.settDeposit(depositAmount, {"from": deployer}) # Earn snap.settEarn(depositAmount, {"from": deployer}) if tendable: with brownie.reverts("onlyAuthorizedActors"): strategy.tend({"from": randomUser}) snap.settTend({"from": deployer}) chain.sleep(days(0.5)) chain.mine() if tendable: snap.settTend({"from": deployer}) chain.sleep(days(1)) chain.mine() with brownie.reverts("onlyAuthorizedActors"): strategy.harvest({"from": randomUser}) snap.settHarvest({"from": deployer}) chain.sleep(days(1)) chain.mine() if tendable: snap.settTend({"from": deployer}) chain.sleep(days(3)) chain.mine() snap.settHarvest({"from": deployer}) snap.settWithdrawAll({"from": deployer}) endingBalance = want.balanceOf(deployer) assert endingBalance > startingBalance
def tend_all(badger: BadgerSystem, skip, min_profit=0): """ Runs tend function for strategies if they are expected to be profitable. If a profit estimate fails for any reason the default behavior is to treat it as having a profit of zero. :param badger: badger system :param skip: strategies to skip checking :param min_profit: minimum estimated profit (in ETH or BNB) required for harvest to be executed on chain """ table = [] for key, vault in badger.sett_system.vaults.items(): if key in skip: continue strategy = badger.getStrategy(key) if not strategy.isTendable(): continue console.print("\n[bold green]===== Tend: " + key + " =====[/bold green]\n") snap = SnapshotManager(badger, key) strategy = badger.getStrategy(key) before = snap.snap() if strategy.keeper() == badger.badgerRewardsManager: estimated_profit = snap.estimateProfitTendViaManager( key, strategy, { "from": keeper, "gas_limit": 1000000 }, min_profit) if estimated_profit >= min_profit: snap.settTendViaManager( strategy, { "from": keeper, "gas_limit": 1000000 }, confirm=False, ) else: keeper = accounts.at(strategy.keeper()) estimated_profit = snap.estimateProfitTend(key, { "from": keeper, "gas_limit": 1000000 }, min_profit) if estimated_profit >= min_profit: snap.settTend( { "from": keeper, "gas_limit": 1000000 }, confirm=False, ) tx_wait() if rpc.is_active(): chain.mine() after = snap.snap() snap.printCompare(before, after)
def single_user_harvest_flow(badger: BadgerSystem, sett_id, user): controller = badger.getController("native") strategy = badger.getStrategy(sett_id) want = interface.IERC20(strategy.want()) snap = SnapshotManager(badger, sett_id) sett = badger.getSett(sett_id) strategist = accounts.at(strategy.strategist(), force=True) console.log({ "key": sett_id, "want": strategy.want(), "token0": strategy.token0(), "token1": strategy.token1(), "path0": strategy.getTokenSwapPath(registry.pancake.cake, strategy.token0()), "path1": strategy.getTokenSwapPath(registry.pancake.cake, strategy.token1()), }) strategist = badger.deployer settKeeper = accounts.at(sett.keeper(), force=True) strategyKeeper = accounts.at(strategy.keeper(), force=True) randomUser = accounts[6] tendable = strategy.isTendable() startingBalance = want.balanceOf(user) depositAmount = startingBalance // 200 assert startingBalance >= depositAmount assert startingBalance >= 0 # Deposit want.approve(sett, MaxUint256, {"from": user}) snap.settDeposit(depositAmount, {"from": user}) assert want.balanceOf(sett) > 0 print("want.balanceOf(sett)", want.balanceOf(sett)) # Earn snap.settEarn({"from": settKeeper}) numTends = 48 timeBetweenTends = days(0.5) // numTends console.print({"numTends": numTends, "timeBetweenTends": timeBetweenTends}) for i in range(0, numTends): console.print("Tend {}".format(i)) snap.settTend({"from": strategyKeeper}) chain.sleep(timeBetweenTends) chain.mine() snap.settHarvest({"from": strategyKeeper}) # if tendable: # snap.settTend({"from": strategyKeeper}) # snap.settWithdraw(depositAmount // 2, {"from": user}) # chain.sleep(days(3)) # chain.mine() # snap.settHarvest({"from": strategyKeeper}) # snap.settWithdraw(depositAmount // 2 - 1, {"from": user}) assert False
def assert_single_user_harvest_flow(settConfig): badger = badger_single_sett(settConfig) sett = badger.getSett(settConfig["id"]) strategy = badger.getStrategy(settConfig["id"]) want = badger.getStrategyWant(settConfig["id"]) settKeeper = accounts.at(sett.keeper(), force=True) strategyKeeper = accounts.at(strategy.keeper(), force=True) snap = SnapshotManager(badger, settConfig["id"]) deployer = badger.deployer randomUser = accounts[6] tendable = strategy.isTendable() startingBalance = want.balanceOf(deployer) depositAmount = startingBalance // 2 assert startingBalance >= depositAmount assert startingBalance >= 0 # Deposit want.approve(sett, MaxUint256, {"from": deployer}) snap.settDeposit(depositAmount, {"from": deployer}) assert want.balanceOf(sett) > 0 print("want.balanceOf(sett)", want.balanceOf(sett)) # Earn snap.settEarn({"from": settKeeper}) if tendable: with brownie.reverts("onlyAuthorizedActors"): strategy.tend({"from": randomUser}) snap.settTend({"from": strategyKeeper}) chain.sleep(days(0.5)) chain.mine() if tendable: snap.settTend({"from": strategyKeeper}) chain.sleep(days(1)) chain.mine() with brownie.reverts("onlyAuthorizedActors"): strategy.harvest({"from": randomUser}) snap.settHarvest({"from": strategyKeeper}) chain.sleep(days(1)) chain.mine() if tendable: snap.settTend({"from": strategyKeeper}) snap.settWithdraw(depositAmount // 2, {"from": deployer}) chain.sleep(days(3)) chain.mine() snap.settHarvest({"from": strategyKeeper}) snap.settWithdraw(depositAmount // 2 - 1, {"from": deployer})
def assert_single_user_harvest_flow_remove_fees(settConfig): suiteName = "assert_single_user_harvest_flow_remove_fees" + ": " + settConfig[ "id"] badger = badger_single_sett(settConfig) controller = badger.getController(settConfig["id"]) sett = badger.getSett(settConfig["id"]) strategy = badger.getStrategy(settConfig["id"]) want = badger.getStrategyWant(settConfig["id"]) deployer = badger.deployer randomUser = accounts[6] snap = SnapshotManager(badger, settConfig["id"]) tendable = strategy.isTendable() startingBalance = want.balanceOf(deployer) strategyKeeper = accounts.at(strategy.keeper(), force=True) depositAmount = Wei("1 ether") assert startingBalance >= depositAmount # Deposit want.approve(sett, MaxUint256, {"from": deployer}) sett.deposit(depositAmount, {"from": deployer}) # Earn sett.earn({"from": strategyKeeper}) chain.sleep(days(0.5)) chain.mine() if tendable: tx = snap.settTend({"from": strategyKeeper}) chain.sleep(days(1)) chain.mine() with brownie.reverts("onlyAuthorizedActors"): strategy.harvest({"from": randomUser}) snap.settHarvest({"from": strategyKeeper}) # Harvesting on the HarvestMetaFarm does not increase the underlying position, it sends rewards to the rewardsTree # For HarvestMetaFarm, we expect FARM rewards to be distributed to rewardsTree assert want.balanceOf(controller.rewards()) > 0 chain.sleep(days(1)) chain.mine() if tendable: tx = strategy.tend({"from": strategyKeeper}) chain.sleep(days(3)) chain.mine() tx = snap.settHarvest({"from": strategyKeeper}) sett.withdrawAll({"from": deployer}) endingBalance = want.balanceOf(deployer) report = { "time": "4 days", "gains": endingBalance - startingBalance, "gainsPercentage": (endingBalance - startingBalance) / startingBalance, } print(report)