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 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 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 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 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 init_prod_digg(badger: BadgerSystem, user): deployer = badger.deployer digg = badger.digg multi = GnosisSafe(badger.devMultisig) digg_liquidity_amount = 1000000000 wbtc_liquidity_amount = 100000000 print("TOKEN_LOCKER_ROLE", TOKEN_LOCKER_ROLE) locker_role = "0x4bf6f2cdcc8ad6c087a7a4fbecf46150b3686b71387234cac2b3e2e6dc70e345" # TODO: Have this as proxy in real deploy seederLogic = DiggSeeder.deploy({"from": deployer}) seeder = deploy_proxy( "DiggSeeder", DiggSeeder.abi, seederLogic.address, badger.devProxyAdmin.address, seederLogic.initialize.encode_input(digg.diggDistributor), deployer, ) # # Take initial liquidity from DAO # aragon = AragonSystem() # voting = aragon.getVotingAt("0xdc344bfb12522bf3fa58ef0d6b9a41256fc79a1b") # PROD: Configure DIGG digg.uFragmentsPolicy.setCpiOracle( digg.cpiMedianOracle, {"from": deployer}, ) digg.uFragmentsPolicy.setMarketOracle( digg.marketMedianOracle, {"from": deployer}, ) digg.uFragmentsPolicy.setOrchestrator( digg.orchestrator, {"from": deployer}, ) digg.uFragments.setMonetaryPolicy( digg.uFragmentsPolicy, {"from": deployer}, ) # ===== Upgrade DAOTimelock to allow voting ===== # print(badger.logic.SimpleTimelockWithVoting.address) # timelockWithVotingLogic = SimpleTimelockWithVoting.at(badger.logic.SimpleTimelockWithVoting.address) # timelock = interface.ISimpleTimelockWithVoting(badger.daoBadgerTimelock.address) # multi.execute( # MultisigTxMetadata(description="Upgrade DAO Badger Timelock to Allow voting",), # { # "to": badger.devProxyAdmin.address, # "data": badger.devProxyAdmin.upgrade.encode_input( # badger.daoBadgerTimelock, timelockWithVotingLogic # ), # }, # ) # # ===== Vote to move initial liquidity funds to multisig ===== # tx = multi.execute( # MultisigTxMetadata(description="Vote on DAO Timelock from multisig",), # { # "to": timelock.address, # "data": timelock.vote.encode_input(0, True, True) # }, # ) # # Approve DAO voting as recipient # multi.execute( # MultisigTxMetadata(description="Approve DAO voting as recipient",), # { # "to": badger.rewardsEscrow.address, # "data": badger.rewardsEscrow.approveRecipient.encode_input(voting), # }, # ) # # Vote on DAO voting as rewardsEscrow # before = badger.token.balanceOf(badger.rewardsEscrow) # tx = multi.execute( # MultisigTxMetadata(description="Vote on Rewards Escrow from multisig",), # { # "to": badger.rewardsEscrow.address, # "data": badger.rewardsEscrow.call.encode_input( # voting, 0, voting.vote.encode_input(0, True, True) # ), # }, # ) # after = badger.token.balanceOf(badger.rewardsEscrow) # print(tx.call_trace()) # assert after == before # crvRen = interface.IERC20(registry.curve.pools.renCrv.token) wbtc = interface.IERC20(registry.tokens.wbtc) # assert crvRen.balanceOf(badger.devMultisig) >= wbtc_liquidity_amount * 10 ** 10 * 2 # crvPool = interface.ICurveZap(registry.curve.pools.renCrv.swap) # # crvPool.Remove_liquidity_one_coin( # # wbtc_liquidity_amount * 10 ** 10, 1, wbtc_liquidity_amount # # ) # # ===== Convert crvRen to wBTC on multisig ===== # tx = multi.execute( # MultisigTxMetadata(description="Withdraw crvRen for 100% WBTC",), # { # "to": crvPool.address, # "data": crvPool.remove_liquidity_one_coin.encode_input( # wbtc_liquidity_amount * 10 ** 10 * 2, 1, wbtc_liquidity_amount * 2 # ), # }, # ) # assert wbtc.balanceOf(badger.devMultisig) >= wbtc_liquidity_amount * 2 # ===== Move initial liquidity funds to Seeder ===== multi.execute( MultisigTxMetadata( description="Transfer initial liquidity WBTC to the Seeder", ), { "to": wbtc.address, "data": wbtc.transfer.encode_input(seeder, 200000000), }, ) # ===== Move DIGG to Seeder ===== digg.token.transfer(seeder, digg.token.totalSupply(), {"from": deployer}) # ===== Move Required Badger to Seeder from RewardsEscrow ===== multi.execute( MultisigTxMetadata( description="Move Required Badger to Seeder from RewardsEscrow", ), { "to": badger.rewardsEscrow.address, "data": badger.rewardsEscrow.transfer.encode_input(badger.token, seeder, Wei("30000 ether")), }, ) # ===== Add DIGG token to all geyser distribution lists ===== # (Also, add Seeder as approved schedule creator) geyser_keys = [ "native.badger", "native.renCrv", "native.sbtcCrv", "native.tbtcCrv", "native.uniBadgerWbtc", "harvest.renCrv", "native.sushiWbtcEth", "native.sushiBadgerWbtc", "native.uniDiggWbtc", "native.sushiDiggWbtc", ] for key in geyser_keys: geyser = badger.getGeyser(key) print(key, geyser) id = multi.addTx( MultisigTxMetadata( description="Add DIGG token to distribution tokens on {} geyser" .format(key), ), { "to": geyser.address, "data": geyser.addDistributionToken.encode_input(digg.token), }, ) tx = multi.executeTx(id) assert geyser.hasRole(DEFAULT_ADMIN_ROLE, badger.devMultisig) multi.execute( MultisigTxMetadata( description="Allow Seeder to set unlock schedules on {} geyser" .format(key), ), { "to": geyser.address, "data": geyser.grantRole.encode_input(locker_role, seeder), }, ) assert geyser.hasRole(locker_role, seeder) # Seeder needs to have admin role to config Faucets. Remove role as part of seed. rewards_keys = [ "native.digg", "native.uniDiggWbtc", "native.sushiDiggWbtc", ] for key in rewards_keys: rewards = badger.getSettRewards(key) rewards.grantRole(DEFAULT_ADMIN_ROLE, seeder, {"from": deployer}) rewards.grantRole(DEFAULT_ADMIN_ROLE, badger.devMultisig, {"from": deployer}) rewards.renounceRole(DEFAULT_ADMIN_ROLE, deployer, {"from": deployer}) # print(digg.token.balanceOf(deployer)) # assert digg.token.balanceOf(deployer) == digg.token.totalSupply() # digg.token.transfer(seeder, digg.token.totalSupply(), {"from": deployer}) # wbtc = interface.IERC20(token_registry.wbtc) # wbtc.transfer(seeder, 200000000, {"from": user}) # ===== Seed Prep ===== print("wbtc.balanceOf(seeder)", wbtc.balanceOf(seeder)) assert digg.token.balanceOf(seeder) >= digg.token.totalSupply() assert wbtc.balanceOf(seeder) >= 200000000 print(digg.diggDistributor.address) print("digg.diggDistributor", digg.diggDistributor.isOpen()) digg.diggDistributor.transferOwnership(seeder, {"from": deployer}) print("prePreSeed", digg.token.balanceOf(seeder)) seeder.preSeed({"from": deployer}) print("postPreSeed", digg.token.balanceOf(seeder)) seeder.seed({"from": deployer}) # seeder.transferOwnership(badger.devMultisig, {'from': deployer}) # tx = multi.execute( # MultisigTxMetadata(description="Withdraw crvRen for 100% WBTC",), # { # "to": seeder.address, # "data": seeder.preSeed.encode_input(), # }, # ) # seeder.initialize({"from": deployer}) # Unpause all Setts setts_to_unpause = [ "native.digg", "native.uniDiggWbtc", "native.sushiDiggWbtc", ] for key in setts_to_unpause: sett = badger.getSett(key) id = multi.addTx( MultisigTxMetadata(description="Unpause Sett {}".format(key), ), { "to": sett.address, "data": sett.unpause.encode_input(), }, ) tx = multi.executeTx(id) assert sett.paused() == False
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 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 confirm_setup_rewards(badger: BadgerSystem): # Badger Tree confirm_badger_tree_params( badger, badger.badgerTree, DotMap( admin=badger.devMultisig, rootUpdater=badger.deployer, guardian=badger.deployer, # initialBalance=badger.initialBadgerTreeBalance, ), ) # Rewards Escrow confirm_rewards_escrow_params(badger.rewardsEscrow, DotMap(owner=badger.devMultisig)) # Badger Hunt confirm_badger_hunt_params( badger.badgerHunt, DotMap( token=badger.token, merkleRoot=EmptyBytes32, epochDuration=days(1), rewardReductionPerEpoch=2000, claimsStart=badger_config.globalStartTime, gracePeriod=days(2), rewardsEscrow=badger.rewardsEscrow, currentRewardRate=10000, ), ) # Badger Geysers common_geyser_params = DotMap( tokenLockers=[badger.rewardsEscrow.address], admin=badger.devMultisig, initialDistributionToken=badger.token, ) params = common_geyser_params params.stakingToken = badger.getSett("native.renCrv") confirm_badger_geyser_params(badger.getGeyser("native.renCrv"), params) params.stakingToken = badger.getSett("native.sbtcCrv") confirm_badger_geyser_params(badger.getGeyser("native.sbtcCrv"), params) params.stakingToken = badger.getSett("native.tbtcCrv") confirm_badger_geyser_params(badger.getGeyser("native.tbtcCrv"), params) params.stakingToken = badger.getSett("native.badger") confirm_badger_geyser_params(badger.getGeyser("native.badger"), params) params.stakingToken = badger.getSett("harvest.renCrv") confirm_badger_geyser_params(badger.getGeyser("harvest.renCrv"), params) # # Ensure staking not possible # for key, geyser in badger.geysers.items(): # with brownie.reverts("BadgerGeyser: Distribution not started"): # geyser.stake(0, "0x", {"from": badger.deployer}) # geyser.stakeFor(0, "0x", badger.deployer, {"from": badger.deployer}) # Badger Balances # Some of the initial supply is distributed to Sett special StakingRewards pools & BadgerTree assert (badger.token.balanceOf( badger.rewardsEscrow) == badger.initialRewardsEscrowBalance) assert (badger.token.balanceOf( badger.badgerHunt) == badger_config.huntParams.badgerAmount) assert (badger.token.balanceOf(badger.daoBadgerTimelock) == badger_config.tokenLockParams.badgerLockAmount)
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")), )