def digg_distributor_unit():
badger = connect_badger(badger_config.prod_json)
deployer = badger.deployer
devProxyAdminAddress = badger.devProxyAdmin.address
daoProxyAdminAddress = badger.daoProxyAdmin.address
digg = deploy_digg_minimal(deployer,
devProxyAdminAddress,
daoProxyAdminAddress,
owner=deployer)
# deployer should have eth but just in case
distribute_test_ether(badger.deployer, Wei("20 ether"))
digg.deploy_airdrop_distributor(
digg_config.airdropRoot,
badger.rewardsEscrow,
digg_config.reclaimAllowedTimestamp,
)
totalSupply = digg.token.totalSupply()
# 15% airdropped
digg.token.transfer(digg.diggDistributor, totalSupply * 0.15,
{"from": deployer})
return digg
def test_main():
badger = connect_badger()
user = accounts[0]
distribute_test_ether(user, Wei("10 ether"))
distribute_from_whales(user)
settConfig = {"id": "native.pancakeBnbBtcb"}
setup_badger(badger, settConfig)
deposit_withdraw_single_user_flow(badger, settConfig, user)
single_user_harvest_flow(badger, settConfig, user)
def __init__(self, contract, testMode=True):
self.contract = connect_gnosis_safe(contract)
console.print("contract", contract)
self.firstOwner = get_first_owner(contract)
self.transactions = []
self.testMode = testMode
if testMode and rpc.is_active():
distribute_test_ether(self.firstOwner, Wei("2 ether"))
self.convert_to_test_mode()
def deploy(self, new_badger=True):
if (new_badger):
self.badger = deploy_badger_minimal(self.deployer, self.keeper, self.guardian)
self.controller = self.badger.add_controller(self.key)
else:
self.badger=""
self.deploy_required_logic()
self.pre_deploy_setup()
(params, want) = self.fetch_params()
self.params = params
self.want = want
distribute_test_ether(self.deployer, Wei("20 ether"))
distribute_from_whales(self.badger, self.deployer)
self.controller = self.badger.add_controller(self.key)
self.vault = self.badger.deploy_sett(
self.key,
self.want,
self.controller,
governance=self.governance,
strategist=self.strategist,
keeper=self.keeper,
guardian=self.guardian,
)
self.post_vault_deploy_setup()
self.strategy = self.badger.deploy_strategy(
self.key,
self.strategyName,
self.controller,
self.params,
governance=self.governance,
strategist=self.strategist,
keeper=self.keeper,
guardian=self.guardian,
)
self.badger.wire_up_sett(self.vault, self.strategy, self.controller)
self.post_deploy_setup()
assert self.vault.paused()
self.vault.unpause({"from": self.governance})
return self.badger
def test_main():
badger = connect_badger()
user = accounts[0]
distribute_test_ether(user, Wei("10 ether"))
distribute_from_whales(user)
setts_to_run = [
#"native.pancakeBnbBtcb",
"native.bDiggBtcb"
]
setup_badger(badger)
for sett_id in setts_to_run:
# deposit_withdraw_single_user_flow(badger, sett_id, user)
single_user_harvest_flow(badger, sett_id, user)
def main():
"""
Connect to badger, distribute assets to specified test user, and keep ganache open.
Ganache will run with your default brownie settings for mainnet-fork
"""
# The address to test with
user = accounts.at(decouple.config("TEST_ACCOUNT"), force=True)
badger = connect_badger(badger_config.prod_json)
console.print("[blue]=== 🦡 Test ENV for account {} 🦡 ===[/blue]".format(user))
distribute_test_ether(user, Wei("10 ether"))
distribute_from_whales(badger, user)
console.print("[green]=== ✅ Test ENV Setup Complete ✅ ===[/green]")
# Keep ganache open until closed
time.sleep(days(365))
def test_claw(settConfig):
badger = badger_single_sett(settConfig, deploy=False)
snap = SnapshotManager(badger, settConfig["id"])
deployer = badger.deployer
want = badger.getStrategyWant(settConfig["id"])
sett = badger.getSett(settConfig["id"])
depositAmount = int(want.balanceOf(deployer) * 0.8)
assert depositAmount > 0
want.approve(sett, MaxUint256, {"from": deployer})
snap.settDeposit(depositAmount, {"from": deployer})
assert want.balanceOf(deployer) > 0
distribute_test_ether(deployer, Wei("20 ether"))
distribute_from_whales(deployer)
claw = deploy_claw_minimal(deployer)
if settConfig["id"] == "native.badger":
_manage_position(claw, "bClaw", deployer)
if settConfig["id"] == "sushi.sushiWbtcEth":
_manage_position(claw, "sClaw", deployer)
def main():
"""
Connect to badger, distribute assets to specified test user, and keep ganache open.
Ganache will run with your default brownie settings for mainnet-fork
"""
# The address to test with
user = accounts.at(decouple.config("TEST_ACCOUNT"), force=True)
badger = connect_badger("deploy-final.json",
load_deployer=True,
load_keeper=True,
load_guardian=True)
digg = connect_digg("deploy-final.json")
digg.token = digg.uFragments
badger.add_existing_digg(digg)
console.print(
"[blue]=== 🦡 Test ENV for account {} 🦡 ===[/blue]".format(user))
distribute_test_ether(user, Wei("10 ether"))
distribute_test_ether(badger.deployer, Wei("20 ether"))
distribute_from_whales(user)
wbtc = interface.IERC20(token_registry.wbtc)
assert wbtc.balanceOf(user) >= 200000000
init_prod_digg(badger, user)
accounts.at(digg.daoDiggTimelock, force=True)
digg.token.transfer(user, 20000000000, {"from": digg.daoDiggTimelock})
digg_liquidity_amount = 1000000000
wbtc_liquidity_amount = 100000000
assert digg.token.balanceOf(user) >= digg_liquidity_amount * 2
assert wbtc.balanceOf(user) >= wbtc_liquidity_amount * 2
uni = UniswapSystem()
wbtc.approve(uni.router, wbtc_liquidity_amount, {"from": user})
digg.token.approve(uni.router, digg_liquidity_amount, {"from": user})
uni.router.addLiquidity(
digg.token,
wbtc,
digg_liquidity_amount,
wbtc_liquidity_amount,
digg_liquidity_amount,
wbtc_liquidity_amount,
user,
chain.time() + 1000,
{"from": user},
)
sushi = SushiswapSystem()
wbtc.approve(sushi.router, wbtc_liquidity_amount, {"from": user})
digg.token.approve(sushi.router, digg_liquidity_amount, {"from": user})
sushi.router.addLiquidity(
digg.token,
wbtc,
digg_liquidity_amount,
wbtc_liquidity_amount,
digg_liquidity_amount,
wbtc_liquidity_amount,
user,
chain.time() + 1000,
{"from": user},
)
console.print("[green]=== ✅ Test ENV Setup Complete ✅ ===[/green]")
# Keep ganache open until closed
time.sleep(days(365))
def badger_single_sett(settConfig):
deployer = accounts[0]
guardian = accounts[1]
keeper = accounts[2]
strategist = accounts[3]
governance = accounts[4]
print(settConfig)
settId = settConfig['id']
if settConfig['mode'] == 'test':
if settId == "native.badger":
return BadgerRewardsMiniDeploy(
"native.badger",
"StrategyBadgerRewards",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy()
if settId == "native.renCrv":
return CurveGaugeRenBtcMiniDeploy(
"native.renCrv",
"StrategyCurveGaugeRenBtcCrv",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy()
if settId == "native.sbtcCrv":
return CurveGaugeSBtcMiniDeploy(
"native.sbtcCrv",
"StrategyCurveGaugeSbtcCrv",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy()
if settId == "native.tbtcCrv":
return CurveGaugeTBtcMiniDeploy(
"native.tbtcCrv",
"StrategyCurveGaugeTbtcCrv",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy()
if settId == "native.uniBadgerWbtc":
return BadgerLpMetaFarmMiniDeploy(
"native.uniBadgerWbtc",
"StrategyBadgerLpMetaFarm",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy()
if settId == "harvest.renCrv":
return HarvestMetaFarmMiniDeploy(
"harvest.renCrv",
"StrategyHarvestMetaFarm",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy()
if settId == "sushi.sushiBadgerWBtc":
return SushiBadgerWBtcMiniDeploy(
"sushi.sushiBadgerWBtc",
"StrategySushiBadgerWbtc",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy()
if settId == "sushi.sushiWbtcWeth":
return SushiBadgerLpOptimizerMiniDeploy(
"sushi.sushiWbtcWeth",
"StrategySushiLpOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy()
if settConfig['mode'] == 'prod':
"""
Run vs prod contracts, transferring assets to the test user
(WIP)
"""
badger = connect_badger(badger_config.prod_json)
distribute_test_ether(badger.deployer, Wei("20 ether"))
distribute_from_whales(badger, badger.deployer)
return badger
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 main():
"""
Connect to badger system, and configure multisig for running transactions in local fork without access to accounts
"""
# Connect badger system from file
badger = connect_badger()
digg = badger.digg
# Sanity check file addresses
expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77"
assert badger.devMultisig == expectedMultisig
if rpc.is_active():
distribute_test_ether(badger.devMultisig, Wei("5 ether"))
# Multisig wrapper
# Get price data from sushiswap, uniswap, and coingecko
digg_usd_coingecko = 41531.72
btc_usd_coingecko = 32601.13
digg_per_btc = digg_usd_coingecko / btc_usd_coingecko
uniTWAP = get_average_daily_price("scripts/oracle/data/uni_digg_hour")
sushiTWAP = get_average_daily_price("scripts/oracle/data/sushi_digg_hour")
averageTWAP = Average([uniTWAP, sushiTWAP])
console.print({
"uniTWAP": uniTWAP,
"sushiTWAP": sushiTWAP,
"averageTWAP": averageTWAP
})
supplyBefore = digg.token.totalSupply()
print("spfBefore", digg.token._sharesPerFragment())
print("supplyBefore", digg.token.totalSupply())
marketValue = Wei(str(averageTWAP) + " ether")
print(marketValue)
print(int(marketValue * 10**18))
print("digg_per_btc", digg_per_btc, averageTWAP, marketValue)
if rpc.is_active():
distribute_test_ether(digg.centralizedOracle, Wei("5 ether"))
centralizedMulti = GnosisSafe(digg.centralizedOracle)
print(digg.marketMedianOracle.providerReports(digg.centralizedOracle, 0))
print(digg.marketMedianOracle.providerReports(digg.centralizedOracle, 1))
print(digg.cpiMedianOracle.providerReports(digg.constantOracle, 0))
print(digg.cpiMedianOracle.providerReports(digg.constantOracle, 1))
print(digg.cpiMedianOracle.getData.call())
sushi = SushiswapSystem()
pair = sushi.getPair(digg.token, registry.tokens.wbtc)
uni = UniswapSystem()
uniPair = uni.getPair(digg.token, registry.tokens.wbtc)
print("pair before", pair.getReserves())
print("uniPair before", uniPair.getReserves())
tx = centralizedMulti.execute(
MultisigTxMetadata(description="Set Market Data"),
{
"to": digg.marketMedianOracle.address,
"data":
digg.marketMedianOracle.pushReport.encode_input(marketValue),
},
)
chain.mine()
print(tx.call_trace())
print(tx.events)
chain.sleep(hours(0.4))
chain.mine()
in_rebase_window = digg.uFragmentsPolicy.inRebaseWindow()
while not in_rebase_window:
print("Not in rebase window...")
chain.sleep(hours(0.1))
chain.mine()
in_rebase_window = digg.uFragmentsPolicy.inRebaseWindow()
tx = digg.orchestrator.rebase({"from": accounts[0]})
chain.mine()
supplyAfter = digg.token.totalSupply()
print("spfAfter", digg.token._sharesPerFragment())
print("supplyAfter", supplyAfter)
print("supplyChange", supplyAfter / supplyBefore)
print("supplyChangeOtherWay", supplyBefore / supplyAfter)
print("pair after", pair.getReserves())
print("uniPair after", uniPair.getReserves())
def badger_single_sett(settConfig, deploy=True):
if deploy:
deployer = accounts[0]
guardian = accounts[1]
keeper = accounts[2]
governance = accounts[4]
else:
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["devMultisig"], force=True)
strategist = accounts[3]
print(settConfig)
settId = settConfig['id']
if settConfig['mode'] == 'test':
if settId == "native.badger":
return BadgerRewardsMiniDeploy(
"native.badger",
"StrategyBadgerRewards",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.renCrv":
return CurveGaugeRenBtcMiniDeploy(
"native.renCrv",
"StrategyCurveGaugeRenBtcCrv",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.sbtcCrv":
return CurveGaugeSBtcMiniDeploy(
"native.sbtcCrv",
"StrategyCurveGaugeSbtcCrv",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.tbtcCrv":
return CurveGaugeTBtcMiniDeploy(
"native.tbtcCrv",
"StrategyCurveGaugeTbtcCrv",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.uniBadgerWbtc":
return BadgerLpMetaFarmMiniDeploy(
"native.uniBadgerWbtc",
"StrategyBadgerLpMetaFarm",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "harvest.renCrv":
return HarvestMetaFarmMiniDeploy(
"harvest.renCrv",
"StrategyHarvestMetaFarm",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.sushiBadgerWbtc":
return SushiBadgerWBtcMiniDeploy(
"native.sushiBadgerWbtc",
"StrategySushiBadgerWbtc",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.sushiWbtcEth":
return SushiBadgerLpOptimizerMiniDeploy(
"native.sushiWbtcEth",
"StrategySushiLpOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.digg":
return DiggRewardsMiniDeploy(
"native.digg",
"StrategyDiggRewards",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(sett_type=SettType.DIGG, deploy=deploy)
if settId == "native.uniDiggWbtc":
return UniDiggWbtcLpMiniDeploy(
"native.uniDiggWbtc",
"StrategyDiggLpMetaFarm",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.sushiDiggWbtc":
return SushiDiggWbtcLpOptimizerMiniDeploy(
"native.sushiDiggWbtc",
"StrategySushiDiggWbtcLpOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.sushiSClawUSDC":
# Claw/USDC mini deploy can be used for any CLAW synthetic token.
return SushiClawUSDCMiniDeploy(
"native.sushiSClawUSDC",
"StrategySushiLpOptimizer", # sushi lp optimizer strat is generic
deployer,
"sClaw", # This specifies the name of the EMP contract on the CLAW system.
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.sushiBClawUSDC":
# Claw/USDC mini deploy can be used for any CLAW synthetic token.
return SushiClawUSDCMiniDeploy(
"native.sushiBClawUSDC",
"StrategySushiLpOptimizer", # sushi lp optimizer strat is generic
deployer,
"bClaw", # This specifies the name of the EMP contract on the CLAW system.
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.pancakeBnbBtcb":
return PancakeMiniDeploy.PancakeMiniDeploy(
"native.pancakeBnbBtcb",
"StrategyPancakeLpOptimzier", # pancake lp optimizer strat is generic
deployer,
# Base strategy params (perf/withdrawal fees)
sett_config.pancake.pancakeBnbBtcb,
# Lp pair tokens (bnb/btcb) for this strategy.
[
registry.tokens.btcb,
registry.tokens.bnb,
],
# Both want/pid are optional params and used for validation.
# In this case, both the lp token and pid (pool id) exist so we can pass them in.
want=registry.pancake.chefPairs.bnbBtcb,
pid=registry.pancake.chefPids.bnbBtcb
).deploy(deploy=deploy)
if settId == "native.sushiWbtcIbBtc":
return SushiWbtcIbBtcLpOptimizerMiniDeploy(
"native.sushiWbtcIbBtc",
"StrategySushiLpOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settConfig['mode'] == 'prod':
"""
Run vs prod contracts, transferring assets to the test user
(WIP)
"""
badger = connect_badger(badger_config.prod_json)
distribute_test_ether(badger.deployer, Wei("20 ether"))
distribute_from_whales(badger.deployer)
return badger
def deploy(self, sett_type=SettType.DEFAULT, deploy=True) -> BadgerSystem:
if not deploy:
self.badger = connect_badger(badger_config.prod_json)
self.pre_deploy_setup(deploy=deploy)
distribute_test_ether(self.deployer, Wei("20 ether"))
distribute_from_whales(self.deployer)
self.controller = self.badger.sett_system.controllers[self.key]
self.vault = self.badger.sett_system.vaults[self.key]
self.post_vault_deploy_setup(deploy=deploy)
self.strategy = self.badger.sett_system.strategies[self.key]
self.post_deploy_setup(deploy=deploy)
if self.vault.paused():
self.vault.unpause({"from": self.governance})
return self.badger
self.badger = deploy_badger_minimal(self.deployer, self.keeper,
self.guardian)
self.controller = self.badger.add_controller(self.key)
self.deploy_required_logic()
self.pre_deploy_setup(deploy=deploy)
(params, want) = self.fetch_params()
self.params = params
self.want = want
distribute_test_ether(self.deployer, Wei("20 ether"))
distribute_from_whales(self.deployer)
self.controller = self.badger.add_controller(self.key)
self.vault = self.badger.deploy_sett(
self.key,
self.want,
self.controller,
governance=self.governance,
strategist=self.strategist,
keeper=self.keeper,
guardian=self.guardian,
sett_type=sett_type,
)
self.post_vault_deploy_setup(deploy=deploy)
print("Deploying Strategy with key: ", self.key)
self.strategy = self.badger.deploy_strategy(
self.key,
self.strategyName,
self.controller,
self.params,
governance=self.governance,
strategist=self.strategist,
keeper=self.keeper,
guardian=self.guardian,
)
self.badger.wire_up_sett(self.vault, self.strategy, self.controller)
self.post_deploy_setup(deploy=deploy)
assert self.vault.paused()
self.vault.unpause({"from": self.governance})
return self.badger
def badger_single_sett(settConfig, deploy=True):
if deploy:
deployer = accounts[0]
guardian = accounts[1]
keeper = accounts[2]
governance = accounts[4]
else:
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["devMultisig"], force=True)
strategist = accounts[3]
settId = settConfig["id"]
print("settId:", settId)
if settConfig["mode"] == "test":
if settId == "native.badger":
return BadgerRewardsMiniDeploy(
"native.badger",
"StrategyBadgerRewards",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.uniBadgerWbtc":
return BadgerLpMetaFarmMiniDeploy(
"native.uniBadgerWbtc",
"StrategyBadgerLpMetaFarm",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "harvest.renCrv":
return HarvestMetaFarmMiniDeploy(
"harvest.renCrv",
"StrategyHarvestMetaFarm",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.unitRenBtc":
return UnitProtocolRenBtcMiniDeploy(
"native.unitRenBtc",
"StrategyUnitProtocolRenbtc",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.sushiBadgerWbtc":
return SushiBadgerWBtcMiniDeploy(
"native.sushiBadgerWbtc",
"StrategySushiBadgerWbtc",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.sushiWbtcEth":
return SushiBadgerLpOptimizerMiniDeploy(
"native.sushiWbtcEth",
"StrategySushiLpOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.digg":
return DiggRewardsMiniDeploy(
"native.digg",
"StrategyDiggRewards",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(sett_type=SettType.DIGG, deploy=deploy)
if settId == "native.uniDiggWbtc":
return UniDiggWbtcLpMiniDeploy(
"native.uniDiggWbtc",
"StrategyDiggLpMetaFarm",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.sushiDiggWbtc":
return SushiDiggWbtcLpOptimizerMiniDeploy(
"native.sushiDiggWbtc",
"StrategySushiDiggWbtcLpOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.sushiSClawUSDC":
# Claw/USDC mini deploy can be used for any CLAW synthetic token.
return SushiClawUSDCMiniDeploy(
"native.sushiSClawUSDC",
"StrategySushiLpOptimizer", # sushi lp optimizer strat is generic
deployer,
"sClaw", # This specifies the name of the EMP contract on the CLAW system.
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.sushiBClawUSDC":
# Claw/USDC mini deploy can be used for any CLAW synthetic token.
return SushiClawUSDCMiniDeploy(
"native.sushiBClawUSDC",
"StrategySushiLpOptimizer", # sushi lp optimizer strat is generic
deployer,
"bClaw", # This specifies the name of the EMP contract on the CLAW system.
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.pancakeBnbBtcb":
return PancakeMiniDeploy.PancakeMiniDeploy(
"native.pancakeBnbBtcb",
"StrategyPancakeLpOptimzier", # pancake lp optimizer strat is generic
deployer,
# Base strategy params (perf/withdrawal fees)
sett_config.pancake.pancakeBnbBtcb,
# Lp pair tokens (bnb/btcb) for this strategy.
[
registry.tokens.btcb,
registry.tokens.bnb,
],
# Both want/pid are optional params and used for validation.
# In this case, both the lp token and pid (pool id) exist so we can pass them in.
want=registry.pancake.chefPairs.bnbBtcb,
pid=registry.pancake.chefPids.bnbBtcb,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.sushiWbtcIbBtc":
return SushiWbtcIbBtcLpOptimizerMiniDeploy(
"native.sushiWbtcIbBtc",
"StrategySushiLpOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=True) # Deploy for now since not already deployed.
if settId == "native.uniWbtcIbBtc":
return UniGenericLpMiniDeploy(
"native.uniWbtcIbBtc",
"StrategyUniGenericLp",
deployer,
[registry.tokens.ibbtc, registry.tokens.wbtc],
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=True) # Deploy for now since not already deployed.
if settId == "yearn.bvyWBTC":
return YearnMiniDeploy(
"yearn.bvyWBTC",
"AffiliateTokenGatedUpgradable",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.convexRenCrv":
return ConvexRenBtcMiniDeploy(
"native.convexRenCrv",
"StrategyConvexStakingOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.renCrv":
return ConvexRenBtcMiniDeploy(
"native.renCrv",
"StrategyConvexStakingOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.sbtcCrv":
return ConvexSBtcMiniDeploy(
"native.sbtcCrv",
"StrategyConvexStakingOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.tbtcCrv":
return ConvexTBtcMiniDeploy(
"native.tbtcCrv",
"StrategyConvexStakingOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.hbtcCrv":
return ConvexHBtcMiniDeploy(
"native.hbtcCrv",
"StrategyConvexStakingOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.pbtcCrv":
return ConvexPBtcMiniDeploy(
"native.pbtcCrv",
"StrategyConvexStakingOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.obtcCrv":
return ConvexOBtcMiniDeploy(
"native.obtcCrv",
"StrategyConvexStakingOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.bbtcCrv":
return ConvexBBtcMiniDeploy(
"native.bbtcCrv",
"StrategyConvexStakingOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.tricrypto":
return ConvexTriCryptoMiniDeploy(
"native.tricrypto",
"StrategyConvexStakingOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.tricryptoDos":
return ConvexTriCryptoDosMiniDeploy(
"native.tricryptoDos",
"StrategyConvexStakingOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.cvx":
return HelperCvxMiniDeploy(
"native.cvx",
"StrategyCvxHelper",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.cvxCrv":
return HelperCvxCrvMiniDeploy(
"native.cvxCrv",
"StrategyCvxCrvHelper",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "experimental.digg":
return DiggStabilizeMiniDeploy().deploy(deploy=deploy)
if settConfig["mode"] == "prod":
"""
Run vs prod contracts, transferring assets to the test user
(WIP)
"""
badger = connect_badger(badger_config.prod_json)
distribute_test_ether(badger.deployer, Wei("20 ether"))
distribute_from_whales(badger.deployer)
return badger
def deploy(self, sett_type=SettType.DEFAULT, deploy=True) -> BadgerSystem:
if not deploy:
self.badger = connect_badger(badger_config.prod_json)
self.pre_deploy_setup(deploy=deploy)
distribute_test_ether(self.deployer, Wei("20 ether"))
self.controller = self.badger.sett_system.controllers[self.key]
self.vault = self.badger.sett_system.vaults[self.key]
self.post_vault_deploy_setup(deploy=deploy)
self.strategy = self.badger.sett_system.strategies[self.key]
self.post_deploy_setup(deploy=deploy)
# NB: Not all vaults are pauseable.
try:
if self.vault.paused():
self.vault.unpause({"from": self.governance})
except exceptions.VirtualMachineError:
pass
return self.badger
self.badger = deploy_badger_minimal(self.deployer, self.keeper, self.guardian)
# NB: We always connect to dao contracts and multisig.
self.badger.connect_dao()
self.badger.connect_multisig("0xB65cef03b9B89f99517643226d76e286ee999e77")
self.controller = self.badger.add_controller(self.key)
self.deploy_required_logic()
self.pre_deploy_setup(deploy=deploy)
(params, want) = self.fetch_params()
self.params = params
self.want = want
distribute_test_ether(self.deployer, Wei("20 ether"))
self.controller = self.badger.add_controller(self.key)
self.vault = self.badger.deploy_sett(
self.key,
self.want,
self.controller,
governance=self.governance,
strategist=self.strategist,
keeper=self.keeper,
guardian=self.guardian,
sett_type=sett_type,
)
self.post_vault_deploy_setup(deploy=deploy)
print("Deploying Strategy with key: ", self.key)
self.strategy = self.badger.deploy_strategy(
self.key,
self.strategyName,
self.controller,
self.params,
governance=self.governance,
strategist=self.strategist,
keeper=self.keeper,
guardian=self.guardian,
)
self.badger.wire_up_sett(self.vault, self.strategy, self.controller)
self.post_deploy_setup(deploy=deploy)
assert self.vault.paused()
self.vault.unpause({"from": self.governance})
return self.badger
def main():
badger = connect_badger("deploy-final.json")
test_user = accounts.at(decouple.config("TEST_ACCOUNT"), force=True)
distribute_test_ether(test_user, Wei("20 ether"))
distribute_from_whales(test_user, assets=["bBadger", "badger", "usdc"])
rest = get_active_rewards_schedule(badger)
usdc = interface.IERC20(registry.tokens.usdc)
usdc_per_badger = 40.37 * 0.75
usdc_total = 13386240
multi = GnosisSafe(badger.devMultisig)
badger_total_scaled = usdc_total / usdc_per_badger
badger_total = Wei(str(badger_total_scaled) + " ether")
bBadger = badger.getSett("native.badger")
ppfs = bBadger.getPricePerFullShare()
bBadger_total = int(badger_total / ppfs * 10**18)
badger_total = Wei(str(badger_total_scaled) + " ether")
console.print({
"TRADE": "BASED",
"usdc_per_badger": usdc_per_badger,
"usdc_total": usdc_total,
"badger_total_scaled": badger_total_scaled,
"badger_total": badger_total,
"ppfs": ppfs,
"bBadger_total": str(bBadger_total),
})
params = {
"beneficiary": "0x3159b46a7829a0dbfa856888af768fe7146e7418",
"duration": days(182),
"usdcAmount": usdc_total * 10**6,
"bBadgerAmount": bBadger_total,
# "usdcAmount": 0,
# "bBadgerAmount": 0,
}
console.print(params)
# # Oxb1 Test
beneficiary = accounts.at(params["beneficiary"], force=True)
escrow = OtcEscrow.at("0x7163fB2fA38Ea3BBc1F8525F3d8D0417C0c9d903")
# bBadger.transfer(badger.devMultisig, Wei("100000 ether"), {"from": test_user})
pre = get_token_balances(
[usdc, bBadger], [test_user, escrow, badger.devMultisig, beneficiary])
pre.print()
# assert usdc.balanceOf(params["beneficiary"]) >= params["usdcAmount"]
# multi.execute(MultisigTxMetadata(description="Transfer to 0xb1"), {
# "to": bBadger.address,
# "data": bBadger.transfer.encode_input(escrow, bBadger_total + Wei("1000 ether"))
# })
# assert usdc.allowance(beneficiary, escrow) >= params["usdcAmount"]
# usdc.approve(escrow, params["usdcAmount"], {"from": beneficiary})
# tx = escrow.swap({"from": beneficiary})
tx = multi.execute(MultisigTxMetadata(description="Swap"), {
"to": escrow.address,
"data": escrow.swap.encode_input()
},
print_output=False)
chain.mine()
print(tx.call_trace())
vesting = interface.ITokenTimelock(
tx.events["VestingDeployed"][0]["vesting"])
console.print({
"token": vesting.token(),
"beneficiary": vesting.beneficiary(),
"releaseTime": to_utc_date(vesting.releaseTime()),
})
post = get_token_balances(
[usdc, bBadger], [test_user, escrow, badger.devMultisig, beneficiary])
diff_token_balances(pre, post)
try:
vesting.release({"from": test_user})
except:
print("early vest failed!")
chain.sleep(days(182))
chain.mine()
# End
vesting.release({"from": test_user})
post = get_token_balances(
[usdc, bBadger], [test_user, escrow, badger.devMultisig, beneficiary])
diff_token_balances(pre, post)
return
escrow = OtcEscrow.deploy(
params["beneficiary"],
params["duration"],
params["usdcAmount"],
params["bBadgerAmount"],
{"from": badger.deployer},
)
beneficiary = accounts.at(params["beneficiary"], force=True)
usdc.transfer(beneficiary, params["usdcAmount"], {"from": test_user})
usdc.transfer(beneficiary, 1500000000000, {"from": test_user})
badger.token.transfer(badger.devMultisig, badger_total,
{"from": test_user})
multi.execute(
MultisigTxMetadata(description="Whitelist Multi"),
{
"to": bBadger.address,
"data": bBadger.approveContractAccess.encode_input(
badger.devMultisig),
},
)
assert badger.token.balanceOf(badger.devMultisig) > Wei("100 ether")
multi.execute(
MultisigTxMetadata(description="Approve bBadger Contract"),
{
"to": badger.token.address,
"data": badger.token.approve.encode_input(bBadger, badger_total),
},
)
multi.execute(
MultisigTxMetadata(description="Deposit"),
{
"to": bBadger.address,
"data": bBadger.deposit.encode_input(badger_total)
},
)
console.print(
"bBadger.balanceOf(badger.devMultisig)",
bBadger.balanceOf(badger.devMultisig), params["bBadgerAmount"],
params["bBadgerAmount"] - bBadger.balanceOf(badger.devMultisig))
assert bBadger.balanceOf(badger.devMultisig) >= params["bBadgerAmount"]
chain.mine()
chain.sleep(14)
chain.mine()
multi.execute(
MultisigTxMetadata(description="Transfer"),
{
"to": bBadger.address,
"data": bBadger.transfer.encode_input(escrow,
params["bBadgerAmount"]),
},
)
assert bBadger.balanceOf(escrow) == params["bBadgerAmount"]
multi.execute(
MultisigTxMetadata(description="Revoke"),
{
"to": escrow.address,
"data": escrow.revoke.encode_input()
},
)
assert bBadger.balanceOf(escrow) == 0
assert bBadger.balanceOf(badger.devMultisig) >= params["bBadgerAmount"]
print(bBadger.balanceOf(badger.devMultisig))
bBadger.transfer(escrow, params["bBadgerAmount"], {"from": test_user})
pre = get_token_balances(
[usdc, bBadger], [test_user, escrow, badger.devMultisig, beneficiary])
console.print(pre)
assert usdc.balanceOf(beneficiary) >= params["usdcAmount"]
assert bBadger.balanceOf(escrow) == params["bBadgerAmount"]
usdc.approve(escrow, params["usdcAmount"], {"from": beneficiary})
tx = escrow.swap({"from": beneficiary})
post = get_token_balances(
[usdc, bBadger], [test_user, escrow, badger.devMultisig, beneficiary])
console.print(tx.events)
post.print()
diff_token_balances(pre, post)
vesting = interface.ITokenTimelock(
tx.events["VestingDeployed"][0]["vesting"])
console.print({
"token": vesting.token(),
"beneficiary": vesting.beneficiary(),
"releaseTime": to_utc_date(vesting.releaseTime()),
})
chain.sleep(days(365))
chain.mine()
vesting.release({"from": test_user})
def gitcoin_round_8_flow():
"""
Connect to badger, distribute assets to specified test user, and keep ganache open.
Ganache will run with your default brownie settings for mainnet-fork
"""
# The address to test with
user = accounts.at(decouple.config("TEST_ACCOUNT"), force=True)
badger = connect_badger("deploy-final.json",
load_deployer=False,
load_keeper=False,
load_guardian=False)
console.print(
"[blue]=== 🦡 Test ENV for account {} 🦡 ===[/blue]".format(user))
# ===== Transfer test assets to User =====
distribute_test_ether(user, Wei("20 ether"))
distribute_test_ether(badger.deployer, Wei("20 ether"))
distribute_from_whales(user)
gitcoin_airdrop_root = (
"0xcd18c32591078dcb6686c5b4db427b7241f5f1209e79e2e2a31e17c1382dd3e2")
bBadger = badger.getSett("native.badger")
with open("airdrop/gitcoin-round-8-airdrop.json") as f:
merkle = json.load(f)
# ===== Local Setup =====
airdropLogic = AirdropDistributor.at(
"0x5c087cbb48f869f636ff11b385884296146fb505")
# airdropProxy = deploy_proxy(
# "AirdropDistributor",
# AirdropDistributor.abi,
# airdropLogic.address,
# badger.opsProxyAdmin.address,
# airdropLogic.initialize.encode_input(
# bBadger,
# gitcoin_airdrop_root,
# badger.rewardsEscrow,
# chain.time() + days(7),
# ["0x5b908E3a23823Fd9Da157726736BACBFf472976a"],
# ),
# )
account = accounts.load("badger_proxy_deployer")
airdropProxy = AirdropDistributor.at(
"0xd17c7effa924b55951e0f6d555b3a3ea34451179")
bBadger.transfer(airdropProxy, bBadger.balanceOf(account),
{"from": account})
console.print("airdropProxy", airdropProxy)
console.print("bBadger", bBadger.balanceOf(user))
# assert airdropProxy.isClaimTester(user) == True
assert airdropProxy.isClaimTester(badger.guardian) == False
# airdropProxy.unpause({"from": badger.guardian})
other_claim = merkle["claims"][
"0x5b908E3a23823Fd9Da157726736BACBFf472976a".lower()]
user_claim = merkle["claims"][user.address.lower()]
amount = int(user_claim["amount"], 16)
before = bBadger.balanceOf(user)
with brownie.reverts("Ownable: caller is not the owner"):
airdropProxy.openAirdrop({"from": user})
tester = accounts.at("0x5b908E3a23823Fd9Da157726736BACBFf472976a",
force=True)
print(bBadger.balanceOf(tester))
airdropProxy.claim(
other_claim["index"],
tester.address,
int(other_claim["amount"], 16),
other_claim["proof"],
{"from": tester},
)
print(bBadger.balanceOf(tester))
with brownie.reverts("onlyClaimTesters"):
airdropProxy.claim(
user_claim["index"],
user.address,
amount,
other_claim["proof"],
{"from": user},
)
with brownie.reverts("Ownable: caller is not the owner"):
airdropProxy.reclaim({"from": user})
airdropProxy.openAirdrop({"from": badger.guardian})
with brownie.reverts("AirdropDistributor: Invalid proof."):
airdropProxy.claim(
user_claim["index"],
user.address,
amount,
other_claim["proof"],
{"from": user},
)
airdropProxy.claim(
user_claim["index"],
user.address,
amount,
user_claim["proof"],
{"from": user},
)
with brownie.reverts("AirdropDistributor: Drop already claimed."):
airdropProxy.claim(
user_claim["index"],
user.address,
amount,
user_claim["proof"],
{"from": user},
)
after = bBadger.balanceOf(user)
assert after == before + amount
assert False
def badger_single_sett(settConfig, deploy=True):
if deploy:
deployer = accounts[0]
guardian = accounts[1]
keeper = accounts[2]
governance = accounts[4]
else:
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["devMultisig"], force=True)
strategist = accounts[3]
print(settConfig)
settId = settConfig['id']
if settConfig['mode'] == 'test':
if settId == "native.badger":
return BadgerRewardsMiniDeploy(
"native.badger",
"StrategyBadgerRewards",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.renCrv":
return CurveGaugeRenBtcMiniDeploy(
"native.renCrv",
"StrategyCurveGaugeRenBtcCrv",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.sbtcCrv":
return CurveGaugeSBtcMiniDeploy(
"native.sbtcCrv",
"StrategyCurveGaugeSbtcCrv",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.tbtcCrv":
return CurveGaugeTBtcMiniDeploy(
"native.tbtcCrv",
"StrategyCurveGaugeTbtcCrv",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.uniBadgerWbtc":
return BadgerLpMetaFarmMiniDeploy(
"native.uniBadgerWbtc",
"StrategyBadgerLpMetaFarm",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "harvest.renCrv":
return HarvestMetaFarmMiniDeploy(
"harvest.renCrv",
"StrategyHarvestMetaFarm",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "sushi.sushiBadgerWBtc":
return SushiBadgerWBtcMiniDeploy(
"sushi.sushiBadgerWBtc",
"StrategySushiBadgerWbtc",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "sushi.sushiWbtcWeth":
return SushiBadgerLpOptimizerMiniDeploy(
"sushi.sushiWbtcWeth",
"StrategySushiLpOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.digg":
return DiggRewardsMiniDeploy(
"native.digg",
"StrategyDiggRewards",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(sett_type=SettType.DIGG, deploy=deploy)
if settId == "native.uniDiggWbtc":
return UniDiggWbtcLpMiniDeploy(
"native.uniDiggWbtc",
"StrategyDiggLpMetaFarm",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settId == "native.sushiDiggWbtc":
return SushiDiggWbtcLpOptimizerMiniDeploy(
"native.sushiDiggWbtc",
"StrategySushiDiggWbtcLpOptimizer",
deployer,
strategist=strategist,
guardian=guardian,
keeper=keeper,
governance=governance,
).deploy(deploy=deploy)
if settConfig['mode'] == 'prod':
"""
Run vs prod contracts, transferring assets to the test user
(WIP)
"""
badger = connect_badger(badger_config.prod_json)
distribute_test_ether(badger.deployer, Wei("20 ether"))
distribute_from_whales(badger.deployer)
return badger
