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 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") fpps_before = vault.getPricePerFullShare() keeper = accounts.at(strategy.keeper()) strategy.tend({'from': keeper, "gas_price": gas_strategy}) table.append([ key, val(fpps_before), val(vault.getPricePerFullShare()), val(vault.getPricePerFullShare() - fpps_before), ]) print("PPFS: Tend") print(tabulate(table, headers=["name", "before", "after", "diff"]))
def deploy_digg_native_sett(badger: BadgerSystem, digg): deployer = badger.deployer key = "native.digg" params = sett_config.native.badger.params params.want = digg.token rewards = badger.deploy_digg_rewards_faucet(key, digg.token) time.sleep(sleep_between_tx) params.geyser = rewards deploy_sett_by_key( badger, key, "StrategyDiggRewards", SettType.DIGG, params, deployer=deployer, governance=badger.devMultisig, strategist=badger.deployer, keeper=badger.keeper, guardian=badger.guardian, ) strategy = badger.getStrategy(key) rewards.grantRole(PAUSER_ROLE, badger.keeper, {"from": deployer}) rewards.grantRole(UNPAUSER_ROLE, badger.devMultisig, {"from": deployer}) # Make strategy the recipient of the DIGG faucet rewards.initializeRecipient(strategy, {"from": deployer})
def __init__(self, badger: BadgerSystem, key): self.badger = badger self.key = key self.sett = badger.getSett(key) self.strategy = badger.getStrategy(key) self.controller = Controller.at(self.sett.controller()) self.want = interface.IERC20(self.sett.token()) self.resolver = self.init_resolver(self.strategy.getName()) self.snaps = {} self.settSnaps = {} self.entities = {} assert self.want == self.strategy.want() # Common entities for all strategies self.addEntity("sett", self.sett.address) self.addEntity("strategy", self.strategy.address) self.addEntity("controller", self.controller.address) self.addEntity("governance", self.strategy.governance()) self.addEntity("governanceRewards", self.controller.rewards()) self.addEntity("strategist", self.strategy.strategist()) destinations = self.resolver.get_strategy_destinations() for key, dest in destinations.items(): self.addEntity(key, dest)
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(vaultBefore, strategyBefore): print("Earn: " + key, vault, strategy) toEarn = True snap = SnapshotManager(badger, key) strategy = badger.getStrategy(key) keeper = accounts.at(strategy.keeper()) before = snap.snap() snap.printTable(before) keeper = accounts.at(vault.keeper()) snap.settEarn( { '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 multisig_action(badger: BadgerSystem): multi = GnosisSafe(badger.opsMultisig) key = "native.bDiggBtcb" vault = badger.getSett(key) strategy = badger.getStrategy(key) multi.execute( MultisigTxMetadata(description="Set PoolId"), {"to": strategy.address, "data": strategy.setWantPid.encode_input(104)}, ) assert strategy.wantPid() == 104
def transfer_for_strategy(badger: BadgerSystem, key, amount, decimals=18): console.print("Transferring Amount for Strategy {}".format(key), val(amount, decimals)) manager = badger.badgerRewardsManager strategy = badger.getStrategy(key) before = snap_strategy_balance(badger, key, manager) transfer_for_strategy_internal(badger, key, amount) after = snap_strategy_balance(badger, key, manager) diff = diff_numbers_by_key(before, after) console.print("[green]==Transfer for {}==[/green]".format(key)) to_tabulate("Diff {}".format(key), diff)
def swap_for_strategy(badger: BadgerSystem, key, amount): manager = badger.badgerRewardsManager print(key) strategy = badger.getStrategy(key) before = snap_strategy_balance(badger, key, manager) swap_for_strategy_internal(badger, key, amount) after = snap_strategy_balance(badger, key, manager) diff = diff_numbers_by_key(before, after) console.print("[green]==Swap for {}==[/green]".format(key)) console.print("Amount", amount) to_tabulate("Diff {}".format(key), diff)
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 __init__( self, badger: BadgerSystem, snap: SnapshotManager, settId: str, seed: int = 0, # Default seed is 0 or unset, will generate. ): self.accounts = accounts[9:] # Use the 10th account onwards. # User accounts (need to be provisioned before running sim). self.users = [] self.debug = True self.badger = badger self.snap = snap self.sett = badger.getSett(settId) self.strategy = badger.getStrategy(settId) self.want = badger.getStrategyWant(settId) self.settKeeper = accounts.at(self.sett.keeper(), force=True) self.strategyKeeper = accounts.at(self.strategy.keeper(), force=True) # Actors generate valid actions based on the actor type. For example, # user actors need to have deposited first before they can withdraw # (withdraw before deposit is an invalid action). self.actors = [ SettKeeperActor(self, self.settKeeper), StrategyKeeperActor(self, self.strategyKeeper), ChainActor(), ] if isinstance(snap, DiggSnapshotManager): self.actors.append(DiggActor(self, self.badger.deployer)) # Ordered valid actions generated by actors. self.actions = [] self.state = SimulationManagerState.IDLE # Track seed so we can configure this value if we want to repro test failures. self.seed = seed if self.seed == 0: self.seed = int(time.time()) console.print(f"initialized simulation manager with seed: {self.seed}") random.seed(self.seed) console.print("Random Seed") self.provisioner = self._initProvisioner(settId) console.print("initialization complete")
def lp_for_strategy(badger: BadgerSystem, key): """ Add maximum liquidity for associated strategy LP position """ manager = badger.badgerRewardsManager strategy = badger.getStrategy(key) want = interface.IERC20(strategy.want()) before = snap_strategy_balance(badger, key, manager) lp_for_strategy_internal(badger, key) after = snap_strategy_balance(badger, key, manager) diff = diff_numbers_by_key(before, after) console.print("[cyan]==LP for {}==[/cyan]".format(key)) to_tabulate("Diff {}".format(key), diff)
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 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 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 snap_strategy_balance(badger: BadgerSystem, key, manager): digg = badger.digg strategy = badger.getStrategy(key) sett = badger.getSett(key) want = interface.IERC20(strategy.want()) wbtc = interface.IERC20(registry.tokens.wbtc) state = { "manager (badger)": badger.token.balanceOf(manager), "manager (digg)": digg.token.balanceOf(manager), "manager (want)": want.balanceOf(manager), "manager (wbtc)": wbtc.balanceOf(manager), "balanceOfPool": strategy.balanceOfPool(), "balanceOfWant": strategy.balanceOfWant(), "balanceOf": strategy.balanceOf(), "pricePerFullShare": sett.getPricePerFullShare(), } return state
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 setup_badger(badger: BadgerSystem): # Set paths key = "native.bDiggBtcb" sett = badger.getSett(key) strategy = badger.getStrategy(key) multi = GnosisSafe(badger.opsMultisig) multi.execute( MultisigTxMetadata(description="Set path"), { "to": strategy.address, "data": strategy.setTokenSwapPath.encode_input( registry.pancake.cake, strategy.token0(), [ registry.pancake.cake, registry.tokens.btcb, strategy.token0() ], ), }, ) multi.execute( MultisigTxMetadata(description="Set path"), { "to": strategy.address, "data": strategy.setTokenSwapPath.encode_input( registry.pancake.cake, strategy.token1(), [registry.pancake.cake, registry.tokens.btcb], ), }, )
def setup_badger(badger: BadgerSystem): configs = { "native.pancakeBnbBtcb": { "want": registry.pancake.chefPairs.bnbBtcb, "token0": registry.tokens.btcb, "token1": registry.tokens.bnb, "performanceFeeStrategist": 1000, "performanceFeeGovernance": 1000, "withdrawalFee": 50, "wantPid": registry.pancake.chefPids.bnbBtcb, }, "native.bBadgerBtcb": { "want": registry.pancake.chefPairs.bBadgerBtcb, "token0": registry.tokens.bBadger, "token1": registry.tokens.btcb, "performanceFeeStrategist": 1000, "performanceFeeGovernance": 1000, "withdrawalFee": 50, "wantPid": registry.pancake.chefPids.bBadgerBtcb, }, "native.bDiggBtcb": { "want": registry.pancake.chefPairs.bDiggBtcb, "token0": registry.tokens.bDigg, "token1": registry.tokens.btcb, "performanceFeeStrategist": 1000, "performanceFeeGovernance": 1000, "withdrawalFee": 50, "wantPid": registry.pancake.chefPids.bDiggBtcb, }, } # Set paths key = "native.bDiggBtcb" sett = badger.getSett(key) strategy = badger.getStrategy(key) multi = GnosisSafe(badger.opsMultisig) multi.execute( MultisigTxMetadata(description="Set path"), { "to": strategy.address, "data": strategy.setTokenSwapPath.encode_input( registry.pancake.cake, strategy.token0(), [ registry.pancake.cake, registry.tokens.btcb, strategy.token0() ], ), }, ) multi.execute( MultisigTxMetadata(description="Set path"), { "to": strategy.address, "data": strategy.setTokenSwapPath.encode_input( registry.pancake.cake, strategy.token1(), [ registry.pancake.cake, registry.tokens.btcb, strategy.token1() ], ), }, )
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 destination = get_expected_strategy_deposit_location(badger, key) vaultBefore = want.balanceOf(vault) destinationBefore = want.balanceOf(destination) strategyBefore = strategy.balanceOf() controllerBefore = want.balanceOf(controller) if vaultBefore == 0: print("No balance in Sett: ", key) continue toEarn = False if earn_preconditions(vaultBefore, strategyBefore): print("Earn: " + key, vault, strategy) toEarn = True keeper = accounts.at(vault.keeper()) vault.earn({'from': keeper, "gas_price": gas_strategy}) # Post safety for test run vaultAfter = want.balanceOf(vault) destinationAfter = want.balanceOf(destination) strategyAfter = strategy.balanceOf() controllerAfter = want.balanceOf(controller) table = [] table.append([ "vault", val(vaultBefore), val(vaultAfter), val(vaultAfter - vaultBefore) ]) table.append([ "destination", val(destinationBefore), val(destinationAfter), val(destinationAfter - destinationBefore), ]) table.append([ "strategy", val(strategyBefore), val(strategyAfter), val(strategyAfter - strategyBefore), ]) table.append([ "controller", val(controllerBefore), val(controllerAfter), val(controllerAfter - controllerBefore), ]) print(tabulate(table, headers=["name", "before", "after", "diff"])) if toEarn: assert strategyAfter > strategyBefore
def post_deploy_config(badger: BadgerSystem): deployer = badger.deployer """ Set initial conditions on immediate post-deploy Badger Transfer tokens to thier initial locations - Rewards Escrow (40%, minus tokens initially distributed via Sett Special StakingRewards) - Badger Hunt (15%) - DAO Timelock (35%) - Founder Rewards (10%) """ # Approve BadgerTree to recieve rewards tokens print(deployer) print(badger.rewardsEscrow.owner()) # badger.rewardsEscrow.approveRecipient(badger.badgerTree, {"from": deployer}) # badger.rewardsEscrow.approveRecipient( # badger.getGeyser("native.badger"), {"from": deployer} # ) # badger.rewardsEscrow.approveRecipient( # badger.getGeyser("native.uniBadgerWbtc"), {"from": deployer} # ) # badger.rewardsEscrow.approveRecipient( # badger.getGeyser("native.renCrv"), {"from": deployer} # ) # badger.rewardsEscrow.approveRecipient( # badger.getGeyser("native.sbtcCrv"), {"from": deployer} # ) # badger.rewardsEscrow.approveRecipient( # badger.getGeyser("native.tbtcCrv"), {"from": deployer} # ) # badger.rewardsEscrow.approveRecipient( # badger.getGeyser("harvest.renCrv"), {"from": deployer} # ) # console.log("before signal locks", badger.token.balanceOf(deployer) / 1e18) # # Geyser Signals # """ # These signals are used to calculate the rewards distributions distributed via BadgerTree. The tokens are actually held in the RewardsEscrow and sent to the BadgerTree as needed. # The escrow will only send a few days worth of rewards initially at a time to the RewardsTree as another failsafe mechanism. # renbtcCRV — 76750 $BADGER # sbtcCRV — 76,750 $BADGER # tbtcCRV — 76,750 $BADGER # Badger — 90,000 $BADGER / 2 # - 45000 in Sett StakingRewards # - 45000 in Geyser # Badger <>wBTC Uniswap LP — 130,000 $BADGER / 2 # - 65000 in Sett StakingRewards # - 65000 in Geyser # Super Sett # Pickle renbtcCRV — 76,750 $BADGER # Harvest renbtc CRV — 76,750 $BADGER # """ # badger.signal_token_lock( # "native.badger", badger_config.geyserParams.unlockSchedules.badger[0] # ) # badger.signal_token_lock( # "native.uniBadgerWbtc", # badger_config.geyserParams.unlockSchedules.uniBadgerWbtc[0], # ) # badger.signal_token_lock( # "native.renCrv", badger_config.geyserParams.unlockSchedules.bRenCrv[0] # ) # badger.signal_token_lock( # "native.sbtcCrv", badger_config.geyserParams.unlockSchedules.bSbtcCrv[0] # ) # badger.signal_token_lock( # "native.tbtcCrv", badger_config.geyserParams.unlockSchedules.bTbtcCrv[0] # ) # badger.signal_token_lock( # "harvest.renCrv", # badger_config.geyserParams.unlockSchedules.bSuperRenCrvHarvest[0], # ) # console.log( # "before initial token distribution", badger.token.balanceOf(deployer) / 1e18 # ) # ===== Initial Token Distribution ===== # == Native Badger == rewards = badger.getSettRewards("native.badger") strategy = badger.getStrategy("native.badger") badger.distribute_staking_rewards( "native.badger", badger_config.geyserParams.unlockSchedules.badger[0].amount, notify=False, ) rewards.grantRole(APPROVED_STAKER_ROLE, strategy, {"from": deployer}) # == Uni LP == rewards = badger.getSettRewards("native.uniBadgerWbtc") strategy = badger.getStrategy("native.uniBadgerWbtc") badger.distribute_staking_rewards( "native.uniBadgerWbtc", badger_config.geyserParams.unlockSchedules.uniBadgerWbtc[0].amount, notify=False, ) rewards.grantRole(APPROVED_STAKER_ROLE, strategy, {"from": deployer}) console.log( "remaining after special pool distributions", badger.token.balanceOf(deployer) / 1e18, ) distributedToPools = ( badger_config.geyserParams.unlockSchedules.badger[0].amount + badger_config.geyserParams.unlockSchedules.uniBadgerWbtc[0].amount) # print( # badger_config.geyserParams.unlockSchedules.badger[0], # badger_config.geyserParams.unlockSchedules.uniBadgerWbtc[0], # badger_config.geyserParams.unlockSchedules.bRenCrv[0], # badger_config.geyserParams.unlockSchedules.bSbtcCrv[0], # badger_config.geyserParams.unlockSchedules.bTbtcCrv[0], # badger_config.geyserParams.unlockSchedules.bSuperRenCrvHarvest[0] # ) supplyForWeek1Rewards = ( badger_config.geyserParams.unlockSchedules.badger[0].amount + badger_config.geyserParams.unlockSchedules.uniBadgerWbtc[0].amount + badger_config.geyserParams.unlockSchedules.bRenCrv[0].amount + badger_config.geyserParams.unlockSchedules.bSbtcCrv[0].amount + badger_config.geyserParams.unlockSchedules.bTbtcCrv[0].amount + badger_config.geyserParams.unlockSchedules.bSuperRenCrvHarvest[0]. amount) toEscrow = (badger_config.rewardsEscrowBadgerAmount - distributedToPools - supplyForWeek1Rewards) badger.initialRewardsEscrowBalance = toEscrow badger.initialBadgerTreeBalance = supplyForWeek1Rewards console.log(locals(), badger_config.rewardsEscrowBadgerAmount) # == Badger Hunt == badger.token.transfer( badger.badgerHunt, badger_config.huntParams.badgerAmount, {"from": deployer}, ) # == Badger Tree == badger.token.transfer( badger.badgerTree, supplyForWeek1Rewards, {"from": deployer}, ) # == Rewards Escrow == badger.token.transfer( badger.rewardsEscrow, toEscrow, {"from": deployer}, ) # == DAO Timelock == badger.token.transfer( badger.daoBadgerTimelock, badger_config.tokenLockParams.badgerLockAmount, {"from": deployer}, ) console.log("after daoBadgerTimelock", badger.token.balanceOf(deployer) / 1e18) # == Team Vesting == badger.token.transfer(badger.teamVesting, badger_config.founderRewardsAmount, {"from": deployer}) tokenDistributionTargets = { "deployer": 0, "rewardsEscrow": toEscrow, "native.badger Pool": badger_config.geyserParams.unlockSchedules.badger[0].amount, "native.uniBadgerWbtc Pool": badger_config.geyserParams.unlockSchedules.uniBadgerWbtc[0].amount, "native.badger geyser": badger_config.geyserParams.unlockSchedules.badger[0].amount, "native.uniBadgerWbtc geyser": badger_config.geyserParams.unlockSchedules.uniBadgerWbtc[0].amount, "native.renCrv geyser": badger_config.geyserParams.unlockSchedules.bRenCrv[0].amount, "native.sbtcCrv geyser": badger_config.geyserParams.unlockSchedules.bSbtcCrv[0].amount, "native.tbtcCrv geyser": badger_config.geyserParams.unlockSchedules.bTbtcCrv[0].amount, "harvest.renCrv geyser": badger_config.geyserParams.unlockSchedules.bSuperRenCrvHarvest[0]. amount, "daoBadgerTimelock": badger_config.tokenLockParams.badgerLockAmount, "teamVesting": badger_config.founderRewardsAmount, "badgerHunt": badger_config.huntParams.badgerAmount, "badgerTree": 0, } tokenDistributionBalances = { "deployer": badger.token.balanceOf(deployer), "rewardsEscrow": badger.token.balanceOf(badger.rewardsEscrow), "native.badger Pool": badger.token.balanceOf(badger.getSettRewards("native.badger")), "native.uniBadgerWbtc Pool": badger.token.balanceOf(badger.getSettRewards("native.uniBadgerWbtc")), "native.badger geyser": badger.token.balanceOf(badger.getGeyser("native.badger")), "native.uniBadgerWbtc geyser": badger.token.balanceOf(badger.getGeyser("native.uniBadgerWbtc")), "native.renCrv geyser": badger.token.balanceOf(badger.getGeyser("native.renCrv")), "native.sbtcCrv geyser": badger.token.balanceOf(badger.getGeyser("native.sbtcCrv")), "native.tbtcCrv geyser": badger.token.balanceOf(badger.getGeyser("native.tbtcCrv")), "harvest.renCrv geyser": badger.token.balanceOf(badger.getGeyser("harvest.renCrv")), "daoBadgerTimelock": badger.token.balanceOf(badger.daoBadgerTimelock), "teamVesting": badger.token.balanceOf(badger.teamVesting), "badgerHunt": badger.token.balanceOf(badger.badgerHunt), "badgerTree": badger.initialBadgerTreeBalance, } if not badger.test: expectedSum = 0 actualSum = 0 for key, value in tokenDistributionTargets.items(): print("expected", key, value / 1e18) print("actual", key, tokenDistributionBalances[key] / 1e18) expectedSum += value actualSum += tokenDistributionBalances[key] print("expectedSum", expectedSum / 1e18) print("actualSum", actualSum / 1e18) # assert expectedSum == badger_total_supply # assert actualSum == badger_total_supply console.log("after teamVesting", badger.token.balanceOf(deployer) / 1e18) """ ===== Transfer Ownership ===== - proxyAdmin should be owned by multisig - All contract owner / admin rights should be given to multisig """ badger.rewardsEscrow.transferOwnership(badger.devMultisig, {"from": deployer})
def confirm_setup_sett(badger: BadgerSystem): common_controller_params = DotMap( governance=badger.deployer, strategist=badger.deployer, keeper=badger.keeper, onesplit=registry.onesplit.contract, rewards=badger.dao.agent, ) # ===== Confirm Controller ===== # Native Controller params = common_controller_params params.setts = [ [ badger.token, badger.getSett("native.badger"), badger.getStrategy("native.badger"), ], [ registry.curve.pools.sbtcCrv.token, badger.getSett("native.sbtcCrv"), badger.getStrategy("native.sbtcCrv"), ], [ registry.curve.pools.renCrv.token, badger.getSett("native.renCrv"), badger.getStrategy("native.renCrv"), ], [ registry.curve.pools.tbtcCrv.token, badger.getSett("native.tbtcCrv"), badger.getStrategy("native.tbtcCrv"), ], ] print(badger.getStrategy("native.tbtcCrv")) confirm_controller_params(badger.getController("native"), params) # Harvest Controller params = common_controller_params params.setts = [[ registry.curve.pools.renCrv.token, badger.getSett("harvest.renCrv"), badger.getStrategy("harvest.renCrv"), ]] confirm_controller_params(badger.getController("harvest"), params) # ===== Confirm Setts ===== # Native Setts # TODO: Change governance and strategist to prod values common_native_sett_params = DotMap( governance=badger.deployer, strategist=AddressZero, keeper=badger.deployer, controller=badger.getController("native"), min=9500, ) params = common_native_sett_params params.token = badger.token params.name = "Badger Sett Badger" params.symbol = "bBADGER" # params.name = "Badger Sett BadgerTest" # params.symbol = "bBGTEST" confirm_sett_params(badger.getSett("native.badger"), params) params = common_native_sett_params params.token = registry.curve.pools.sbtcCrv.token params.name = "Badger Sett Curve.fi renBTC/wBTC/sBTC" params.symbol = "bcrvRenWSBTC" confirm_sett_params(badger.getSett("native.sbtcCrv"), params) params = common_native_sett_params params.token = registry.curve.pools.renCrv.token params.name = "Badger Sett Curve.fi renBTC/wBTC" params.symbol = "bcrvRenWBTC" confirm_sett_params(badger.getSett("native.renCrv"), params) params = common_native_sett_params params.token = registry.curve.pools.tbtcCrv.token params.name = "Badger Sett Curve.fi tBTC/sbtcCrv" params.symbol = "btbtc/sbtcCrv" confirm_sett_params(badger.getSett("native.tbtcCrv"), params) # Harvest Setts harvest_sett_params = DotMap( governance=badger.deployer, strategist=AddressZero, keeper=badger.deployer, controller=badger.getController("harvest"), min=9500, token=registry.curve.pools.renCrv.token, name="Badger SuperSett (Harvest) Curve.fi renBTC/wBTC", symbol="bSupercrvRenWBTC", ) confirm_sett_params(badger.getSett("harvest.renCrv"), harvest_sett_params) # ===== Confirm Strategies ===== common_strategy_params = DotMap( governance=badger.deployer, strategist=badger.deployer, keeper=badger.keeper, controller=badger.getController("native"), guardian=badger.guardian, performanceFeeGovernance=1000, performanceFeeStrategist=1000, withdrawalFee=75, ) # ===== Native Strategies ===== # == Badger Native == params = common_strategy_params params.name = "StrategyBadgerRewards" params.want = badger.token params.performanceFeeGovernance = 0 params.performanceFeeStrategist = 0 params.withdrawalFee = 0 confirm_strategy_common_params(badger.getStrategy("native.badger"), params) confirm_strategy_badger_rewards_params( badger.getStrategy("native.badger"), DotMap(geyser=badger.getSettRewards("native.badger")), ) # == Badger LP == params = common_strategy_params params.name = "StrategyBadgerLpMetaFarm" params.want = badger.pair params.performanceFeeGovernance = 0 params.performanceFeeStrategist = 0 params.withdrawalFee = 0 confirm_strategy_common_params(badger.getStrategy("native.uniBadgerWbtc"), params) confirm_strategy_badger_rewards_params( badger.getStrategy("native.uniBadgerWbtc"), DotMap(geyser=badger.getSettRewards("native.uniBadgerWbtc")), ) # == Native SbtcCrv == params = common_strategy_params params.name = "StrategyCurveGauge" params.want = registry.curve.pools.sbtcCrv.token params.performanceFeeGovernance = 1000 params.performanceFeeStrategist = 1000 params.withdrawalFee = 75 confirm_strategy_common_params(badger.getStrategy("native.sbtcCrv"), params) params = common_strategy_params params.name = "StrategyCurveGauge" params.want = registry.curve.pools.renCrv.token params.performanceFeeGovernance = 1000 params.performanceFeeStrategist = 1000 params.withdrawalFee = 75 confirm_strategy_common_params(badger.getStrategy("native.renCrv"), params) params = common_strategy_params params.name = "StrategyCurveGauge" params.want = registry.curve.pools.tbtcCrv.token params.performanceFeeGovernance = 1000 params.performanceFeeStrategist = 1000 params.withdrawalFee = 75 confirm_strategy_common_params(badger.getStrategy("native.tbtcCrv"), params) # Harvest Strategies params.name = "StrategyHarvestMetaFarm" params.controller = badger.getController("harvest") params.want = registry.curve.pools.renCrv.token params.performanceFeeGovernance = 0 params.performanceFeeStrategist = 0 params.farmPerformanceFeeGovernance = 1000 params.farmPerformanceFeeStrategist = 1000 params.withdrawalFee = 75 params.harvestVault = registry.harvest.vaults.renCrv params.vaultFarm = registry.harvest.farms.fRenCrv params.metaFarm = registry.harvest.farms.farm params.badgerTree = badger.badgerTree confirm_strategy_common_params(badger.getStrategy("harvest.renCrv"), params) confirm_strategy_harvest_meta_farm_params( badger.getStrategy("harvest.renCrv"), params) """ def confirm_strategy_harvest_meta_farm_params(strategy, params): assert strategy.harvestVault() == params.harvestVault assert strategy.vaultFarm() == params.vaultFarm assert strategy.metaFarm() == params.metaFarm assert strategy.badgerTree() == params.badgerTree assert strategy.farm() == registry.harvest.farmToken assert strategy.depositHelper() == registry.harvest.depositHelper assert strategy.weth() == registry.tokens.weth assert ( strategy.farmPerformanceFeeGovernance() == params.farmPerformanceFeeGovernance ) assert ( strategy.farmPerformanceFeeStrategist() == params.farmPerformanceFeeStrategist ) """ # Supporting Infrastructure: Rewards confirm_staking_rewards_params( badger.getSettRewards("native.badger"), DotMap(approvedStaker=badger.getStrategy("native.badger")), ) confirm_staking_rewards_params( badger.getSettRewards("native.uniBadgerWbtc"), DotMap(approvedStaker=badger.getStrategy("native.uniBadgerWbtc")), )
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