def deploy_dao_badger_timelock(self):
deployer = self.deployer
print(
self.token,
self.dao.agent,
badger_config.globalStartTime,
badger_config.tokenLockParams.lockDuration,
(
badger_config.globalStartTime
+ badger_config.tokenLockParams.lockDuration
),
chain.time(),
)
self.daoBadgerTimelock = deploy_proxy(
"SimpleTimelock",
SimpleTimelock.abi,
self.logic.SimpleTimelock.address,
self.devProxyAdmin.address,
self.logic.SimpleTimelock.initialize.encode_input(
self.token,
self.dao.agent,
badger_config.globalStartTime
+ badger_config.tokenLockParams.lockDuration,
),
self.deployer,
)
self.track_contract_upgradeable("daoBadgerTimelock", self.daoBadgerTimelock)
def deploy_digg_team_vesting(self):
deployer = self.deployer
print(
self.token,
self.devMultisig,
self.dao.agent,
self.config.startTime,
self.config.teamVestingParams.cliffDuration,
self.config.teamVestingParams.totalDuration,
chain.time(),
)
self.diggTeamVesting = deploy_proxy(
"SmartVesting",
SmartVesting.abi,
self.logic.SmartVesting.address,
self.devProxyAdmin.address,
self.logic.SmartVesting.initialize.encode_input(
self.token,
self.devMultisig,
self.dao.agent,
self.config.startTime,
self.config.teamVestingParams.cliffDuration,
self.config.teamVestingParams.totalDuration,
),
deployer,
)
self.track_contract_upgradeable("teamVesting", self.diggTeamVesting)
def deploy_controller(
badger,
deployer,
governance=None,
strategist=None,
keeper=None,
rewards=None,
proxyAdmin=None,
):
# TODO: Change to prod config
# Set default roles if not specified
if not governance:
governance = deployer
if not strategist:
strategist = deployer
if not keeper:
keeper = badger.keeper
if not rewards:
rewards = badger.dao.agent
if not proxyAdmin:
proxyAdmin = badger.devProxyAdmin
return deploy_proxy(
"Controller",
Controller.abi,
badger.logic.Controller.address,
proxyAdmin.address,
badger.logic.Controller.initialize.encode_input(
governance, strategist, keeper, rewards),
deployer,
)
def deploy_sett(
self,
id,
token,
controller,
namePrefixOverride=False,
namePrefix="",
symbolPrefix="",
):
deployer = self.deployer
proxyAdmin = self.devProxyAdmin
governance = deployer
keeper = deployer
sett = deploy_proxy(
"Sett",
Sett.abi,
self.logic.Sett.address,
proxyAdmin.address,
self.logic.Sett.initialize.encode_input(
token,
controller,
governance,
keeper,
namePrefixOverride,
namePrefix,
symbolPrefix,
),
deployer,
)
self.sett_system.vaults[id] = sett
self.track_contract_upgradeable(id + ".sett", sett)
print("tracked", sett)
return sett
def deploy_adapter(self, registry, router, deployer):
config = self.config
# deployer = self.deployer
devProxyAdmin = self.devProxyAdmin
logic = self.logic
self.adapter = deploy_proxy(
"BadgerBridgeAdapter",
BadgerBridgeAdapter.abi,
logic.BadgerBridgeAdapter.address,
web3.toChecksumAddress(devProxyAdmin.address),
logic.BadgerBridgeAdapter.initialize.encode_input(
config.governance,
config.rewards,
registry,
router,
config.wbtc,
[
config.mintFeeBps,
config.burnFeeBps,
config.percentageFeeRewardsBps,
config.percentageFeeGovernanceBps,
],
),
deployer,
)
def deploy_digg_policy(self):
deployer = self.deployer
self.uFragmentsPolicy = deploy_proxy(
"UFragmentsPolicy",
UFragmentsPolicy.abi,
self.logic.UFragmentsPolicy.address,
self.devProxyAdmin.address,
self.logic.UFragmentsPolicy.initialize.encode_input(
self.owner,
self.uFragments,
self.config.baseCpi,
),
deployer,
)
config = self.config
# TODO: F/u on why these values are not being set.
self.uFragmentsPolicy.setDeviationThreshold(config.deviationThreshold,
{"from": deployer})
self.uFragmentsPolicy.setRebaseLag(config.rebaseLag,
{"from": deployer})
self.uFragmentsPolicy.setRebaseTimingParameters(
config.minRebaseTimeIntervalSec,
config.rebaseWindowOffsetSec,
config.rebaseWindowLengthSec,
{"from": deployer},
)
self.track_contract_upgradeable("uFragmentsPolicy",
self.uFragmentsPolicy)
self.track_contract_ownable(self.uFragmentsPolicy)
def setup_badger(badger: BadgerSystem, settConfig):
controller = badger.getController("native")
console.print(registry.pancake.chefPids.bnbBtcb)
strategyLogic = StrategyPancakeLpOptimizer.deploy({"from": badger.deployer})
strategy = deploy_proxy(
"StrategyPancakeLpOptimizer",
StrategyPancakeLpOptimizer.abi,
strategyLogic.address,
badger.devProxyAdmin.address,
strategyLogic.initialize.encode_input(
badger.devMultisig,
badger.deployer,
controller,
badger.keeper,
badger.guardian,
[
registry.pancake.chefPairs.bnbBtcb,
registry.tokens.btcb,
registry.tokens.bnb,
],
[100, 100, 50],
15,
),
badger.deployer,
)
token0 = registry.tokens.btcb
token1 = registry.tokens.bnb
cake = registry.pancake.cake
strategy.setTokenSwapPath(cake, token0, [cake, token0], {"from": badger.deployer})
strategy.setTokenSwapPath(cake, token1, [cake, token1], {"from": badger.deployer})
# want = interface.IERC20(registry.pancake.chefPairs.bnbBtcb)
# multi = accounts.at(badger.devMultisig.address, force=True)
# snap = SnapshotManager(badger, settConfig["id"])
table = []
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 deploy_rewards_escrow(self):
deployer = self.deployer
print("deployer", deployer)
self.rewardsEscrow = deploy_proxy(
"RewardsEscrow",
RewardsEscrow.abi,
self.logic.RewardsEscrow.address,
self.devProxyAdmin.address,
self.logic.RewardsEscrow.initialize.encode_input(),
deployer,
)
self.track_contract_upgradeable("rewardsEscrow", self.rewardsEscrow)
def deploy_router(self):
admin = self.admin
devProxyAdmin = self.devProxyAdmin
self.router = deploy_proxy(
"SwapStrategyRouter",
SwapStrategyRouter.abi,
self.logic.SwapStrategyRouter.address,
web3.toChecksumAddress(devProxyAdmin.address),
self.logic.SwapStrategyRouter.initialize.encode_input(
admin.address, ),
self.deployer,
)
def deploy_sett_native_badger(badger, deployer):
badger.add_controller("native")
badger.deploy_sett("native")
sett = DotMap(logic=deploy_sett_common_logic(deployer))
sett.logic.StrategyBadgerRewards = StrategyBadgerRewards.deploy(
{"from": deployer})
sett.controller = deploy_controller(badger, sett, deployer)
sett.sett = deploy_sett(
badger,
sett,
badger.token,
sett.controller,
"Badger Sett badger",
"bBadger",
deployer,
)
sett.rewards = deploy_proxy(
"StakingRewards",
StakingRewards.abi,
sett.logic.StakingRewards.address,
badger.devProxyAdmin.address,
sett.logic.StakingRewards.initialize.encode_input(
deployer, badger.token, badger.token),
deployer,
)
params = sett_config.native.badger.params
params.want = badger.token
params.geyser = sett.rewards
sett.strategy = deploy_strategy(
badger,
sett,
"StrategyBadgerRewards",
sett.controller,
params,
deployer,
)
sett.want = interface.IERC20(sett.strategy.want())
configure_sett(sett, deployer)
# Approve Setts on specific
sett.rewards.grantRole(APPROVED_STAKER_ROLE, sett.strategy,
{"from": deployer})
return sett
def deploy_digg_rewards_faucet(self, id, diggToken):
deployer = self.deployer
rewards = deploy_proxy(
"DiggRewardsFaucet",
DiggRewardsFaucet.abi,
self.logic.DiggRewardsFaucet.address,
self.devProxyAdmin.address,
self.logic.DiggRewardsFaucet.initialize.encode_input(deployer, diggToken),
deployer,
)
self.sett_system.rewards[id] = rewards
self.track_contract_upgradeable(id + ".rewards", rewards)
return rewards
def deploy_curve_swap_strategy(self):
config = self.config
admin = self.admin
devProxyAdmin = self.devProxyAdmin
self.strategies.curve = deploy_proxy(
"CurveSwapStrategy",
CurveSwapStrategy.abi,
self.logic.CurveSwapStrategy.address,
web3.toChecksumAddress(devProxyAdmin.address),
self.logic.CurveSwapStrategy.initialize.encode_input(
admin.address,
config.strategies.curve.registry,
),
self.deployer,
)
def deploy_dao_digg_timelock(self):
deployer = self.owner
self.daoDiggTimelock = deploy_proxy(
"SimpleTimelock",
SimpleTimelock.abi,
self.logic.SimpleTimelock.address,
self.devProxyAdmin.address,
self.logic.SimpleTimelock.initialize.encode_input(
self.token,
self.dao.agent,
self.config.startTime
+ self.config.tokenLockParams.lockDuration,
),
deployer,
)
self.track_contract_upgradeable("daoDiggTimelock", self.daoDiggTimelock)
def deploy_digg_token(self):
deployer = self.owner
self.uFragments = deploy_proxy(
"UFragments",
UFragments.abi,
self.logic.UFragments.address,
self.devProxyAdmin.address,
self.logic.UFragments.initialize.encode_input(self.owner, ),
deployer,
)
self.track_contract_upgradeable("uFragments", self.uFragments)
self.track_contract_ownable(self.uFragments)
# Set the digg system token after deploying.
# TODO: Move this to a better place.
self.token = self.uFragments
def deploy_airdrop_distributor(self, root, rewardsEscrow,
reclaimAllowedTimestamp):
deployer = self.deployer
self.diggDistributor = deploy_proxy(
"DiggDistributor",
DiggDistributor.abi,
self.logic.DiggDistributor.address,
self.devProxyAdmin.address,
self.logic.DiggDistributor.initialize.encode_input(
self.token, root, rewardsEscrow, reclaimAllowedTimestamp),
deployer,
)
self.track_contract_upgradeable("diggDistributor",
self.diggDistributor)
def deploy_digg_policy(self):
deployer = self.owner
self.uFragmentsPolicy = deploy_proxy(
"UFragmentsPolicy",
UFragmentsPolicy.abi,
self.logic.UFragmentsPolicy.address,
self.devProxyAdmin.address,
self.logic.UFragmentsPolicy.initialize.encode_input(
self.owner,
self.uFragments,
self.config.baseCpi,
),
deployer,
)
self.track_contract_upgradeable("uFragmentsPolicy", self.uFragmentsPolicy)
self.track_contract_ownable(self.uFragmentsPolicy)
def deploy_sett_staking_rewards(self, id, stakingToken, distToken):
deployer = self.deployer
rewards = deploy_proxy(
"StakingRewards",
StakingRewards.abi,
self.logic.StakingRewards.address,
self.devProxyAdmin.address,
self.logic.StakingRewards.initialize.encode_input(
deployer, distToken, stakingToken),
deployer,
)
self.sett_system.rewards[id] = rewards
self.track_contract_upgradeable(id + ".rewards", rewards)
return rewards
def deploy_controller(badger, deployer):
# TODO: Change to prod config
governance = deployer
strategist = deployer
keeper = badger.keeper
rewards = badger.dao.agent
proxyAdmin = badger.devProxyAdmin
return deploy_proxy(
"Controller",
Controller.abi,
badger.logic.Controller.address,
proxyAdmin.address,
badger.logic.Controller.initialize.encode_input(
governance, strategist, keeper, rewards),
deployer,
)
def deploy_sett(
self,
id,
token,
controller,
namePrefixOverride=False,
namePrefix="",
symbolPrefix="",
governance=None,
strategist=None,
keeper=None,
guardian=None,
):
deployer = self.deployer
proxyAdmin = self.devProxyAdmin
if not governance:
governance = deployer
if not strategist:
strategist = deployer
if not keeper:
keeper = deployer
if not guardian:
guardian = deployer
sett = deploy_proxy(
"Sett",
Sett.abi,
self.logic.Sett.address,
proxyAdmin.address,
self.logic.Sett.initialize.encode_input(
token,
controller,
governance,
keeper,
guardian,
namePrefixOverride,
namePrefix,
symbolPrefix,
),
deployer,
)
self.sett_system.vaults[id] = sett
self.track_contract_upgradeable(id + ".sett", sett)
return sett
def deploy_badger_tree(self):
deployer = self.deployer
print(
self.logic.BadgerTree.address,
self.devProxyAdmin.address,
self.keeper,
self.guardian,
)
self.badgerTree = deploy_proxy(
"BadgerTree",
BadgerTree.abi,
self.logic.BadgerTree.address,
self.devProxyAdmin.address,
self.logic.BadgerTree.initialize.encode_input(
self.deployer, self.keeper, self.guardian),
deployer,
)
self.track_contract_upgradeable("badgerTree", self.badgerTree)
def deploy_sett(badger, token, controller, name, symbol, deployer):
"""
Deploy Sett Instance
"""
proxyAdmin = badger.devProxyAdmin
governance = deployer
keeper = badger.keeper
return deploy_proxy(
"Sett",
Sett.abi,
badger.logic.Sett.address,
proxyAdmin.address,
badger.logic.Sett.initialize.encode_input(
token, controller, governance, keeper, name, symbol
),
deployer,
)
def deploy_team_vesting(self):
deployer = self.deployer
self.teamVesting = deploy_proxy(
"SmartVesting",
SmartVesting.abi,
self.logic.SmartVesting.address,
self.devProxyAdmin.address,
self.logic.SmartVesting.initialize.encode_input(
self.token,
self.devMultisig,
self.dao.agent,
badger_config.globalStartTime,
badger_config.teamVestingParams.cliffDuration,
badger_config.teamVestingParams.totalDuration,
),
self.deployer,
)
self.track_contract_upgradeable("teamVesting", self.teamVesting)
def deploy_geyser(badger, stakingToken):
pool_input = DotMap(
stakingToken=stakingToken.address,
initialDistributionToken=badger.token.address,
)
return deploy_proxy(
"BadgerGeyser",
BadgerGeyser.abi,
badger.logic.BadgerGeyser.address,
badger.devProxyAdmin.address,
badger.logic.BadgerGeyser.initialize.encode_input(
pool_input["stakingToken"],
pool_input["initialDistributionToken"],
badger_config.geyserParams.badgerDistributionStart,
badger.devMultisig.address,
badger.rewardsEscrow.address,
),
badger.deployer,
)
def deploy_badger_hunt(self):
deployer = self.deployer
self.badgerHunt = deploy_proxy(
"BadgerHunt",
BadgerHunt.abi,
self.logic.BadgerHunt.address,
self.devProxyAdmin.address,
self.logic.BadgerHunt.initialize.encode_input(
self.token,
badger_config.huntParams.merkleRoot,
badger_config.huntParams.epochDuration,
badger_config.huntParams.claimReductionPerEpoch,
badger_config.huntParams.startTime,
badger_config.huntParams.gracePeriod,
self.rewardsEscrow,
self.deployer,
),
deployer,
)
self.track_contract_upgradeable("badgerHunt", self.badgerHunt)
def main():
badger = connect_badger(badger_config.prod_json)
deployer = badger.deployer
# distribute_from_whales(deployer)
# Deploy Honeypot
artifact = BadgerRewardsManager
logic = BadgerRewardsManager.at(badger.logic.BadgerRewardsManager)
console.print("Logic Contract", logic)
contract = deploy_proxy(
"BadgerRewardsManager",
artifact.abi,
logic.address,
badger.devProxyAdmin.address,
logic.initialize.encode_input(
badger.deployer,
badger.keeper,
badger.keeper,
badger.guardian,
badger.devMultisig,
),
deployer,
)
strat_keys = [
"native.badger",
"native.uniBadgerWbtc",
"native.sushiBadgerWbtc",
"native.digg",
"native.uniDiggWbtc",
"native.sushiDiggWbtc",
]
for key in strat_keys:
strategy = badger.getStrategy(key)
print(key, strategy)
contract.approveStrategy(strategy, {
"from": badger.deployer,
"gas_strategy": gas_strategies.fast
})
def main():
badger = connect_badger(badger_config.prod_json)
deployer = badger.deployer
# distribute_from_whales(badger, deployer)
# Deploy Honeypot
honeypotLogic = HoneypotMeme.deploy({"from": deployer})
honeypot_params = DotMap(
token=badger.token,
amount=Wei("2500 ether"),
nftIndicies=[97, 98, 99, 100, 101, 102],
meme="0xe4605d46Fd0B3f8329d936a8b258D69276cBa264",
badgerCollection="0x14dC10FA6E4878280F9CA0D9f32dDAEa8C7d4d45",
)
honeypot = deploy_proxy(
"HoneypotMeme",
HoneypotMeme.abi,
honeypotLogic.address,
badger.devProxyAdmin.address,
honeypotLogic.initialize.encode_input(
honeypot_params.token,
honeypot_params.amount,
honeypot_params.nftIndicies,
),
deployer,
)
assert honeypot.token() == badger.token
assert honeypot.memeLtd() == honeypot_params.meme
assert honeypot.honeypot() == honeypot_params.amount
assert honeypot.nftIndicies(0) == honeypot_params.nftIndicies[0]
assert honeypot.nftIndicies(1) == honeypot_params.nftIndicies[1]
assert honeypot.nftIndicies(2) == honeypot_params.nftIndicies[2]
assert honeypot.nftIndicies(3) == honeypot_params.nftIndicies[3]
assert honeypot.nftIndicies(4) == honeypot_params.nftIndicies[4]
assert honeypot.nftIndicies(5) == honeypot_params.nftIndicies[5]
def setup(StrategyConvexStakingOptimizer, ):
# Assign accounts
with open(digg_config.prod_json) as f:
badger_deploy = json.load(f)
deployer = accounts.at(badger_deploy["deployer"], force=True)
guardian = accounts.at(badger_deploy["guardian"], force=True)
keeper = accounts.at(badger_deploy["keeper"], force=True)
governance = accounts.at(badger_deploy["timelock"], force=True)
strategist = accounts[3]
user1 = accounts[4]
user2 = accounts[5]
user3 = accounts[6]
namedAccounts = {
"deployer": deployer,
"guardian": guardian,
"keeper": keeper,
"governance": governance,
"strategist": strategist,
"user1": user1,
"user2": user2,
"user3": user3,
}
# Setup Badger system
badger = connect_badger(badger_config.prod_json)
distribute_test_ether(deployer, Wei("20 ether"))
# Key of Sett to migrate (ONLY UNCOMMENT THE ONE TO TEST):
settKey = "native.renCrv"
# settKey = "native.sbtcCrv"
# settKey = "native.tbtcCrv"
# Connect to prod controller and vault
vault = badger.sett_system.vaults[settKey]
print("Vault for " + settKey + " fetched with address " + vault.address)
controller = interface.IController(vault.controller())
print("Controller for " + settKey + " fetched with address " +
controller.address)
# Deploy and initialize the strategy
if settKey == "native.renCrv":
params = sett_config.native.convexRenCrv.params
want = sett_config.native.convexRenCrv.params.want
# Transfer assets to users
distribute_from_whales(user1, 1, "renCrv")
if settKey == "native.sbtcCrv":
params = sett_config.native.convexSbtcCrv.params
want = sett_config.native.convexSbtcCrv.params.want
# Transfer assets to users
distribute_from_whales(user1, 1, "sbtcCrv")
if settKey == "native.tbtcCrv":
params = sett_config.native.convexTbtcCrv.params
want = sett_config.native.convexTbtcCrv.params.want
# Transfer assets to users
distribute_from_whales(user1, 1, "tbtcCrv")
contract = StrategyConvexStakingOptimizer.deploy({"from": deployer})
strategy = deploy_proxy(
"StrategyConvexStakingOptimizer",
StrategyConvexStakingOptimizer.abi,
contract.address,
web3.toChecksumAddress(badger.devProxyAdmin.address),
contract.initialize.encode_input(
governance.address,
strategist.address,
controller.address,
keeper.address,
guardian.address,
[
params.want,
badger.badgerTree.address,
params.cvxHelperVault,
params.cvxCrvHelperVault,
],
params.pid,
[
params.performanceFeeGovernance,
params.performanceFeeStrategist,
params.withdrawalFee,
],
(
params.curvePool.swap,
params.curvePool.wbtcPosition,
params.curvePool.numElements,
),
),
deployer,
)
# Finish setup
yield namedtuple("setup",
"badger controller vault strategy namedAccounts")(
badger, controller, vault, strategy, namedAccounts)
def deploy_strategy(
badger,
strategyName,
controller,
params,
deployer,
governance=None,
strategist=None,
keeper=None,
guardian=None,
):
if not governance:
governance = deployer
if not strategist:
strategist = deployer
if not keeper:
keeper = badger.keeper
if not guardian:
guardian = badger.guardian
proxyAdmin = badger.devProxyAdmin
console.print(
"Deploy Strategy "+ strategyName, params
)
if strategyName == "StrategyCurveGaugeRenBtcCrv":
return deploy_proxy(
"StrategyCurveGaugeRenBtcCrv",
StrategyCurveGaugeRenBtcCrv.abi,
badger.logic.StrategyCurveGaugeRenBtcCrv.address,
proxyAdmin.address,
badger.logic.StrategyCurveGaugeRenBtcCrv.initialize.encode_input(
governance,
strategist,
controller,
keeper,
guardian,
[
params.want,
params.gauge,
params.minter,
params.swap,
params.lpComponent,
],
[
params.performanceFeeGovernance,
params.performanceFeeStrategist,
params.withdrawalFee,
params.keepCRV,
],
),
deployer,
)
if strategyName == "StrategyCurveGaugeSbtcCrv":
return deploy_proxy(
"StrategyCurveGaugeSbtcCrv",
StrategyCurveGaugeSbtcCrv.abi,
badger.logic.StrategyCurveGaugeSbtcCrv.address,
proxyAdmin.address,
badger.logic.StrategyCurveGaugeSbtcCrv.initialize.encode_input(
governance,
strategist,
controller,
keeper,
guardian,
[
params.want,
params.gauge,
params.minter,
params.swap,
params.lpComponent,
],
[
params.performanceFeeGovernance,
params.performanceFeeStrategist,
params.withdrawalFee,
params.keepCRV,
],
),
deployer,
)
if strategyName == "StrategyCurveGaugeTbtcCrv":
return deploy_proxy(
"StrategyCurveGaugeTbtcCrv",
StrategyCurveGaugeTbtcCrv.abi,
badger.logic.StrategyCurveGaugeTbtcCrv.address,
proxyAdmin.address,
badger.logic.StrategyCurveGaugeTbtcCrv.initialize.encode_input(
governance,
strategist,
controller,
keeper,
guardian,
[
params.want,
params.gauge,
params.minter,
params.swap,
params.lpComponent,
],
[
params.performanceFeeGovernance,
params.performanceFeeStrategist,
params.withdrawalFee,
params.keepCRV,
],
),
deployer,
)
if strategyName == "StrategySushiLpOptimizer":
return deploy_proxy(
"StrategySushiLpOptimizer",
StrategySushiLpOptimizer.abi,
badger.logic.StrategySushiLpOptimizer.address,
proxyAdmin.address,
badger.logic.StrategySushiLpOptimizer.initialize.encode_input(
governance,
strategist,
controller,
keeper,
guardian,
[
params.want,
params.badgerTree,
],
params.pid,
[
params.performanceFeeGovernance,
params.performanceFeeStrategist,
params.withdrawalFee
],
),
deployer,
)
if strategyName == "StrategySushiBadgerWbtc":
return deploy_proxy(
"StrategySushiBadgerWbtc",
StrategySushiBadgerWbtc.abi,
badger.logic.StrategySushiBadgerWbtc.address,
proxyAdmin.address,
badger.logic.StrategySushiBadgerWbtc.initialize.encode_input(
governance,
strategist,
controller,
keeper,
guardian,
[
params.want,
params.geyser,
params.badger,
params.badgerTree
],
[
params.performanceFeeGovernance,
params.performanceFeeStrategist,
params.withdrawalFee
],
),
deployer,
)
if strategyName == "StrategyPickleMetaFarm":
return deploy_proxy(
"StrategyPickleMetaFarm",
StrategyPickleMetaFarm.abi,
badger.logic.StrategyPickleMetaFarm.address,
proxyAdmin.address,
badger.logic.StrategyPickleMetaFarm.initialize.encode_input(
governance,
strategist,
controller,
keeper,
guardian,
[params.want, params.pickleJar, curve.pools.renCrv.swap, tokens.wbtc],
params.pid,
[
params.performanceFeeGovernance,
params.performanceFeeStrategist,
params.withdrawalFee,
],
),
deployer,
)
if strategyName == "StrategyHarvestMetaFarm":
return deploy_proxy(
"StrategyHarvestMetaFarm",
StrategyHarvestMetaFarm.abi,
badger.logic.StrategyHarvestMetaFarm.address,
proxyAdmin.address,
badger.logic.StrategyHarvestMetaFarm.initialize.encode_input(
governance,
strategist,
controller,
keeper,
guardian,
[
params.want,
params.harvestVault,
params.vaultFarm,
params.metaFarm,
params.badgerTree,
],
[
params.performanceFeeGovernance,
params.performanceFeeStrategist,
params.withdrawalFee,
],
),
deployer,
)
if strategyName == "StrategyBadgerLpMetaFarm":
return deploy_proxy(
"StrategyBadgerLpMetaFarm",
StrategyBadgerLpMetaFarm.abi,
badger.logic.StrategyBadgerLpMetaFarm.address,
proxyAdmin.address,
badger.logic.StrategyBadgerLpMetaFarm.initialize.encode_input(
governance,
strategist,
controller,
keeper,
guardian,
[params.want, params.geyser, badger.token],
[
params.performanceFeeGovernance,
params.performanceFeeStrategist,
params.withdrawalFee,
],
),
deployer,
)
if strategyName == "StrategyBadgerRewards":
return deploy_proxy(
"StrategyBadgerRewards",
StrategyBadgerRewards.abi,
badger.logic.StrategyBadgerRewards.address,
proxyAdmin.address,
badger.logic.StrategyBadgerRewards.initialize.encode_input(
governance,
strategist,
controller,
keeper,
guardian,
[badger.token, params.geyser],
[
params.performanceFeeGovernance,
params.performanceFeeStrategist,
params.withdrawalFee,
],
),
deployer,
)
def deploy_sett_system(badger, deployer):
proxyAdmin = badger.proxyAdmin
deployer = badger.deployer
# Logic
sett = DotMap(logic=deploy_sett_logic(deployer))
# Controllers
sett.native.controller = deploy_controller(badger, sett, deployer)
sett.pickle.controller = deploy_controller(badger, sett, deployer)
sett.harvest.controller = deploy_controller(badger, sett, deployer)
# Deploy each pair of vault and strategy
"""
For each group of Setts (native, harvest, pickle) iterate through each vault
entry and deploy the Sett and starting strategy
"""
# Deploy Setts
sett.native.badger = deploy_sett(
badger,
sett,
badger.token,
sett.native.controller,
"Badger Sett badger",
"bBadger",
deployer,
)
sett.native.sbtcCrv = deploy_sett(
badger,
sett,
sett_config.native.sbtcCrv.params.want,
sett.native.controller,
"Badger Sett sbtcCrv",
"bSbtcCrv",
deployer,
)
sett.native.renCrv = deploy_sett(
badger,
sett,
sett_config.native.renCrv.params.want,
sett.native.controller,
"Badger Sett renCrv",
"bRenCrv",
deployer,
)
sett.native.tbtcCrv = deploy_sett(
badger,
sett,
sett_config.native.tbtcCrv.params.want,
sett.native.controller,
"Badger Sett tbtcCrv",
"bTbtcCrv",
deployer,
)
sett.pickle.renCrv = deploy_sett(
badger,
sett,
sett_config.pickle.renCrv.params.want,
sett.pickle.controller,
"Badger SuperSett renCrv (Pickle)",
"bSuperRenCrv (Pickle)",
deployer,
)
sett.harvest.renCrv = deploy_sett(
badger,
sett,
sett_config.harvest.renCrv.params.want,
sett.harvest.controller,
"Badger SuperSett renCrv (Harvest)",
"bSuperRenCrv (Harvest)",
deployer,
)
# Deploy Strategy Staking Rewards
sett.rewards = DotMap()
sett.rewards.badger = deploy_proxy(
"StakingRewards",
StakingRewards.abi,
sett.logic.StakingRewards.address,
badger.devProxyAdmin.address,
sett.logic.StakingRewards.initialize.encode_input(
deployer, badger.token, badger.token
),
deployer,
)
# Deploy Strategies
params = sett_config.native.badger.params
params.want = badger.token
params.geyser = sett.rewards.badger
sett.native.strategies.badger = deploy_strategy(
badger, sett, "StrategyBadgerRewards", sett.native.controller, params, deployer,
)
sett.native.strategies.sbtcCrv = deploy_strategy(
badger,
sett,
"StrategyCurveGauge",
sett.native.controller,
sett_config.native.sbtcCrv.params,
deployer,
)
sett.native.strategies.renCrv = deploy_strategy(
badger,
sett,
"StrategyCurveGauge",
sett.native.controller,
sett_config.native.renCrv.params,
deployer,
)
sett.native.strategies.tbtcCrv = deploy_strategy(
badger,
sett,
"StrategyCurveGauge",
sett.native.controller,
sett_config.native.tbtcCrv.params,
deployer,
)
params = sett_config.pickle.renCrv.params
sett.pickle.strategies.renCrv = deploy_strategy(
badger,
sett,
"StrategyPickleMetaFarm",
sett.pickle.controller,
sett_config.pickle.renCrv.params,
deployer,
)
params = sett_config.harvest.renCrv.params
params.rewardsEscrow = badger.rewardsEscrow
sett.harvest.strategies.renCrv = deploy_strategy(
badger,
sett,
"StrategyHarvestMetaFarm",
sett.harvest.controller,
sett_config.harvest.renCrv.params,
deployer,
)
# Set Vaults on Controller
sett.native.controller.setVault(
badger.token, sett.native.badger, {"from": deployer}
)
sett.native.controller.setVault(
sett_config.native.sbtcCrv.params.want, sett.native.sbtcCrv, {"from": deployer}
)
sett.native.controller.setVault(
sett_config.native.renCrv.params.want, sett.native.renCrv, {"from": deployer}
)
sett.native.controller.setVault(
sett_config.native.tbtcCrv.params.want, sett.native.tbtcCrv, {"from": deployer}
)
sett.pickle.controller.setVault(
sett_config.pickle.renCrv.params.want, sett.pickle.renCrv, {"from": deployer}
)
sett.harvest.controller.setVault(
sett_config.harvest.renCrv.params.want, sett.harvest.renCrv, {"from": deployer}
)
# Approve Strategies by Controller
sett.native.controller.approveStrategy(
badger.token, sett.native.strategies.badger, {"from": deployer}
)
sett.native.controller.approveStrategy(
sett_config.native.sbtcCrv.params.want,
sett.native.strategies.sbtcCrv,
{"from": deployer},
)
sett.native.controller.approveStrategy(
sett_config.native.renCrv.params.want,
sett.native.strategies.renCrv,
{"from": deployer},
)
sett.native.controller.approveStrategy(
sett_config.native.tbtcCrv.params.want,
sett.native.strategies.tbtcCrv,
{"from": deployer},
)
sett.pickle.controller.approveStrategy(
sett_config.pickle.renCrv.params.want,
sett.pickle.strategies.renCrv,
{"from": deployer},
)
sett.harvest.controller.approveStrategy(
sett_config.harvest.renCrv.params.want,
sett.harvest.strategies.renCrv,
{"from": deployer},
)
# Set strategies on Controller
sett.native.controller.setStrategy(
badger.token, sett.native.strategies.badger, {"from": deployer}
)
sett.native.controller.setStrategy(
sett_config.native.sbtcCrv.params.want,
sett.native.strategies.sbtcCrv,
{"from": deployer},
)
sett.native.controller.setStrategy(
sett_config.native.renCrv.params.want,
sett.native.strategies.renCrv,
{"from": deployer},
)
sett.native.controller.setStrategy(
sett_config.native.tbtcCrv.params.want,
sett.native.strategies.tbtcCrv,
{"from": deployer},
)
sett.pickle.controller.setStrategy(
sett_config.pickle.renCrv.params.want,
sett.pickle.strategies.renCrv,
{"from": deployer},
)
sett.harvest.controller.setStrategy(
sett_config.harvest.renCrv.params.want,
sett.harvest.strategies.renCrv,
{"from": deployer},
)
# Approve Setts on specific
sett.rewards.badger.grantRole(
APPROVED_STAKER_ROLE, sett.native.strategies.badger, {"from": deployer}
)
return sett
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
