def get_expected_strategy_deposit_location(badger: BadgerSystem, id):
if id == "native.badger":
# Rewards Staking
return badger.getSettRewards("native.badger")
if id == "native.uniBadgerWbtc":
# Rewards Staking
return badger.getSettRewards("native.uniBadgerWbtc")
if id == "native.renCrv":
# CRV Gauge
return registry.curve.pools.renCrv.gauge
if id == "native.sbtcCrv":
# CRV Gauge
return registry.curve.pools.sbtcCrv.gauge
if id == "native.tbtcCrv":
# CRV Gauge
return registry.curve.pools.tbtcCrv.gauge
if id == "harvest.renCrv":
# Harvest Vault
return registry.harvest.vaults.renCrv
if id == "native.sushiWbtcEth":
# Sushi Chef
return registry.sushi.sushiChef
if id == "native.sushiBadgerWbtc":
# Sushi Chef
return registry.sushi.sushiChef
def start_staking_rewards(badger: BadgerSystem):
"""
StakingRewards contracts start immediately when the first tokens are locked
"""
# == Badger ==
deployer = badger.deployer
rewards = badger.getSettRewards("native.badger")
assert (badger.token.balanceOf(rewards) >=
badger_config.geyserParams.unlockSchedules.badger[0].amount)
assert rewards.stakingToken() == badger.token
assert rewards.rewardsToken() == badger.token
rewards.notifyRewardAmount(
badger_config.geyserParams.unlockSchedules.badger[0].amount,
{"from": deployer})
# == Uni LP ==
rewards = badger.getSettRewards("native.uniBadgerWbtc")
assert (badger.token.balanceOf(rewards) >=
badger_config.geyserParams.unlockSchedules.uniBadgerWbtc[0].amount)
assert rewards.stakingToken() == badger.pair
assert rewards.rewardsToken() == badger.token
rewards.notifyRewardAmount(
badger_config.geyserParams.unlockSchedules.uniBadgerWbtc[0].amount,
{"from": deployer},
)
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 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")),
)