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