def sett_harvest_meta_farm(): deployer = accounts[0] params = sett_config.harvest.renCrv.params want = sett_config.harvest.renCrv.params.want badger = deploy_badger_minimal(deployer) params.badgerTree = badger.badgerTree distribute_from_whales(badger, deployer) # badger.deploy_logic("StrategyHarvestMetaFarm", StrategyHarvestMetaFarm) # badger.deploy_logic("BadgerGeyser", BadgerGeyser) badger.deploy_core_logic() badger.deploy_sett_core_logic() badger.deploy_sett_strategy_logic() controller = badger.add_controller("harvest.renCrv") vault = badger.deploy_sett("harvest.renCrv", want, controller) strategy = badger.deploy_strategy("harvest.renCrv", "StrategyHarvestMetaFarm", controller, params) badger.wire_up_sett(vault, strategy, controller) badger.deploy_geyser(badger.getSett("harvest.renCrv"), "harvest.renCrv") return badger
def sett_curve_gauge_tbtc(): deployer = accounts[0] params = sett_config.native.tbtcCrv.params want = sett_config.native.tbtcCrv.params.want badger = deploy_badger_minimal(deployer) distribute_from_whales(badger, deployer) # badger.deploy_logic("StrategyCurveGaugeTbtcCrv", StrategyCurveGaugeTbtcCrv) badger.deploy_core_logic() badger.deploy_sett_core_logic() badger.deploy_sett_strategy_logic() controller = badger.add_controller("native.tbtcCrv") vault = badger.deploy_sett("native.tbtcCrv", want, controller) strategy = badger.deploy_strategy("native.tbtcCrv", "StrategyCurveGaugeTbtcCrv", controller, params) badger.wire_up_sett(vault, strategy, controller) badger.deploy_geyser(badger.getSett("native.tbtcCrv"), "native.tbtcCrv") return badger
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 sett_badger_lp_rewards(): deployer = accounts[0] # TODO: Deploy UNI pool and add liquidity in order to get want badger = deploy_badger_minimal(deployer) distribute_from_whales(badger, deployer) pair = create_uniswap_pair(badger.token.address, registry.tokens.wbtc, deployer) badger.pair = pair want = pair rewards = badger.deploy_sett_staking_rewards("native.uniBadgerWbtc", pair.address, badger.token) assert rewards.rewardsToken() == badger.token assert rewards.stakingToken() == pair # badger.deploy_logic("StrategyBadgerLpMetaFarm", StrategyBadgerLpMetaFarm) badger.deploy_core_logic() badger.deploy_sett_core_logic() badger.deploy_sett_strategy_logic() controller = badger.add_controller("native.uniBadgerWbtc") vault = badger.deploy_sett("native.uniBadgerWbtc", want, controller) params = sett_config.native.uniBadgerWbtc.params params.want = badger.pair params.geyser = rewards strategy = badger.deploy_strategy("native.uniBadgerWbtc", "StrategyBadgerLpMetaFarm", controller, params) badger.wire_up_sett(vault, strategy, controller) wbtc = interface.IERC20(registry.tokens.wbtc) # Grant deployer LP tokens # badger.uniswap.addMaxLiquidity(badger.token, wbtc, deployer) badger.distribute_staking_rewards( "native.uniBadgerWbtc", badger_config.geyserParams.unlockSchedules.uniBadgerWbtc[0].amount, ) rewards.grantRole(APPROVED_STAKER_ROLE, strategy, {"from": deployer}) badger.deploy_geyser(badger.getSett("native.uniBadgerWbtc"), "native.uniBadgerWbtc") return badger
def badger_tree_unit(): deployer = accounts[0] badger = deploy_badger_minimal(deployer) distribute_from_whales(badger, deployer) badger.deploy_logic("BadgerHunt", BadgerHunt) badger.deploy_badger_hunt() badger.token.transfer(badger.badgerHunt, badger_config.huntParams.badgerAmount, {"from": deployer}) return badger
def badger_hunt_unit(): deployer = accounts[0] badger = deploy_badger_minimal(deployer) distribute_from_whales(deployer) badger.deploy_logic("BadgerHunt", BadgerHunt) badger.deploy_badger_hunt() source = accounts.at("0x394DCfbCf25C5400fcC147EbD9970eD34A474543", force=True) badger.token.transfer(badger.badgerHunt, Wei("100000 ether"), {"from": source}) return 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 sett_native_badger(): deployer = accounts[0] badger = deploy_badger_minimal(deployer) distribute_from_whales(badger, deployer) # badger.deploy_logic("StrategyBadgerRewards", StrategyBadgerRewards) # badger.deploy_logic("BadgerGeyser", BadgerGeyser) badger.deploy_core_logic() badger.deploy_sett_core_logic() badger.deploy_sett_strategy_logic() controller = badger.add_controller("native.badger") vault = badger.deploy_sett("native.badger", badger.token, controller) rewards = badger.deploy_sett_staking_rewards("native.badger", badger.token, badger.token) params = sett_config.native.badger.params params.want = badger.token params.geyser = rewards strategy = badger.deploy_strategy("native.badger", "StrategyBadgerRewards", controller, params) # want = badger.getStrategyWant('native.badger') badger.wire_up_sett(vault, strategy, controller) badger.distribute_staking_rewards( "native.badger", badger_config.geyserParams.unlockSchedules.badger[0].amount) # Approve Setts on specific rewards.grantRole(APPROVED_STAKER_ROLE, strategy, {"from": deployer}) print(badger.getSett("native.badger")) badger.deploy_geyser(badger.getSett("native.badger"), "native.badger") return badger
def sett_pickle_meta_farm(): deployer = accounts[0] params = sett_config.pickle.renCrv.params want = sett_config.pickle.renCrv.params.want badger = deploy_badger_minimal(deployer) distribute_from_whales(badger, deployer) # badger.deploy_logic("StrategyPickleMetaFarm", StrategyPickleMetaFarm) # badger.deploy_logic("BadgerGeyser", BadgerGeyser) badger.deploy_core_logic() badger.deploy_sett_core_logic() badger.deploy_sett_strategy_logic() controller = badger.add_controller("pickle.renCrv") vault = badger.deploy_sett("pickle.renCrv", want, controller) strategy = badger.deploy_strategy("pickle.renCrv", "StrategyPickleMetaFarm", controller, params) badger.wire_up_sett(vault, strategy, controller) return badger
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 test_deploy(test=False, uniswap=True): # Badger Deployer deployer = "" keeper = "" guardian = "" accounts.at( web3.toChecksumAddress("0xDA25ee226E534d868f0Dd8a459536b03fEE9079b"), force=True, ) accounts.at( web3.toChecksumAddress("0x872213E29C85d7e30F1C8202FC47eD1Ec124BB1D"), force=True, ) accounts.at( web3.toChecksumAddress("0x29F7F8896Fb913CF7f9949C623F896a154727919"), force=True, ) if test: accounts.at( web3.toChecksumAddress( "0xDA25ee226E534d868f0Dd8a459536b03fEE9079b"), force=True, ) else: # Load accounts from keystore deployer = accounts.load("badger_deployer") keeper = accounts.load("badger_keeper") guardian = accounts.load("badger_guardian") # Ganache Accounts if test: accounts.at("0x90F8bf6A479f320ead074411a4B0e7944Ea8c9C1", force=True) accounts.at("0xFFcf8FDEE72ac11b5c542428B35EEF5769C409f0", force=True) accounts.at("0x22d491Bde2303f2f43325b2108D26f1eAbA1e32b", force=True) accounts.at("0xE11BA2b4D45Eaed5996Cd0823791E0C93114882d", force=True) accounts.at("0xd03ea8624C8C5987235048901fB614fDcA89b117", force=True) accounts.at("0x95cED938F7991cd0dFcb48F0a06a40FA1aF46EBC", force=True) accounts.at("0x3E5e9111Ae8eB78Fe1CC3bb8915d5D461F3Ef9A9", force=True) accounts.at("0x28a8746e75304c0780E011BEd21C72cD78cd535E", force=True) accounts.at("0xACa94ef8bD5ffEE41947b4585a84BdA5a3d3DA6E", force=True) accounts.at("0x1dF62f291b2E969fB0849d99D9Ce41e2F137006e", force=True) # Unlocked Accounts if test: accounts.at( web3.toChecksumAddress( "0x193991827e291599a262e7fa7d212ff1ae31d110"), force=True, ) accounts.at( web3.toChecksumAddress( "0x97ca371d59bbfefdb391aa6dcbdf4455fec361f2"), force=True, ) accounts.at( web3.toChecksumAddress( "0x3d24d77bec08549d7ea86c4e9937204c11e153f1"), force=True, ) accounts.at( web3.toChecksumAddress( "0xcD9e6Df80169b6a2CFfDaE613fAbC3F7C3647B14"), force=True, ) accounts.at( web3.toChecksumAddress( "0xaf379f0228ad0d46bb7b4f38f9dc9bcc1ad0360c"), force=True, ) accounts.at( web3.toChecksumAddress( "0xc25099792e9349c7dd09759744ea681c7de2cb66"), force=True, ) accounts.at( web3.toChecksumAddress( "0xb1f2cdec61db658f091671f5f199635aef202cac"), force=True, ) accounts.at( web3.toChecksumAddress( "0x2bf792ffe8803585f74e06907900c2dc2c29adcb"), force=True, ) # Test Accounts accounts.at( web3.toChecksumAddress( "0xe7bab002A39f9672a1bD0E949d3128eeBd883575"), force=True, ) accounts.at( web3.toChecksumAddress( "0x482c741b0711624d1f462E56EE5D8f776d5970dC"), force=True, ) deployer = accounts.at( web3.toChecksumAddress( ("0xDA25ee226E534d868f0Dd8a459536b03fEE9079b"))) keeper = accounts.at( web3.toChecksumAddress( ("0xDA25ee226E534d868f0Dd8a459536b03fEE9079b"))) guardian = accounts.at( web3.toChecksumAddress( ("0xDA25ee226E534d868f0Dd8a459536b03fEE9079b"))) print( "Initialize Badger System", { "deployer": deployer, "keeper": keeper, "guardian": guardian }, ) print(deployer.balance()) # ClaimEncoder.deploy({'from': deployer}) # assert False badger = BadgerSystem(badger_config, None, deployer, keeper, guardian, deploy=False) badger.test = test badger_deploy_file = "deploy-final.json" print("Connecting to deploy at " + badger_deploy_file) with open(badger_deploy_file) as f: badger_deploy = json.load(f) print("Connect Logic Contracts") badger.connect_logic(badger_deploy["logic"]) print("Create / Connect Badger<>wBTC LP Pair") # pair = create_uniswap_pair(badger.token.address, registry.tokens.wbtc, deployer) factory = interface.IUniswapV2Factory( web3.toChecksumAddress(registry.uniswap.factoryV2)) # tx = factory.createPair(badger.token.address, registry.tokens.wbtc, {"from": deployer}) pairAddress = factory.getPair(badger.token.address, registry.tokens.wbtc) pair = interface.IUniswapV2Pair(pairAddress) badger.pair = pair if uniswap: print("Test: Distribute assets to deployer") accounts.at(badger_config.dao.initialOwner, force=True) badger.token.transfer(deployer, badger_total_supply, {"from": badger_config.dao.initialOwner}) console.log( "after initial token transfer", badger.token.balanceOf(deployer) / 1e18, badger_total_supply, ) assert badger.token.balanceOf(deployer) == badger_total_supply distribute_from_whales(deployer) console.log("after whale funding", badger.token.balanceOf(deployer) / 1e18) print("Test: Add Badger<>wBTC Liquidity") wbtc = interface.IERC20(registry.tokens.wbtc) # In test mode, add liqudity to uniswap badger.uniswap.addMaxLiquidity(badger.token, wbtc, deployer) # print("Deploy core logic") # badger.deploy_core_logic() # print("Deploy Sett core logic") # badger.deploy_sett_core_logic() # badger.deploy_sett_strategy_logic() console.log("before deploys", badger.token.balanceOf(deployer) / 1e18) print("Deploy rewards & vesting infrastructure") # badger.deploy_rewards_escrow() # badger.deploy_badger_tree() # badger.deploy_dao_badger_timelock() # badger.deploy_team_vesting() # badger.deploy_badger_hunt() # print("Connect Rewards and Vesting Infrastructure") badger.connect_rewards_escrow(badger_deploy["rewardsEscrow"]) badger.connect_badger_tree(badger_deploy["badgerTree"]) badger.connect_dao_badger_timelock(badger_deploy["daoBadgerTimelock"]) badger.connect_team_vesting(badger_deploy["teamVesting"]) badger.connect_badger_hunt(badger_deploy["badgerHunt"]) console.log("after reward infra deploys", badger.token.balanceOf(deployer) / 1e18) print("Deploy Sett controllers") # badger.add_controller("native") # badger.add_controller("harvest") badger.connect_controller( "native", badger_deploy["sett_system"]["controllers"]["native"]) badger.connect_controller( "harvest", badger_deploy["sett_system"]["controllers"]["harvest"]) print("Deploy native Sett vaults") controller = badger.getController("native") # badger.deploy_sett("native.badger", badger.token, controller) # badger.deploy_sett("native.renCrv", registry.curve.pools.renCrv.token, controller) # badger.deploy_sett("native.sbtcCrv", registry.curve.pools.sbtcCrv.token, controller) # badger.deploy_sett("native.tbtcCrv", registry.curve.pools.tbtcCrv.token, controller) # badger.deploy_sett("native.uniBadgerWbtc", badger.pair.address, controller) settSystem = badger_deploy["sett_system"] badger.connect_sett("native.badger", settSystem["vaults"]["native.badger"]) badger.connect_sett("native.renCrv", settSystem["vaults"]["native.renCrv"]) badger.connect_sett( "native.sbtcCrv", badger_deploy["sett_system"]["vaults"]["native.sbtcCrv"]) badger.connect_sett( "native.tbtcCrv", badger_deploy["sett_system"]["vaults"]["native.tbtcCrv"]) badger.connect_sett( "native.uniBadgerWbtc", badger_deploy["sett_system"]["vaults"]["native.uniBadgerWbtc"], ) print("Deploy & configure native Sett strategies") print("Deploy vault-specific staking rewards") # badger.deploy_sett_staking_rewards("native.badger", badger.token, badger.token) # badger.deploy_sett_staking_rewards( # "native.uniBadgerWbtc", pair.address, badger.token # ) badger.connect_sett_staking_rewards("native.badger", settSystem["rewards"]["native.badger"]) badger.connect_sett_staking_rewards( "native.uniBadgerWbtc", settSystem["rewards"]["native.uniBadgerWbtc"]) print("Strategy: Native Badger") # badger.deploy_strategy_native_badger() badger.connect_strategy( "native.badger", settSystem["strategies"]["native.badger"], "StrategyBadgerRewards", ) print("Strategy: Native RenCrv") # badger.deploy_strategy_native_rencrv() badger.connect_strategy( "native.renCrv", settSystem["strategies"]["native.renCrv"], "StrategyCurveGaugeRenBtcCrv", ) print("Strategy: Native sBtcCrv") # badger.deploy_strategy_native_sbtccrv() badger.connect_strategy( "native.sbtcCrv", settSystem["strategies"]["native.sbtcCrv"], "StrategyCurveGaugeSbtcCrv", ) print("Strategy: Native tBtcCrv") # badger.deploy_strategy_native_tbtccrv() badger.connect_strategy( "native.tbtCcrv", settSystem["strategies"]["native.tbtcCrv"], "StrategyCurveGaugeTbtcCrv", ) print("Strategy: Native uniBadgerWbtc") # badger.deploy_strategy_native_uniBadgerWbtc() badger.connect_strategy( "native.uniBadgerWbtc", settSystem["strategies"]["native.uniBadgerWbtc"], "StrategyBadgerLpMetaFarm", ) print("Deploy harvest Sett vaults") controller = badger.getController("harvest") # badger.deploy_sett( # "harvest.renCrv", # registry.curve.pools.renCrv.token, # controller, # namePrefixOverride=True, # namePrefix="Badger SuperSett (Harvest) ", # symbolPrefix="bSuper", # ) badger.connect_sett("harvest.renCrv", settSystem["vaults"]["harvest.renCrv"]) print("Deploy & configure harvest Sett strategies") # badger.deploy_strategy_harvest_rencrv() badger.connect_strategy( "harvest.renCrv", settSystem["strategies"]["harvest.renCrv"], "StrategyHarvestMetaFarm", ) # print("Deploy reward geysers") # badger.deploy_geyser(badger.getSett("native.badger"), "native.badger") # badger.deploy_geyser(badger.getSett("native.renCrv"), "native.renCrv") # badger.deploy_geyser(badger.getSett("native.sbtcCrv"), "native.sbtcCrv") # badger.deploy_geyser(badger.getSett("native.tbtcCrv"), "native.tbtcCrv") # badger.deploy_geyser(badger.getSett("native.uniBadgerWbtc"), "native.uniBadgerWbtc") # badger.deploy_geyser(badger.getSett("harvest.renCrv"), "harvest.renCrv") print("Connect reward geysers") badger.connect_geyser("native.badger", badger_deploy["geysers"]["native.badger"]) badger.connect_geyser("native.renCrv", badger_deploy["geysers"]["native.renCrv"]) badger.connect_geyser("native.sbtcCrv", badger_deploy["geysers"]["native.sbtcCrv"]) badger.connect_geyser("native.tbtcCrv", badger_deploy["geysers"]["native.tbtcCrv"]) badger.connect_geyser("native.uniBadgerWbtc", badger_deploy["geysers"]["native.uniBadgerWbtc"]) badger.connect_geyser("harvest.renCrv", badger_deploy["geysers"]["harvest.renCrv"]) # Transfer ownership of all sett Rewards contracts to multisig # Transfer proxyAdmin to multisig console.log("after deploys", badger.token.balanceOf(deployer) / 1e18) return badger
def test_single_user_harvest_flow(settConfig): badger = badger_single_sett(settConfig) depositAmount = 50 * 1e8 # renBTC decimal is 8 # test settings controller = badger.getController(settConfig["id"]) sett = badger.getSett(settConfig["id"]) strategy = badger.getStrategy(settConfig["id"]) want = badger.getStrategyWant(settConfig["id"]) deployer = badger.deployer # production settings # controller = interface.IController("0x9b4efa18c0c6b4822225b81d150f3518160f8609"); # sett = interface.ISett("0x77f07Dd580cc957109c70c7fa81aa5704f8a3572") # strategy = StrategyUnitProtocolRenbtc.at("0x5640d6E2F72e76FBCb5296d59EA28C7375F1fE12"); # want = interface.IERC20("0xEB4C2781e4ebA804CE9a9803C67d0893436bB27D") # deployer = accounts.at("0x576cD258835C529B54722F84Bb7d4170aA932C64", force=True) # controllerGov = accounts.at("0xB65cef03b9B89f99517643226d76e286ee999e77", force=True) # ethWhale = accounts.at("0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE", force=True) # ethWhale.transfer(deployer, "100 ether") # settGuestList = interface.IVipCappedGuestList("0x9FC48e61B6a75eE263ca160aCF3288A99238719E"); # settGuestList.setGuests([deployer], [True], {"from": deployer}); # settGuestList.setUserDepositCap(depositAmount * 2, {"from": deployer}); # settGuestList.setTotalDepositCap(depositAmount * 10, {"from": deployer}); # controller.setVault(want, sett, {"from": deployer}); # controller.approveStrategy(want, strategy, {"from": controllerGov}); # controller.setStrategy(want, strategy, {"from": deployer}); settKeeper = accounts.at(sett.keeper(), force=True) strategyKeeper = accounts.at(strategy.keeper(), force=True) snap = SnapshotManager(badger, settConfig["id"]) governance = strategy.governance() tendable = strategy.isTendable() distribute_from_whales(deployer) startingBalance = want.balanceOf(deployer) assert startingBalance >= depositAmount assert startingBalance >= 0 # Deposit want.approve(sett, MaxUint256, {"from": deployer}) # sett.deposit(depositAmount, {"from": deployer}); snap.settDeposit(depositAmount, {"from": deployer}) assert want.balanceOf(sett) > 0 print("want.balanceOf(sett)", want.balanceOf(sett)) # Earn # sett.earn({"from": settKeeper}); snap.settEarn({"from": settKeeper}) # Harvest chain.sleep(hours(0.1)) chain.mine() # strategy.harvest({"from": strategyKeeper}) snap.settHarvest({"from": strategyKeeper}) # Withdraw half # sett.withdraw(depositAmount // 2, {"from": deployer}) snap.settWithdraw(depositAmount // 2, {"from": deployer}) # KeepMinRatio to maintain collateralization safe enough from liquidation currentRatio = strategy.currentRatio() safeRatio = currentRatio + 20 strategy.setMinRatio(safeRatio, {"from": governance}) strategy.keepMinRatio({"from": governance}) assert strategy.currentRatio() > safeRatio # sugar-daddy usdp discrepancy due to accrued interest in Unit Protocol debtTotal = strategy.getDebtBalance() curveGauge = interface.ICurveGauge( "0x055be5DDB7A925BfEF3417FC157f53CA77cA7222") usdp3crvInGauge = curveGauge.balanceOf(strategy) curvePool = interface.ICurveFi( "0x42d7025938bEc20B69cBae5A77421082407f053A") usdpOfPool = curvePool.calc_withdraw_one_coin(usdp3crvInGauge, 0) sugar = (debtTotal - usdpOfPool) * 2 usdpToken = interface.IERC20("0x1456688345527bE1f37E9e627DA0837D6f08C925") if sugar > 0: usdpToken.transfer(strategy, sugar, {"from": deployer}) print("sugar debt=", sugar) # Harvest again chain.sleep(hours(0.1)) chain.mine() # strategy.harvest({"from": strategyKeeper}) snap.settHarvest({"from": strategyKeeper}) # Withdraw all wantInSettBalance = sett.getPricePerFullShare() * sett.totalSupply() / 1e18 print("wantInSett=", wantInSettBalance) print("wantInStrategy=", strategy.balanceOfPool()) print("pricePerFullShare=", sett.getPricePerFullShare()) wantToWithdraw = sett.balanceOf( deployer) * sett.getPricePerFullShare() / 1e18 print("wantToWithdraw=", wantToWithdraw) assert wantToWithdraw <= wantInSettBalance sugarWithdrawAll = (strategy.getDebtBalance() - strategy.balanceOfPool()) * 2 if sugarWithdrawAll > 0: usdpToken.transfer(strategy, sugarWithdrawAll, {"from": deployer}) print("sugarWithdrawAll=", sugarWithdrawAll) renbtcToken = interface.IERC20( "0xEB4C2781e4ebA804CE9a9803C67d0893436bB27D") controller.withdrawAll(renbtcToken, {"from": deployer}) # sett.withdrawAll({"from": deployer}) snap.settWithdrawAll({"from": deployer}) assert True
def test_rewards_flow(setup): rewards_assistant = setup BadgerTreeV2 = rewards_assistant.BadgerTreeV2 guardian = rewards_assistant.guardian rootUpdater = rewards_assistant.rootUpdater admin, proposer, validator, user = accounts[:4] rewardsContract = admin.deploy(BadgerTreeV2) rewardsContract.initialize(admin, proposer, validator) console.print("[yellow]You may need to manually set the cycle in the contract for this test to work. See the comment titled 'SETTING CORRECT CYCLE'[/yellow]") ''' SETTING CORRECT CYCLE ========================= 1. Add the following function to the BadgerTreeV2 contract: /// @dev test function to get cycle to starting point function setCycle(uint256 n) public { _onlyAdmin(); currentCycle = n; } 2. Uncomment the next line to set the cycle in the test contract: ''' # rewardsContract.setCycle(1296, {'from': admin}) contentHash1 = "0xe8e31919bd92024a0437852392695f5424932b2d1b041ab45c319de7ce42fda0" contentHash2 = "0xe84f535a2581589e2c0b62040926d6599d14c436da24ab8fac5e2c86467721aa" with open("rewards/test-rewards-{}.json".format(contentHash1)) as f: rewards1 = json.load(f) with open("rewards/test-rewards-{}.json".format(contentHash2)) as f: rewards2 = json.load(f) console.print("Here are the merkle roots to use") console.print({ "root1": rewards1["merkleRoot"], "root2": rewards2["merkleRoot"] }) """ The new tree enables a couple significant features: - Claim from past cycles - Partially claim (only some tokens) - Partially claim (only some amounts) - In the future we may stake certain rewards in farms via the tree == Test Setup == Create a tree and fund with Badger, Digg, xSushi, FARM tokens via distribute_from_whales() Set to real past root (unlike the live tree, claimed will be zero for everyone) == First root to use == 0xe68a891a97fceba2afa40bfe627f1c7ee98989a727c03408314b2e6ffa56caab == Run the following tests == Run claims for users with various parameters (full claims, only claiming some tokens, only claiming partial amounts, etc) Ensure that the expected gains of tokens occur in each case Try to claim more than the appropriate amount sometimes, and ensure the failure occurs Run claims for past cycle and ensure they work as expected == Update to new root == 0xefe2c10736c6176d415009dbe85037f0b9150631cf334176783c5ae1cb3cb895 Go through proposeRoot and approveRoot to get new data uploaded. Try the same series of tests from before and make sure the amonuts recieved and amounts claimable are correct given the new cycle, especially for users who claimed during previous cycle Also make sure that users can claim from the previous cycle still with that data """ distribute_from_whales(rewardsContract, user) with open("build/contracts/ERC20.json") as f: ERC20_abi = json.load(f)['abi'] # first rewards cycle rewards_accounts = list(rewards1['claims'].keys()) start_block = rewardsContract.lastPublishStartBlock()+1 with brownie.reverts('Incorrect cycle'): rewardsContract.proposeRoot( rewards1["merkleRoot"], contentHash1, hex(rewardsContract.currentCycle()), start_block, start_block + 1, {'from': proposer} ) with brownie.reverts('Incorrect cycle'): rewardsContract.proposeRoot( rewards1["merkleRoot"], contentHash1, hex(rewardsContract.currentCycle()+2), start_block, start_block + 1, {'from': proposer} ) with brownie.reverts('Incorrect start block'): rewardsContract.proposeRoot( rewards1["merkleRoot"], contentHash1, hex(rewardsContract.currentCycle()+1), start_block - 1, start_block + 1, {'from': proposer} ) with brownie.reverts('Incorrect start block'): rewardsContract.proposeRoot( rewards1["merkleRoot"], contentHash1, hex(rewardsContract.currentCycle()+1), start_block + 1, start_block + 1, {'from': proposer} ) rewardsContract.proposeRoot( rewards1["merkleRoot"], contentHash1, hex(rewardsContract.currentCycle()+1), start_block, start_block + 1, {'from': proposer} ) rewardsContract.approveRoot( rewards1["merkleRoot"], contentHash1, rewardsContract.currentCycle()+1, start_block, start_block + 1, {'from': validator} ) # Test partial claims first_claimer = rewards_accounts[0] token_contract = Contract.from_abi("Token1", rewards1['claims'][first_claimer]['tokens'][0], ERC20_abi) prev_balance = token_contract.balanceOf(first_claimer) claim_amount = int(rewards1['claims'][first_claimer]['cumulativeAmounts'][0]) // 2 # Some claims that should fail with brownie.reverts('Excessive claim'): rewardsContract.claim( rewards1['claims'][first_claimer]['tokens'], rewards1['claims'][first_claimer]['cumulativeAmounts'], rewards1['claims'][first_claimer]['index'], rewards1['claims'][first_claimer]['cycle'], rewards1['claims'][first_claimer]['proof'], [ int(rewards1['claims'][first_claimer]['cumulativeAmounts'][0])+1, claim_amount ], {'from': first_claimer} ) with brownie.reverts('Invalid cycle'): rewardsContract.claim( rewards1['claims'][first_claimer]['tokens'], rewards1['claims'][first_claimer]['cumulativeAmounts'], rewards1['claims'][first_claimer]['index'], "0x9999", rewards1['claims'][first_claimer]['proof'], [ claim_amount, claim_amount ], {'from': first_claimer} ) with brownie.reverts('Invalid proof'): rewardsContract.claim( rewards1['claims'][first_claimer]['tokens'], rewards1['claims'][first_claimer]['cumulativeAmounts'], rewards1['claims'][rewards_accounts[1]]['index'], rewards1['claims'][first_claimer]['cycle'], rewards1['claims'][first_claimer]['proof'], [ claim_amount, claim_amount ], {'from': first_claimer} ) with brownie.reverts('Invalid proof'): rewardsContract.claim( rewards1['claims'][first_claimer]['tokens'], rewards1['claims'][first_claimer]['cumulativeAmounts'], rewards1['claims'][first_claimer]['index'], rewards1['claims'][first_claimer]['cycle'], rewards1['claims'][rewards_accounts[1]]['proof'], [ claim_amount, claim_amount ], {'from': first_claimer} ) with brownie.reverts('Invalid proof'): rewardsContract.claim( rewards1['claims'][rewards_accounts[7]]['tokens'], rewards1['claims'][first_claimer]['cumulativeAmounts'], rewards1['claims'][first_claimer]['index'], rewards1['claims'][first_claimer]['cycle'], rewards1['claims'][first_claimer]['proof'], [ claim_amount, claim_amount ], {'from': first_claimer} ) with brownie.reverts('Invalid proof'): rewardsContract.claim( rewards1['claims'][first_claimer]['tokens'], rewards1['claims'][rewards_accounts[7]]['cumulativeAmounts'], rewards1['claims'][first_claimer]['index'], rewards1['claims'][first_claimer]['cycle'], rewards1['claims'][first_claimer]['proof'], [ claim_amount, claim_amount ], {'from': first_claimer} ) with brownie.reverts('No tokens to claim'): rewardsContract.claim( rewards1['claims'][first_claimer]['tokens'], rewards1['claims'][first_claimer]['cumulativeAmounts'], rewards1['claims'][first_claimer]['index'], rewards1['claims'][first_claimer]['cycle'], rewards1['claims'][first_claimer]['proof'], [ 0, 0 ], {'from': first_claimer} ) with brownie.reverts('Excessive claim'): rewardsContract.claim( rewards1['claims'][first_claimer]['tokens'], rewards1['claims'][first_claimer]['cumulativeAmounts'], rewards1['claims'][first_claimer]['index'], rewards1['claims'][first_claimer]['cycle'], rewards1['claims'][first_claimer]['proof'], [ int(rewards1['claims'][first_claimer]['cumulativeAmounts'][0])+1, 0 ], {'from': first_claimer} ) # Make two successful partial claims rewardsContract.claim( rewards1['claims'][first_claimer]['tokens'], rewards1['claims'][first_claimer]['cumulativeAmounts'], rewards1['claims'][first_claimer]['index'], rewards1['claims'][first_claimer]['cycle'], rewards1['claims'][first_claimer]['proof'], [ claim_amount, 0 ], {'from': first_claimer} ) assert prev_balance + claim_amount == token_contract.balanceOf(first_claimer) rewardsContract.claim( rewards1['claims'][first_claimer]['tokens'], rewards1['claims'][first_claimer]['cumulativeAmounts'], rewards1['claims'][first_claimer]['index'], rewards1['claims'][first_claimer]['cycle'], rewards1['claims'][first_claimer]['proof'], [ claim_amount, 0 ], {'from': first_claimer} ) assert prev_balance + claim_amount + claim_amount == token_contract.balanceOf(first_claimer) # Second rewards cycle chain.mine(10) start_block = rewardsContract.lastPublishStartBlock()+1 rewardsContract.proposeRoot( rewards2["merkleRoot"], contentHash2, hex(rewardsContract.currentCycle()+1), start_block, start_block + 1, {'from': proposer} ) rewardsContract.approveRoot( rewards2["merkleRoot"], contentHash2, rewardsContract.currentCycle()+1, start_block, start_block + 1, {'from': validator} ) # Claim from previous cycle second_claimer = rewards_accounts[1] token_contract1 = Contract.from_abi("Token1", rewards1['claims'][second_claimer]['tokens'][0], ERC20_abi) token_contract2 = Contract.from_explorer(rewards1['claims'][second_claimer]['tokens'][1]) # Digg token contract prev_balance1 = token_contract1.balanceOf(second_claimer) prev_balance2 = token_contract2.balanceOf(second_claimer) claim_amount1 = int(rewards1['claims'][second_claimer]['cumulativeAmounts'][0]) claim_amount2 = int(rewards1['claims'][second_claimer]['cumulativeAmounts'][1]) rewardsContract.claim( rewards1['claims'][second_claimer]['tokens'], rewards1['claims'][second_claimer]['cumulativeAmounts'], rewards1['claims'][second_claimer]['index'], rewards1['claims'][second_claimer]['cycle'], rewards1['claims'][second_claimer]['proof'], [ claim_amount1, claim_amount2 ], {'from': second_claimer} ) assert prev_balance1 + claim_amount1 == token_contract1.balanceOf(second_claimer) # Calculation for Digg balance: assert Decimal(prev_balance2 + claim_amount2) // Decimal(token_contract2._sharesPerFragment()) == token_contract2.balanceOf(second_claimer) # Claim from current cycle prev_balance1 = token_contract1.balanceOf(second_claimer) prev_balance2 = token_contract2.balanceOf(second_claimer) claim_amount1 = int(rewards2['claims'][second_claimer]['cumulativeAmounts'][0]) claim_amount2 = int(rewards2['claims'][second_claimer]['cumulativeAmounts'][1]) # can't claim full cumulative amount for this current cycle since majority was claimed last cycle with brownie.reverts('Excessive claim'): rewardsContract.claim( rewards2['claims'][second_claimer]['tokens'], rewards2['claims'][second_claimer]['cumulativeAmounts'], rewards2['claims'][second_claimer]['index'], rewards2['claims'][second_claimer]['cycle'], rewards2['claims'][second_claimer]['proof'], [ claim_amount1, claim_amount2 ], {'from': second_claimer} ) # claim remaining rewards for new cycle prev_claimable = rewardsContract.getClaimableFor( second_claimer, rewards2['claims'][second_claimer]['tokens'], rewards2['claims'][second_claimer]['cumulativeAmounts'] ) rewardsContract.claim( rewards2['claims'][second_claimer]['tokens'], rewards2['claims'][second_claimer]['cumulativeAmounts'], rewards2['claims'][second_claimer]['index'], rewards2['claims'][second_claimer]['cycle'], rewards2['claims'][second_claimer]['proof'], [ prev_claimable[1][0], prev_claimable[1][1] ], {'from': second_claimer} ) claimable = rewardsContract.getClaimableFor( second_claimer, rewards2['claims'][second_claimer]['tokens'], rewards2['claims'][second_claimer]['cumulativeAmounts'] ) assert claimable[1][0] == 0 assert claimable[1][1] == 0
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 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 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