def main(): badger = connect_badger(badger_config.prod_json) console.print("\n[white]===== 🦡 Sett Status 🦡 =====[white]\n") for key in badger.sett_system.vaults.keys(): sett = badger.getSett(key) admin = badger.getProxyAdmin(sett) sett_impl = admin.getProxyImplementation(sett) sett_admin = admin.getProxyAdmin(sett) sett_type = badger.getSettType(key) print(key, sett_type) table = [] table.append(["Sett Key", key]) table.append(["Sett Type", sett_type]) table.append(["Sett Logic", sett_impl]) table.append(["Sett Admin", sett_admin]) if sett_type == "v1": snap = SnapshotManager(badger, key) state = snap.snap() snap.printPermissions() # snap.printTable(state) strategy = badger.getStrategy(key) strategy_impl = badger.devProxyAdmin.getProxyImplementation( strategy) strategy_admin = admin.getProxyAdmin(strategy) table.append(["Strategy Logic", strategy_impl]) table.append(["Strategy Admin", strategy_admin]) print(tabulate(table, ["Key", "Value"]))
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 main(): badger = connect_badger(badger_config.prod_json) console.print("\n[white]===== 🦡 Sett Status 🦡 =====[white]\n") for key in badger.sett_system.vaults.keys(): if key in setts_to_skip: continue sett = badger.getSett(key) admin = badger.getProxyAdmin(sett) sett_impl = admin.getProxyImplementation(sett) sett_admin = admin.getProxyAdmin(sett) sett_type = badger.getSettType(key) print(key, sett_type) table = [] console.print("[green]=== Admin: {} Sett ===[green]".format(key)) table.append(["Sett Key", key]) table.append(["Sett Type", sett_type]) table.append(["Sett Logic", sett_impl]) table.append(["Sett Admin", sett_admin]) print(tabulate(table, ["Key", "Value"])) table = [] table.append(["PPFS", sett.getPricePerFullShare()]) table.append(["totalSupply", sett.totalSupply()]) table.append(["balance", sett.balance()]) print(tabulate(table, ["Key", "Value"])) if sett_type == "v1": snap = SnapshotManager(badger, key) # state = snap.snap() # snap.printTable(state) if badger.hasStrategy(key): snap.printPermissions() strategy = badger.getStrategy(key) admin = badger.getProxyAdmin(strategy) strategy_impl = admin.getProxyImplementation(strategy) strategy_admin = admin.getProxyAdmin(strategy) table = [] console.print( "[green]=== Admin: {} Strategy ===[green]".format(key)) table.append(["Strategy Logic", strategy_impl]) table.append(["Strategy Admin", strategy_admin]) print(tabulate(table, ["Key", "Value"]))
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 main(): badger = connect_badger(badger_config.prod_json) console.print("\n[white]===== 🦡 Sett Status 🦡 =====[white]\n") for key in badger.sett_system.vaults.keys(): snap = SnapshotManager(badger, key) state = snap.snap() snap.printPermissions() snap.printTable(state)
def test_simulation(settConfig): # connect to prod deploy and run simulation badger = badger_single_sett(settConfig, deploy=False) snap = SnapshotManager(badger, settConfig["id"]) simulation = SimulationManager(badger, snap, settConfig["id"]) simulation.provision() # Randomize 30 actions. simulation.randomize(30) simulation.run()
def test_deposit_withdraw_single_user_flow(settConfig): badger = badger_single_sett(settConfig) sett = badger.getSett(settConfig["id"]) strategy = badger.getStrategy(settConfig["id"]) want = badger.getStrategyWant(settConfig["id"]) deployer = badger.deployer settKeeper = accounts.at(sett.keeper(), force=True) snap = SnapshotManager(badger, settConfig["id"]) randomUser = accounts[6] print("== Testing == ", settConfig["id"], want.address) # Deposit assert want.balanceOf(deployer) > 0 depositAmount = int(want.balanceOf(deployer) * 0.8) assert depositAmount > 0 want.approve(sett, MaxUint256, {"from": deployer}) snap.settDeposit(depositAmount, {"from": deployer}) # Earn with brownie.reverts("onlyAuthorizedActors"): sett.earn({"from": randomUser}) min = sett.min() max = sett.max() remain = max - min snap.settEarn({"from": settKeeper}) chain.sleep(15) chain.mine(1) snap.settWithdraw(depositAmount // 2, {"from": deployer}) chain.sleep(10000) chain.mine(1) snap.settWithdraw(depositAmount // 2 - 1, {"from": deployer})
def harvest_all(badger: BadgerSystem, skip): for key, vault in badger.sett_system.vaults.items(): if key in skip: continue console.print("\n[bold yellow]===== Harvest: " + str(key) + " =====[/bold yellow]\n") print("Harvest: " + key) snap = SnapshotManager(badger, key) strategy = badger.getStrategy(key) keeper = accounts.at(badger.keeper) before = snap.snap() if strategy.keeper() == badger.badgerRewardsManager: snap.settHarvestViaManager( strategy, { "from": keeper, "gas_limit": 2000000, "allow_revert": True }, confirm=False, ) else: snap.settHarvest( { "from": keeper, "gas_limit": 2000000, "allow_revert": True }, confirm=False, ) tx_wait() if rpc.is_active(): chain.mine() after = snap.snap() snap.printCompare(before, after)
def test_deposit_withdraw_single_user_flow(settId): 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] print(want, want.address, want.totalSupply(), deployer) # Deposit depositAmount = int(want.balanceOf(deployer) * 0.8) want.approve(sett, MaxUint256, {"from": deployer}) snap.settDeposit(depositAmount, {"from": deployer}) # Earn with brownie.reverts("onlyAuthorizedActors"): sett.earn({"from": randomUser}) min = sett.min() max = sett.max() remain = max - min assert sett.keeper() == deployer snap.settEarn({"from": deployer}) chain.sleep(15) chain.mine(1) snap.settWithdraw(depositAmount // 2, {"from": deployer}) chain.sleep(10000) chain.mine(1) snap.settWithdrawAll({"from": deployer})
def deposit_withdraw_single_user_flow(badger, 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 = badger.deployer settKeeper = accounts.at(sett.keeper(), force=True) randomUser = accounts[6] # Deposit assert want.balanceOf(user) > 0 depositAmount = int(want.balanceOf(user) * 0.8) assert depositAmount > 0 want.approve(sett, MaxUint256, {"from": user}) # sett.deposit(depositAmount, {"from": deployer}) snap.settDeposit(depositAmount, {"from": user}) # Earn # with brownie.reverts("onlyAuthorizedActors"): # sett.earn({"from": randomUser}) min = sett.min() max = sett.max() remain = max - min # sett.earn({"from": settKeeper}) snap.settEarn({"from": settKeeper}) chain.sleep(15) chain.mine(1) snap.settWithdraw(depositAmount // 2, {"from": user}) chain.sleep(10000) chain.mine(1) snap.settWithdraw(depositAmount // 2 - 1, {"from": user})
def test_claw(settConfig): badger = badger_single_sett(settConfig, deploy=False) snap = SnapshotManager(badger, settConfig["id"]) deployer = badger.deployer want = badger.getStrategyWant(settConfig["id"]) sett = badger.getSett(settConfig["id"]) depositAmount = int(want.balanceOf(deployer) * 0.8) assert depositAmount > 0 want.approve(sett, MaxUint256, {"from": deployer}) snap.settDeposit(depositAmount, {"from": deployer}) assert want.balanceOf(deployer) > 0 distribute_test_ether(deployer, Wei("20 ether")) distribute_from_whales(deployer) claw = deploy_claw_minimal(deployer) if settConfig["id"] == "native.badger": _manage_position(claw, "bClaw", deployer) if settConfig["id"] == "sushi.sushiWbtcEth": _manage_position(claw, "sClaw", deployer)
def vault_report(badger: BadgerSystem): controller = badger.getController("native") for key, vault in badger.sett_system.vaults.items(): strategy = badger.getStrategy(key) snap = SnapshotManager(badger, key) snap.printPermissions() console.print( { "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() ), } )
def deposit_withdraw_single_user_flow(badger, 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) # Deposit assert want.balanceOf(user) > 0 depositAmount = int(want.balanceOf(user) * 0.8) assert depositAmount > 0 want.approve(sett, MaxUint256, {"from": user}) snap.settDeposit(depositAmount, {"from": user}) # Earn # with brownie.reverts("onlyAuthorizedActors"): # sett.earn({"from": randomUser}) min = sett.min() max = sett.max() remain = max - min # sett.earn({"from": settKeeper}) snap.settEarn({"from": settKeeper}) chain.sleep(15) chain.mine(1) snap.settWithdraw(depositAmount // 2, {"from": user}) chain.sleep(10000) chain.mine(1) snap.settWithdrawAll({"from": user})
def test_simulation_after_upgrade_crv_setts(settID): # Upgrade crv setts kkk badger = connect_badger(badger_config.prod_json) txFilename = queue_upgrade_crv_sett(badger, settID) # Sleep 2 days to pass timelock delay period. chain.sleep(2*days(2)) badger.governance_execute_transaction(txFilename) sett = interface.ISett("0x6dEf55d2e18486B9dDfaA075bc4e4EE0B28c1545") snap = SnapshotManager(badger, settID) simulation = SimulationManager(badger, snap, settID) simulation.provision() # Randomize 30 actions. simulation.randomize(30) simulation.run()
def test_simulation_after_upgrade_crv_setts(settID): # Upgrade crv strategy badger = connect_badger(badger_config.prod_json) """ TODO Get the Implementation before upgrade """ txFilename = queue_upgrade_crv_strat(badger, settID) # Sleep 2 days to pass timelock delay period. chain.sleep(2 * days(2)) badger.governance_execute_transaction(txFilename) """ TODO assert tht implementation has changed """ ## Object representing the sett we want and the mode we're in thisSettConfig = {"id": settID, "mode": "test"} ## Get badger so we can get info in sett and strats badger = badger_single_sett(thisSettConfig) ## We now have the want, we can mint some deployer = badger.deployer ## Mints token for us distribute_from_whales(deployer) snap = SnapshotManager(badger, settID) simulation = SimulationManager(badger, snap, settID) simulation.provision() # Randomize 30 actions. simulation.randomize(30) simulation.run() assert_deposit_withdraw_single_user_flow(thisSettConfig) assert_single_user_harvest_flow(thisSettConfig) assert_migrate_single_user(thisSettConfig) assert_withdraw_other(thisSettConfig) assert_single_user_harvest_flow_remove_fees(thisSettConfig) assert_strategy_action_permissions(thisSettConfig) assert_strategy_config_permissions(thisSettConfig) assert_strategy_pausing_permissions(thisSettConfig) assert_sett_pausing_permissions(thisSettConfig) assert_sett_config_permissions(thisSettConfig) assert_controller_permissions(thisSettConfig)
def test_simulation_after_upgrade_sushi_strategies(args): (strategyID, artifactName) = args # Upgrade crv setts kkk badger = connect_badger(badger_config.prod_json) txFilename = queue_upgrade_strategy(badger, strategyID, artifactName) # Sleep 2 days to pass timelock delay period. chain.sleep(2 * days(2)) badger.governance_execute_transaction(txFilename) # NB: strategy/sett IDs align snap = SnapshotManager(badger, strategyID) simulation = SimulationManager(badger, snap, strategyID) simulation.provision() # Randomize 30 actions. simulation.randomize(30) simulation.run()
def harvest_all(badger: BadgerSystem, skip): keeper = badger.deployer for key, vault in badger.sett_system.vaults.items(): if key in skip: continue console.print("\n[bold yellow]===== Harvest: " + str(key) + " =====[/bold yellow]\n") print("Harvest: " + key) snap = SnapshotManager(badger, key) strategy = badger.getStrategy(key) keeper = accounts.at(strategy.keeper()) before = snap.snap() snap.settHarvest({'from': keeper, "gas_price": gas_strategy}) after = snap.snap() snap.printCompare(before, after)
def earn_all(badger: BadgerSystem, skip): keeper = badger.deployer for key, vault in badger.sett_system.vaults.items(): if key in skip: print("Skip ", key) continue console.print("\n[bold red]===== Earn: " + key + " =====[/bold red]\n") strategy = badger.getStrategy(key) controller = Controller.at(vault.controller()) want = interface.IERC20(vault.token()) # Pre safety checks assert want == strategy.want() assert strategy.controller() == controller assert vault.controller() == controller assert controller.strategies(want) == strategy vaultBefore = want.balanceOf(vault) strategyBefore = strategy.balanceOf() toEarn = False if earn_preconditions(key, vaultBefore, strategyBefore): print("Earn: " + key, vault, strategy) toEarn = True snap = SnapshotManager(badger, key) before = snap.snap() keeper = accounts.at(vault.keeper()) snap.settEarn( {"from": keeper, "gas_limit": 2000000, "allow_revert": True}, confirm=False, ) 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 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 test_single_user_harvest_flow(settConfig): badger = badger_single_sett(settConfig) depositAmount = 50 * 1e8 # renBTC decimal is 8 # test settings controller = badger.getController(settConfig["id"]) sett = badger.getSett(settConfig["id"]) strategy = badger.getStrategy(settConfig["id"]) want = badger.getStrategyWant(settConfig["id"]) deployer = badger.deployer # production settings # controller = interface.IController("0x9b4efa18c0c6b4822225b81d150f3518160f8609"); # sett = interface.ISett("0x77f07Dd580cc957109c70c7fa81aa5704f8a3572") # strategy = StrategyUnitProtocolRenbtc.at("0x5640d6E2F72e76FBCb5296d59EA28C7375F1fE12"); # want = interface.IERC20("0xEB4C2781e4ebA804CE9a9803C67d0893436bB27D") # deployer = accounts.at("0x576cD258835C529B54722F84Bb7d4170aA932C64", force=True) # controllerGov = accounts.at("0xB65cef03b9B89f99517643226d76e286ee999e77", force=True) # ethWhale = accounts.at("0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE", force=True) # ethWhale.transfer(deployer, "100 ether") # settGuestList = interface.IVipCappedGuestList("0x9FC48e61B6a75eE263ca160aCF3288A99238719E"); # settGuestList.setGuests([deployer], [True], {"from": deployer}); # settGuestList.setUserDepositCap(depositAmount * 2, {"from": deployer}); # settGuestList.setTotalDepositCap(depositAmount * 10, {"from": deployer}); # controller.setVault(want, sett, {"from": deployer}); # controller.approveStrategy(want, strategy, {"from": controllerGov}); # controller.setStrategy(want, strategy, {"from": deployer}); settKeeper = accounts.at(sett.keeper(), force=True) strategyKeeper = accounts.at(strategy.keeper(), force=True) snap = SnapshotManager(badger, settConfig["id"]) governance = strategy.governance() tendable = strategy.isTendable() distribute_from_whales(deployer) startingBalance = want.balanceOf(deployer) assert startingBalance >= depositAmount assert startingBalance >= 0 # Deposit want.approve(sett, MaxUint256, {"from": deployer}) # sett.deposit(depositAmount, {"from": deployer}); snap.settDeposit(depositAmount, {"from": deployer}) assert want.balanceOf(sett) > 0 print("want.balanceOf(sett)", want.balanceOf(sett)) # Earn # sett.earn({"from": settKeeper}); snap.settEarn({"from": settKeeper}) # Harvest chain.sleep(hours(0.1)) chain.mine() # strategy.harvest({"from": strategyKeeper}) snap.settHarvest({"from": strategyKeeper}) # Withdraw half # sett.withdraw(depositAmount // 2, {"from": deployer}) snap.settWithdraw(depositAmount // 2, {"from": deployer}) # KeepMinRatio to maintain collateralization safe enough from liquidation currentRatio = strategy.currentRatio() safeRatio = currentRatio + 20 strategy.setMinRatio(safeRatio, {"from": governance}) strategy.keepMinRatio({"from": governance}) assert strategy.currentRatio() > safeRatio # sugar-daddy usdp discrepancy due to accrued interest in Unit Protocol debtTotal = strategy.getDebtBalance() curveGauge = interface.ICurveGauge( "0x055be5DDB7A925BfEF3417FC157f53CA77cA7222") usdp3crvInGauge = curveGauge.balanceOf(strategy) curvePool = interface.ICurveFi( "0x42d7025938bEc20B69cBae5A77421082407f053A") usdpOfPool = curvePool.calc_withdraw_one_coin(usdp3crvInGauge, 0) sugar = (debtTotal - usdpOfPool) * 2 usdpToken = interface.IERC20("0x1456688345527bE1f37E9e627DA0837D6f08C925") if sugar > 0: usdpToken.transfer(strategy, sugar, {"from": deployer}) print("sugar debt=", sugar) # Harvest again chain.sleep(hours(0.1)) chain.mine() # strategy.harvest({"from": strategyKeeper}) snap.settHarvest({"from": strategyKeeper}) # Withdraw all wantInSettBalance = sett.getPricePerFullShare() * sett.totalSupply() / 1e18 print("wantInSett=", wantInSettBalance) print("wantInStrategy=", strategy.balanceOfPool()) print("pricePerFullShare=", sett.getPricePerFullShare()) wantToWithdraw = sett.balanceOf( deployer) * sett.getPricePerFullShare() / 1e18 print("wantToWithdraw=", wantToWithdraw) assert wantToWithdraw <= wantInSettBalance sugarWithdrawAll = (strategy.getDebtBalance() - strategy.balanceOfPool()) * 2 if sugarWithdrawAll > 0: usdpToken.transfer(strategy, sugarWithdrawAll, {"from": deployer}) print("sugarWithdrawAll=", sugarWithdrawAll) renbtcToken = interface.IERC20( "0xEB4C2781e4ebA804CE9a9803C67d0893436bB27D") controller.withdrawAll(renbtcToken, {"from": deployer}) # sett.withdrawAll({"from": deployer}) snap.settWithdrawAll({"from": deployer}) assert True
def setup_badger(badger: BadgerSystem, settConfig): if rpc.is_active(): seeder = accounts.at("0x3131B6964d96DE3Ad36C7Fe82e9bA9CcdBaf6baa", force=True) else: seeder = accounts.load("badger_proxy_deployer") # Test Proxy Admin (owned by deployer) # badger.testProxyAdmin = deploy_proxy_admin(seeder) # badger.testProxyAdmin.transferOwnership(badger.deployer, {"from": seeder}) badger.connect_test_proxy_admin( "testProxyAdmin", "0x58A3123f350A469eB4fCA01d8F6E857bc1F61b76") controller = badger.getController("native") console.print(controller) controller.initialize(seeder, badger.deployer, badger.keeper, badger.deployer, {"from": seeder}) assert badger.devProxyAdmin.getProxyAdmin( controller) == badger.devProxyAdmin # Strategy strategyLogic = badger.logic.StrategyPancakeLpOptimizer console.print("strategyLogic", strategyLogic) for key, vault in badger.sett_system.vaults.items(): config = configs[key] console.print(key, vault, config) want = interface.IERC20(config["want"]) vault.initialize( config["want"], controller, seeder, badger.keeper, badger.guardian, False, "", "", {"from": seeder}, ) controller.setVault(want, vault, {"from": seeder}) # vault.setGovernance(badger.devMultisig, {"from": seeder}) assert badger.devProxyAdmin.getProxyAdmin( vault) == badger.devProxyAdmin for key, strategy in badger.sett_system.strategies.items(): config = configs[key] console.print(key, strategy, config) want = interface.IERC20(config["want"]) assert badger.devProxyAdmin.getProxyAdmin( strategy) == badger.devProxyAdmin strategy.initialize( seeder, seeder, controller, badger.keeper, badger.guardian, [ config["want"], config["token0"], config["token1"], ], [ config["performanceFeeStrategist"], config["performanceFeeGovernance"], config["withdrawalFee"], ], config["wantPid"], {"from": seeder}, ) token0 = config["token0"] token1 = config["token1"] cake = registry.pancake.cake strategy.setTokenSwapPath(cake, token0, [cake, token0], {"from": seeder}) strategy.setTokenSwapPath(cake, token1, [cake, token1], {"from": seeder}) # Wiring console.print(controller.address, controller.governance()) assert controller.governance() == seeder controller.approveStrategy(want, strategy, {"from": seeder}) controller.setStrategy(want, strategy, {"from": seeder}) strategy.setStrategist(badger.deployer, {"from": seeder}) # controller.setGovernance(badger.devMultisig, {"from": seeder}) badger.setStrategy(key, strategy) snap = SnapshotManager(badger, key) table = [] table.append(["governance", strategy.governance()]) table.append(["strategist", strategy.strategist()]) table.append(["keeper", strategy.keeper()]) table.append(["guardian", strategy.guardian()]) table.append(["want", strategy.want()]) table.append(["token0", strategy.token0()]) table.append(["token1", strategy.token1()]) table.append(["wantPid", strategy.wantPid()]) table.append( ["performanceFeeGovernance", strategy.performanceFeeGovernance()]) table.append( ["performanceFeeStrategist", strategy.performanceFeeStrategist()]) table.append(["withdrawalFee", strategy.withdrawalFee()]) table.append([ "path0", strategy.getTokenSwapPath(registry.pancake.cake, strategy.token0()), ]) table.append([ "path1", strategy.getTokenSwapPath(registry.pancake.cake, strategy.token1()), ]) print(tabulate(table, headers=["param", "value"]))
def assert_migrate_single_user(settConfig): 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"]) strategyKeeper = accounts.at(strategy.keeper(), force=True) deployer = badger.deployer randomUser = accounts[6] snap = SnapshotManager(badger, settConfig["id"]) startingBalance = want.balanceOf(deployer) depositAmount = startingBalance // 2 assert startingBalance >= depositAmount # Deposit want.approve(sett, MaxUint256, {"from": deployer}) snap.settDeposit(depositAmount, {"from": deployer}) chain.sleep(15) chain.mine() sett.earn({"from": strategyKeeper}) chain.snapshot() # Test no harvests chain.sleep(days(2)) chain.mine() before = { "settWant": want.balanceOf(sett), "stratWant": strategy.balanceOf() } with brownie.reverts(): controller.withdrawAll(strategy.want(), {"from": randomUser}) controller.withdrawAll(strategy.want(), {"from": deployer}) after = { "settWant": want.balanceOf(sett), "stratWant": strategy.balanceOf() } assert after["settWant"] > before["settWant"] assert after["stratWant"] < before["stratWant"] assert after["stratWant"] == 0 # Test tend only if strategy.isTendable(): chain.revert() chain.sleep(days(2)) chain.mine() strategy.tend({"from": strategyKeeper}) before = { "settWant": want.balanceOf(sett), "stratWant": strategy.balanceOf() } with brownie.reverts(): controller.withdrawAll(strategy.want(), {"from": randomUser}) controller.withdrawAll(strategy.want(), {"from": deployer}) after = { "settWant": want.balanceOf(sett), "stratWant": strategy.balanceOf() } assert after["settWant"] > before["settWant"] assert after["stratWant"] < before["stratWant"] assert after["stratWant"] == 0 # Test harvest, with tend if tendable chain.revert() chain.sleep(days(1)) chain.mine() if strategy.isTendable(): strategy.tend({"from": strategyKeeper}) chain.sleep(days(1)) chain.mine() before = { "settWant": want.balanceOf(sett), "stratWant": strategy.balanceOf(), "rewardsWant": want.balanceOf(controller.rewards()), } with brownie.reverts(): controller.withdrawAll(strategy.want(), {"from": randomUser}) controller.withdrawAll(strategy.want(), {"from": deployer}) after = { "settWant": want.balanceOf(sett), "stratWant": strategy.balanceOf() } assert after["settWant"] > before["settWant"] assert after["stratWant"] < before["stratWant"] assert after["stratWant"] == 0
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)
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 harvest_all(badger: BadgerSystem, skip): for key, vault in badger.sett_system.vaults.items(): if key in skip: continue console.print("\n[bold yellow]===== Harvest: " + str(key) + " =====[/bold yellow]\n") print("Harvest: " + key) snap = SnapshotManager(badger, key) strategy = badger.getStrategy(key) keeper = accounts.at(strategy.keeper()) before = snap.snap() snap.printTable(before) snap.settHarvest({'from': keeper, "gas_price": gas_strategy, "gas_limit": 2000000, "allow_revert": True}, confirm=False) after = snap.snap() snap.printTable(after) snap.printCompare(before, after)
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)