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
