def main(): badger = connect_badger() deployer = badger.deployer governance = badger.devMultisig strategist = badger.deployer keeper = badger.keeper guardian = badger.guardian dfdMulti = accounts.at("0x5b5cF8620292249669e1DCC73B753d01543D6Ac7", force=True) sharedMulti = accounts.at("0xCF7346A5E41b0821b80D5B3fdc385EEB6Dc59F44", force=True) logic = Disperse.at("0x3b823864cd0cbad8a1f2b65d4807906775becaa7") distribute_from_whales(deployer, assets=["wbtc"]) wbtc = interface.IERC20(registry.tokens.wbtc) wbtc.transfer(logic, wbtc.balanceOf(deployer) // 2, {"from": deployer}) print(logic.payees()) print( logic.isPayee(dfdMulti), logic.isPayee(badger.devMultisig), logic.isPayee(deployer), ) # logic.initialize([badger.devMultisig, dfdMulti], [5000, 5000], {'from': deployer}) snap = BalanceSnapshotter([wbtc], [logic, badger.devMultisig, dfdMulti]) snap.snap() # logic.disperseToken(wbtc, {"from": deployer}) logic.disperseToken(wbtc, {"from": dfdMulti}) snap.snap() snap.diff_last_two()
def test_main(): """ What contracts are required? Sett (Proxy) GuestList (Proxy) Strategy (Logic + Proxy) What addresses do I need? Fee splitter Mushroom fee address All that good stuff """ badger = connect_badger() digg = badger.digg dev = badger.deployer distribute_from_whales(dev, assets=["digg"]) digg.token.transfer(badger.devMultisig, digg.token.balanceOf(dev), {"from": dev}) multi = GnosisSafe(badger.devMultisig) safe = ApeSafe(badger.devMultisig.address) ops = ApeSafe(badger.opsMultisig.address) helper = ApeSafeHelper(badger, safe) controller = safe.contract("0x9b4efA18c0c6b4822225b81D150f3518160f8609") controller.setVault() """ address _token, address _controller, address _governance, address _keeper, address _guardian, bool _overrideTokenName, string memory _namePrefix, string memory _symbolPrefix """ for i in range(0, len(assets)): asset = interface.IERC20(assets[i]) vault = interface.ISett(vaults[i]) vault.initialize( asset, controller, badger.devMultisig, badger.keeper, badger.guardian, False, "", "", ) controller.setVault(asset, vault)
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_simulation_after_upgrade_crv_setts(settID): # Upgrade crv strategy badger = connect_badger(badger_config.prod_json) """ TODO Get the Implementation before upgrade """ txFilename = queue_upgrade_crv_strat(badger, settID) # Sleep 2 days to pass timelock delay period. chain.sleep(2 * days(2)) badger.governance_execute_transaction(txFilename) """ TODO assert tht implementation has changed """ ## Object representing the sett we want and the mode we're in thisSettConfig = {"id": settID, "mode": "test"} ## Get badger so we can get info in sett and strats badger = badger_single_sett(thisSettConfig) ## We now have the want, we can mint some deployer = badger.deployer ## Mints token for us distribute_from_whales(deployer) snap = SnapshotManager(badger, settID) simulation = SimulationManager(badger, snap, settID) simulation.provision() # Randomize 30 actions. simulation.randomize(30) simulation.run() assert_deposit_withdraw_single_user_flow(thisSettConfig) assert_single_user_harvest_flow(thisSettConfig) assert_migrate_single_user(thisSettConfig) assert_withdraw_other(thisSettConfig) assert_single_user_harvest_flow_remove_fees(thisSettConfig) assert_strategy_action_permissions(thisSettConfig) assert_strategy_config_permissions(thisSettConfig) assert_strategy_pausing_permissions(thisSettConfig) assert_sett_pausing_permissions(thisSettConfig) assert_sett_config_permissions(thisSettConfig) assert_controller_permissions(thisSettConfig)
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() tree = badger.badgerTree newLogic = BadgerTreeV2.at("0x603ad0e0e0fc873371bd1d98f06e567a8c752ac8") ops = accounts.at(badger.opsMultisig, force=True) badger.opsProxyAdmin.upgrade(tree, newLogic, {"from": ops}) distribute_from_whales(user) console.print("[green]=== ✅ Test ENV Setup Complete ✅ ===[/green]") # Keep ganache open until closed time.sleep(days(365))
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 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 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 post_vault_deploy_setup(self, deploy=True): if not deploy: return distribute_from_whales(self.deployer, 1)
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 test_main(): badger = connect_badger("deploy-final.json") digg = connect_digg("deploy-final.json") distribute_from_whales(badger.keeper) manager = setup() deployer = badger.deployer keeper = badger.keeper badger.token.transfer(manager, Wei("1000 ether"), {"from": badger.keeper}) digg.token.transfer(manager, Wei("100 gwei"), {"from": badger.keeper}) before = badger.token.balanceOf(badger.devMultisig) wbtc = interface.IERC20(registry.tokens.wbtc) badger_swap_amount = Wei("100 ether") digg_swap_amount = Wei("10 gwei") badger_transfer_amount = Wei("10 ether") digg_transfer_amount = Wei("1 gwei") # with brownie.reverts("Initializable: contract is already initialized"): # manager.initialize( # badger.deployer, # badger.keeper, # badger.keeper, # badger.guardian, # badger.devMultisig, # {"from": badger.keeper}, # ), testStrat = badger.getStrategy("native.badger") # # Can add strategy # manager.approveStrategy(testStrat, {"from": deployer}) # assert manager.isApprovedStrategy(testStrat) == True # # Can revoke strategy # manager.revokeStrategy(testStrat, {"from": deployer}) # assert manager.isApprovedStrategy(testStrat) == False # Get tokens before = wbtc.balanceOf(manager) manager.swapExactTokensForTokensUniswap( badger.token, badger_swap_amount, [badger.token, registry.tokens.wbtc], {"from": keeper}, ) after = wbtc.balanceOf(manager) console.print("token swap uni", {"before": before, "after": after}) assert after > before manager.swapExactTokensForTokensSushiswap( badger.token, badger_swap_amount, [badger.token, registry.tokens.wbtc], {"from": keeper}, ) after2 = wbtc.balanceOf(manager) console.print("token swap sushi", { "before": before, "after": after, "after2": after2 }) assert after2 > after for key in strat_keys: console.print("[blue]=== Running for {} ===[/blue]".format(key)) strat = badger.getStrategy(key) # manager.approveStrategy(strat, {"from": deployer}) # ===== Convert And Transfer Assets want = interface.IERC20(strat.want()) # Native Staking if key == "native.badger": before = snap_strategy_balance(strat, manager) manager.transferWant(strat.want(), strat, badger_transfer_amount, {"from": keeper}) after = snap_strategy_balance(strat, manager) diff = diff_numbers_by_key(before, after) console.log("transfer only", key, before, after, diff) if key == "native.digg": before = snap_strategy_balance(strat, manager) manager.transferWant(strat.want(), strat, digg_transfer_amount, {"from": keeper}) after = snap_strategy_balance(strat, manager) diff = diff_numbers_by_key(before, after) console.log("transfer only", key, before, after, diff) startToken = "" amount = 0 if "Badger" in key: startToken = badger.token amount = badger_swap_amount elif "Digg" in key: startToken = digg.token amount = digg_swap_amount # LP Setts if "uni" in key: before = snap_strategy_balance(strat, manager) console.print("PreSwap", { "key": key, "startToken": startToken, "amount": amount }) manager.swapExactTokensForTokensUniswap(startToken, amount, [startToken, wbtc], {"from": keeper}) manager.addLiquidityUniswap(startToken, wbtc, {"from": keeper}) after_swap = snap_strategy_balance(strat, manager) diff_swap = diff_numbers_by_key(before, after_swap) console.log("post swap", key, before, after_swap, diff_swap) manager.transferWant(strat.want(), strat, want.balanceOf(manager), {"from": keeper}) after_transfer = snap_strategy_balance(strat, manager) diff_transfer = diff_numbers_by_key(after_swap, after_transfer) console.log("post transfer", key, after_swap, after_transfer, diff_transfer) if "sushi" in key: before = snap_strategy_balance(strat, manager) manager.swapExactTokensForTokensSushiswap(startToken, amount, [startToken, wbtc], {"from": keeper}) manager.addLiquiditySushiswap(startToken, wbtc, {"from": keeper}) after_swap = snap_strategy_balance(strat, manager) diff_swap = diff_numbers_by_key(before, after_swap) console.log("post swap", key, before, after_swap, diff_swap) manager.transferWant(strat.want(), strat, want.balanceOf(manager), {"from": keeper}) after_transfer = snap_strategy_balance(strat, manager) diff_transfer = diff_numbers_by_key(after_swap, after_transfer) console.log("post transfer", key, after_swap, after_transfer, diff_transfer) tx = manager.deposit(strat, {"from": keeper}) print("deposit events", tx.events) if strat.isTendable(): tx = manager.tend(strat, {"from": keeper}) print("tend events", tx.events) if key != "native.uniBadgerWbtc": tx = manager.harvest(strat, {"from": keeper}) print("harvest events", tx.events)
def main(): """ What contracts are required? Sett (Proxy) GuestList (Proxy) Strategy (Logic + Proxy) What addresses do I need? Fee splitter Mushroom fee address All that good stuff """ badger = connect_badger() digg = badger.digg dev = badger.deployer distribute_from_whales(dev, assets=["digg"]) digg.token.transfer(badger.devMultisig, digg.token.balanceOf(dev), {"from": dev}) badger.keeper = "0x872213E29C85d7e30F1C8202FC47eD1Ec124BB1D" badger.guardian = "0x29F7F8896Fb913CF7f9949C623F896a154727919" # Connect Governance # multi = GnosisSafe(badger.devMultisig) # safe = ApeSafe(badger.devMultisig.address) # ops = ApeSafe(badger.opsMultisig.address) # helper = ApeSafeHelper(badger, safe) # Initialize Contracts want = interface.IERC20(registry.tokens.renbtc) vault.initialize( want, controller, badger.deployer, badger.keeper, badger.guardian, False, "", "", {"from": badger.deployer}, ) strat.initialize( badger.opsMultisig, badger.opsMultisig, controller, badger.keeper, badger.guardian, [want], [1000, 1000, 50, 0], {"from": badger.deployer}, ) controller = safe.contract("0x9b4efA18c0c6b4822225b81D150f3518160f8609") guestList = VipCappedGuestListBbtcUpgradeable.at(vault.guestList()) vault.unpause({"from": badger.deployer}) guestList.initialize(vault, {"from": badger.deployer}) # guestList.setUserDepositCap(1 * 10 ** want.deicmals(), {"from": badger.deployer}) # guestList.setTotalDepositCap(10 * 10 ** want.deicmals(), {"from": badger.deployer}) vault.setGuestList(guestList, {"from": badger.deployer}) vault.setGovernance(badger.opsMultisig, {"from": badger.deployer}) guestList.transferOwnership(badger.opsMultisig, {"from": badger.deployer}) # Connect Contracts [Safe owned] # controller.setVault(want, vault) # controller.approveStrategy(want, vault) # guestList = VipCappedGuestListBbtcUpgradeable.at(vault.guestList()) # strategy = StabilizeStrategyDiggV1.at("0xA6af1B913E205B8E9B95D3B30768c0989e942316") # strategy = StabilizeStrategyDiggV1.deploy({"from": dev}) # strategy.initialize( # badger.devMultisig, # dev, # controller, # badger.keeper, # badger.guardian, # 0, # [stabilizeVault, diggTreasury], # [250, 0, 50, 250], # {"from": dev}, # ) # diggTreasury.initialize(strategy, {"from": dev}) """
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(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 test_main(): badger = connect_badger() digg = badger.digg dev = badger.deployer distribute_from_whales(dev, assets=["digg"]) digg.token.transfer(badger.devMultisig, digg.token.balanceOf(dev), {"from": dev}) multi = GnosisSafe(badger.devMultisig) safe = ApeSafe(badger.devMultisig.address) ops = ApeSafe(badger.opsMultisig.address) vault = safe.contract_from_abi( badger.getSett("experimental.digg").address, "StabilizeDiggSett", StabilizeDiggSett.abi, ) controller = ops.contract("0x9b4efA18c0c6b4822225b81D150f3518160f8609") logic = StabilizeDiggSett.deploy({"from": dev}) guestList = VipCappedGuestListBbtcUpgradeable.deploy({"from": dev}) guestList.initialize(vault) guestList.setGuestRoot( "0x71ef21975aea159ba123526bd3b7e28487fb70e424f3450274293eeeaefcab6f", {"from": dev}, ) guestList.setTotalDepositCap(MaxUint256, {"from": dev}) guestList.setUserDepositCap(MaxUint256, {"from": dev}) badger.testProxyAdmin.upgrade(vault, logic, {"from": dev}) stabilizeVault = "0xE05D2A6b97dce9B8e59ad074c2E4b6D51a24aAe3" diggTreasury = DiggTreasury.deploy({"from": dev}) strategy = StabilizeStrategyDiggV1.deploy({"from": dev}) strategy.initialize( badger.devMultisig, dev, controller, badger.keeper, badger.guardian, 0, [stabilizeVault, diggTreasury], [250, 0, 50, 250], {"from": dev}, ) diggTreasury.initialize(strategy, {"from": dev}) """ address _governance, address _strategist, address _controller, address _keeper, address _guardian, uint256 _lockedUntil, address[2] memory _vaultConfig, uint256[4] memory _feeConfig """ print("governance", controller.governance()) vault.unpause() vault.setController(controller) controller.approveStrategy(digg.token, strategy) controller.setStrategy(digg.token, strategy) print(controller.address) print(vault.address) print(controller.vaults(digg.token)) assert controller.vaults(digg.token) == vault assert controller.strategies(digg.token) == strategy assert vault.token() == strategy.want() diggToken = safe.contract(digg.token.address) diggToken.approve(vault, MaxUint256) a = digg.token.balanceOf(badger.devMultisig) assert vault.guestList() == AddressZero vault.setGuestList(guestList) assert vault.guestList() == guestList assert digg.token.balanceOf(badger.devMultisig) > 1000000 assert digg.token.allowance(badger.devMultisig, vault) == MaxUint256 vault.setKeeper(badger.keeper) assert vault.keeper() == badger.keeper vault.deposit(a // 2) tx = vault.earn() # vault.earn({"from": badger.keeper}) strategy.rebalance({"from": badger.keeper}) vault.withdrawAll()