def main():
badger = connect_badger()
deployer = badger.deployer
governance = badger.devMultisig
strategist = badger.deployer
keeper = badger.keeper
guardian = badger.guardian
dfdMulti = accounts.at("0x5b5cF8620292249669e1DCC73B753d01543D6Ac7", force=True)
sharedMulti = accounts.at("0xCF7346A5E41b0821b80D5B3fdc385EEB6Dc59F44", force=True)
logic = Disperse.at("0x3b823864cd0cbad8a1f2b65d4807906775becaa7")
distribute_from_whales(deployer, assets=["wbtc"])
wbtc = interface.IERC20(registry.tokens.wbtc)
wbtc.transfer(logic, wbtc.balanceOf(deployer) // 2, {"from": deployer})
print(logic.payees())
print(
logic.isPayee(dfdMulti),
logic.isPayee(badger.devMultisig),
logic.isPayee(deployer),
)
# logic.initialize([badger.devMultisig, dfdMulti], [5000, 5000], {'from': deployer})
snap = BalanceSnapshotter([wbtc], [logic, badger.devMultisig, dfdMulti])
snap.snap()
# logic.disperseToken(wbtc, {"from": deployer})
logic.disperseToken(wbtc, {"from": dfdMulti})
snap.snap()
snap.diff_last_two()
def test_main():
"""
What contracts are required?
Sett (Proxy)
GuestList (Proxy)
Strategy (Logic + Proxy)
What addresses do I need?
Fee splitter
Mushroom fee address
All that good stuff
"""
badger = connect_badger()
digg = badger.digg
dev = badger.deployer
distribute_from_whales(dev, assets=["digg"])
digg.token.transfer(badger.devMultisig, digg.token.balanceOf(dev), {"from": dev})
multi = GnosisSafe(badger.devMultisig)
safe = ApeSafe(badger.devMultisig.address)
ops = ApeSafe(badger.opsMultisig.address)
helper = ApeSafeHelper(badger, safe)
controller = safe.contract("0x9b4efA18c0c6b4822225b81D150f3518160f8609")
controller.setVault()
"""
address _token,
address _controller,
address _governance,
address _keeper,
address _guardian,
bool _overrideTokenName,
string memory _namePrefix,
string memory _symbolPrefix
"""
for i in range(0, len(assets)):
asset = interface.IERC20(assets[i])
vault = interface.ISett(vaults[i])
vault.initialize(
asset,
controller,
badger.devMultisig,
badger.keeper,
badger.guardian,
False,
"",
"",
)
controller.setVault(asset, vault)
def deploy(self, new_badger=True):
if (new_badger):
self.badger = deploy_badger_minimal(self.deployer, self.keeper, self.guardian)
self.controller = self.badger.add_controller(self.key)
else:
self.badger=""
self.deploy_required_logic()
self.pre_deploy_setup()
(params, want) = self.fetch_params()
self.params = params
self.want = want
distribute_test_ether(self.deployer, Wei("20 ether"))
distribute_from_whales(self.badger, self.deployer)
self.controller = self.badger.add_controller(self.key)
self.vault = self.badger.deploy_sett(
self.key,
self.want,
self.controller,
governance=self.governance,
strategist=self.strategist,
keeper=self.keeper,
guardian=self.guardian,
)
self.post_vault_deploy_setup()
self.strategy = self.badger.deploy_strategy(
self.key,
self.strategyName,
self.controller,
self.params,
governance=self.governance,
strategist=self.strategist,
keeper=self.keeper,
guardian=self.guardian,
)
self.badger.wire_up_sett(self.vault, self.strategy, self.controller)
self.post_deploy_setup()
assert self.vault.paused()
self.vault.unpause({"from": self.governance})
return self.badger
def test_simulation_after_upgrade_crv_setts(settID):
# Upgrade crv strategy
badger = connect_badger(badger_config.prod_json)
"""
TODO Get the Implementation before upgrade
"""
txFilename = queue_upgrade_crv_strat(badger, settID)
# Sleep 2 days to pass timelock delay period.
chain.sleep(2 * days(2))
badger.governance_execute_transaction(txFilename)
"""
TODO assert tht implementation has changed
"""
## Object representing the sett we want and the mode we're in
thisSettConfig = {"id": settID, "mode": "test"}
## Get badger so we can get info in sett and strats
badger = badger_single_sett(thisSettConfig)
## We now have the want, we can mint some
deployer = badger.deployer
## Mints token for us
distribute_from_whales(deployer)
snap = SnapshotManager(badger, settID)
simulation = SimulationManager(badger, snap, settID)
simulation.provision()
# Randomize 30 actions.
simulation.randomize(30)
simulation.run()
assert_deposit_withdraw_single_user_flow(thisSettConfig)
assert_single_user_harvest_flow(thisSettConfig)
assert_migrate_single_user(thisSettConfig)
assert_withdraw_other(thisSettConfig)
assert_single_user_harvest_flow_remove_fees(thisSettConfig)
assert_strategy_action_permissions(thisSettConfig)
assert_strategy_config_permissions(thisSettConfig)
assert_strategy_pausing_permissions(thisSettConfig)
assert_sett_pausing_permissions(thisSettConfig)
assert_sett_config_permissions(thisSettConfig)
assert_controller_permissions(thisSettConfig)
def main():
"""
Connect to badger, distribute assets to specified test user, and keep ganache open.
Ganache will run with your default brownie settings for mainnet-fork
"""
# The address to test with
user = accounts.at(decouple.config("TEST_ACCOUNT"), force=True)
badger = connect_badger()
tree = badger.badgerTree
newLogic = BadgerTreeV2.at("0x603ad0e0e0fc873371bd1d98f06e567a8c752ac8")
ops = accounts.at(badger.opsMultisig, force=True)
badger.opsProxyAdmin.upgrade(tree, newLogic, {"from": ops})
distribute_from_whales(user)
console.print("[green]=== ✅ Test ENV Setup Complete ✅ ===[/green]")
# Keep ganache open until closed
time.sleep(days(365))
def main():
"""
Connect to badger, distribute assets to specified test user, and keep ganache open.
Ganache will run with your default brownie settings for mainnet-fork
"""
# The address to test with
user = accounts.at(decouple.config("TEST_ACCOUNT"), force=True)
badger = connect_badger(badger_config.prod_json)
console.print("[blue]=== 🦡 Test ENV for account {} 🦡 ===[/blue]".format(user))
distribute_test_ether(user, Wei("10 ether"))
distribute_from_whales(badger, user)
console.print("[green]=== ✅ Test ENV Setup Complete ✅ ===[/green]")
# Keep ganache open until closed
time.sleep(days(365))
def test_claw(settConfig):
badger = badger_single_sett(settConfig, deploy=False)
snap = SnapshotManager(badger, settConfig["id"])
deployer = badger.deployer
want = badger.getStrategyWant(settConfig["id"])
sett = badger.getSett(settConfig["id"])
depositAmount = int(want.balanceOf(deployer) * 0.8)
assert depositAmount > 0
want.approve(sett, MaxUint256, {"from": deployer})
snap.settDeposit(depositAmount, {"from": deployer})
assert want.balanceOf(deployer) > 0
distribute_test_ether(deployer, Wei("20 ether"))
distribute_from_whales(deployer)
claw = deploy_claw_minimal(deployer)
if settConfig["id"] == "native.badger":
_manage_position(claw, "bClaw", deployer)
if settConfig["id"] == "sushi.sushiWbtcEth":
_manage_position(claw, "sClaw", deployer)
def gitcoin_round_8_flow():
"""
Connect to badger, distribute assets to specified test user, and keep ganache open.
Ganache will run with your default brownie settings for mainnet-fork
"""
# The address to test with
user = accounts.at(decouple.config("TEST_ACCOUNT"), force=True)
badger = connect_badger("deploy-final.json",
load_deployer=False,
load_keeper=False,
load_guardian=False)
console.print(
"[blue]=== 🦡 Test ENV for account {} 🦡 ===[/blue]".format(user))
# ===== Transfer test assets to User =====
distribute_test_ether(user, Wei("20 ether"))
distribute_test_ether(badger.deployer, Wei("20 ether"))
distribute_from_whales(user)
gitcoin_airdrop_root = (
"0xcd18c32591078dcb6686c5b4db427b7241f5f1209e79e2e2a31e17c1382dd3e2")
bBadger = badger.getSett("native.badger")
with open("airdrop/gitcoin-round-8-airdrop.json") as f:
merkle = json.load(f)
# ===== Local Setup =====
airdropLogic = AirdropDistributor.at(
"0x5c087cbb48f869f636ff11b385884296146fb505")
# airdropProxy = deploy_proxy(
# "AirdropDistributor",
# AirdropDistributor.abi,
# airdropLogic.address,
# badger.opsProxyAdmin.address,
# airdropLogic.initialize.encode_input(
# bBadger,
# gitcoin_airdrop_root,
# badger.rewardsEscrow,
# chain.time() + days(7),
# ["0x5b908E3a23823Fd9Da157726736BACBFf472976a"],
# ),
# )
account = accounts.load("badger_proxy_deployer")
airdropProxy = AirdropDistributor.at(
"0xd17c7effa924b55951e0f6d555b3a3ea34451179")
bBadger.transfer(airdropProxy, bBadger.balanceOf(account),
{"from": account})
console.print("airdropProxy", airdropProxy)
console.print("bBadger", bBadger.balanceOf(user))
# assert airdropProxy.isClaimTester(user) == True
assert airdropProxy.isClaimTester(badger.guardian) == False
# airdropProxy.unpause({"from": badger.guardian})
other_claim = merkle["claims"][
"0x5b908E3a23823Fd9Da157726736BACBFf472976a".lower()]
user_claim = merkle["claims"][user.address.lower()]
amount = int(user_claim["amount"], 16)
before = bBadger.balanceOf(user)
with brownie.reverts("Ownable: caller is not the owner"):
airdropProxy.openAirdrop({"from": user})
tester = accounts.at("0x5b908E3a23823Fd9Da157726736BACBFf472976a",
force=True)
print(bBadger.balanceOf(tester))
airdropProxy.claim(
other_claim["index"],
tester.address,
int(other_claim["amount"], 16),
other_claim["proof"],
{"from": tester},
)
print(bBadger.balanceOf(tester))
with brownie.reverts("onlyClaimTesters"):
airdropProxy.claim(
user_claim["index"],
user.address,
amount,
other_claim["proof"],
{"from": user},
)
with brownie.reverts("Ownable: caller is not the owner"):
airdropProxy.reclaim({"from": user})
airdropProxy.openAirdrop({"from": badger.guardian})
with brownie.reverts("AirdropDistributor: Invalid proof."):
airdropProxy.claim(
user_claim["index"],
user.address,
amount,
other_claim["proof"],
{"from": user},
)
airdropProxy.claim(
user_claim["index"],
user.address,
amount,
user_claim["proof"],
{"from": user},
)
with brownie.reverts("AirdropDistributor: Drop already claimed."):
airdropProxy.claim(
user_claim["index"],
user.address,
amount,
user_claim["proof"],
{"from": user},
)
after = bBadger.balanceOf(user)
assert after == before + amount
assert False
def main():
badger = connect_badger("deploy-final.json")
test_user = accounts.at(decouple.config("TEST_ACCOUNT"), force=True)
distribute_test_ether(test_user, Wei("20 ether"))
distribute_from_whales(test_user, assets=["bBadger", "badger", "usdc"])
rest = get_active_rewards_schedule(badger)
usdc = interface.IERC20(registry.tokens.usdc)
usdc_per_badger = 40.37 * 0.75
usdc_total = 13386240
multi = GnosisSafe(badger.devMultisig)
badger_total_scaled = usdc_total / usdc_per_badger
badger_total = Wei(str(badger_total_scaled) + " ether")
bBadger = badger.getSett("native.badger")
ppfs = bBadger.getPricePerFullShare()
bBadger_total = int(badger_total / ppfs * 10**18)
badger_total = Wei(str(badger_total_scaled) + " ether")
console.print({
"TRADE": "BASED",
"usdc_per_badger": usdc_per_badger,
"usdc_total": usdc_total,
"badger_total_scaled": badger_total_scaled,
"badger_total": badger_total,
"ppfs": ppfs,
"bBadger_total": str(bBadger_total),
})
params = {
"beneficiary": "0x3159b46a7829a0dbfa856888af768fe7146e7418",
"duration": days(182),
"usdcAmount": usdc_total * 10**6,
"bBadgerAmount": bBadger_total,
# "usdcAmount": 0,
# "bBadgerAmount": 0,
}
console.print(params)
# # Oxb1 Test
beneficiary = accounts.at(params["beneficiary"], force=True)
escrow = OtcEscrow.at("0x7163fB2fA38Ea3BBc1F8525F3d8D0417C0c9d903")
# bBadger.transfer(badger.devMultisig, Wei("100000 ether"), {"from": test_user})
pre = get_token_balances(
[usdc, bBadger], [test_user, escrow, badger.devMultisig, beneficiary])
pre.print()
# assert usdc.balanceOf(params["beneficiary"]) >= params["usdcAmount"]
# multi.execute(MultisigTxMetadata(description="Transfer to 0xb1"), {
# "to": bBadger.address,
# "data": bBadger.transfer.encode_input(escrow, bBadger_total + Wei("1000 ether"))
# })
# assert usdc.allowance(beneficiary, escrow) >= params["usdcAmount"]
# usdc.approve(escrow, params["usdcAmount"], {"from": beneficiary})
# tx = escrow.swap({"from": beneficiary})
tx = multi.execute(MultisigTxMetadata(description="Swap"), {
"to": escrow.address,
"data": escrow.swap.encode_input()
},
print_output=False)
chain.mine()
print(tx.call_trace())
vesting = interface.ITokenTimelock(
tx.events["VestingDeployed"][0]["vesting"])
console.print({
"token": vesting.token(),
"beneficiary": vesting.beneficiary(),
"releaseTime": to_utc_date(vesting.releaseTime()),
})
post = get_token_balances(
[usdc, bBadger], [test_user, escrow, badger.devMultisig, beneficiary])
diff_token_balances(pre, post)
try:
vesting.release({"from": test_user})
except:
print("early vest failed!")
chain.sleep(days(182))
chain.mine()
# End
vesting.release({"from": test_user})
post = get_token_balances(
[usdc, bBadger], [test_user, escrow, badger.devMultisig, beneficiary])
diff_token_balances(pre, post)
return
escrow = OtcEscrow.deploy(
params["beneficiary"],
params["duration"],
params["usdcAmount"],
params["bBadgerAmount"],
{"from": badger.deployer},
)
beneficiary = accounts.at(params["beneficiary"], force=True)
usdc.transfer(beneficiary, params["usdcAmount"], {"from": test_user})
usdc.transfer(beneficiary, 1500000000000, {"from": test_user})
badger.token.transfer(badger.devMultisig, badger_total,
{"from": test_user})
multi.execute(
MultisigTxMetadata(description="Whitelist Multi"),
{
"to": bBadger.address,
"data": bBadger.approveContractAccess.encode_input(
badger.devMultisig),
},
)
assert badger.token.balanceOf(badger.devMultisig) > Wei("100 ether")
multi.execute(
MultisigTxMetadata(description="Approve bBadger Contract"),
{
"to": badger.token.address,
"data": badger.token.approve.encode_input(bBadger, badger_total),
},
)
multi.execute(
MultisigTxMetadata(description="Deposit"),
{
"to": bBadger.address,
"data": bBadger.deposit.encode_input(badger_total)
},
)
console.print(
"bBadger.balanceOf(badger.devMultisig)",
bBadger.balanceOf(badger.devMultisig), params["bBadgerAmount"],
params["bBadgerAmount"] - bBadger.balanceOf(badger.devMultisig))
assert bBadger.balanceOf(badger.devMultisig) >= params["bBadgerAmount"]
chain.mine()
chain.sleep(14)
chain.mine()
multi.execute(
MultisigTxMetadata(description="Transfer"),
{
"to": bBadger.address,
"data": bBadger.transfer.encode_input(escrow,
params["bBadgerAmount"]),
},
)
assert bBadger.balanceOf(escrow) == params["bBadgerAmount"]
multi.execute(
MultisigTxMetadata(description="Revoke"),
{
"to": escrow.address,
"data": escrow.revoke.encode_input()
},
)
assert bBadger.balanceOf(escrow) == 0
assert bBadger.balanceOf(badger.devMultisig) >= params["bBadgerAmount"]
print(bBadger.balanceOf(badger.devMultisig))
bBadger.transfer(escrow, params["bBadgerAmount"], {"from": test_user})
pre = get_token_balances(
[usdc, bBadger], [test_user, escrow, badger.devMultisig, beneficiary])
console.print(pre)
assert usdc.balanceOf(beneficiary) >= params["usdcAmount"]
assert bBadger.balanceOf(escrow) == params["bBadgerAmount"]
usdc.approve(escrow, params["usdcAmount"], {"from": beneficiary})
tx = escrow.swap({"from": beneficiary})
post = get_token_balances(
[usdc, bBadger], [test_user, escrow, badger.devMultisig, beneficiary])
console.print(tx.events)
post.print()
diff_token_balances(pre, post)
vesting = interface.ITokenTimelock(
tx.events["VestingDeployed"][0]["vesting"])
console.print({
"token": vesting.token(),
"beneficiary": vesting.beneficiary(),
"releaseTime": to_utc_date(vesting.releaseTime()),
})
chain.sleep(days(365))
chain.mine()
vesting.release({"from": test_user})
def post_vault_deploy_setup(self, deploy=True):
if not deploy:
return
distribute_from_whales(self.deployer, 1)
def main():
"""
Connect to badger, distribute assets to specified test user, and keep ganache open.
Ganache will run with your default brownie settings for mainnet-fork
"""
# The address to test with
user = accounts.at(decouple.config("TEST_ACCOUNT"), force=True)
badger = connect_badger("deploy-final.json",
load_deployer=True,
load_keeper=True,
load_guardian=True)
digg = connect_digg("deploy-final.json")
digg.token = digg.uFragments
badger.add_existing_digg(digg)
console.print(
"[blue]=== 🦡 Test ENV for account {} 🦡 ===[/blue]".format(user))
distribute_test_ether(user, Wei("10 ether"))
distribute_test_ether(badger.deployer, Wei("20 ether"))
distribute_from_whales(user)
wbtc = interface.IERC20(token_registry.wbtc)
assert wbtc.balanceOf(user) >= 200000000
init_prod_digg(badger, user)
accounts.at(digg.daoDiggTimelock, force=True)
digg.token.transfer(user, 20000000000, {"from": digg.daoDiggTimelock})
digg_liquidity_amount = 1000000000
wbtc_liquidity_amount = 100000000
assert digg.token.balanceOf(user) >= digg_liquidity_amount * 2
assert wbtc.balanceOf(user) >= wbtc_liquidity_amount * 2
uni = UniswapSystem()
wbtc.approve(uni.router, wbtc_liquidity_amount, {"from": user})
digg.token.approve(uni.router, digg_liquidity_amount, {"from": user})
uni.router.addLiquidity(
digg.token,
wbtc,
digg_liquidity_amount,
wbtc_liquidity_amount,
digg_liquidity_amount,
wbtc_liquidity_amount,
user,
chain.time() + 1000,
{"from": user},
)
sushi = SushiswapSystem()
wbtc.approve(sushi.router, wbtc_liquidity_amount, {"from": user})
digg.token.approve(sushi.router, digg_liquidity_amount, {"from": user})
sushi.router.addLiquidity(
digg.token,
wbtc,
digg_liquidity_amount,
wbtc_liquidity_amount,
digg_liquidity_amount,
wbtc_liquidity_amount,
user,
chain.time() + 1000,
{"from": user},
)
console.print("[green]=== ✅ Test ENV Setup Complete ✅ ===[/green]")
# Keep ganache open until closed
time.sleep(days(365))
def test_main():
badger = connect_badger("deploy-final.json")
digg = connect_digg("deploy-final.json")
distribute_from_whales(badger.keeper)
manager = setup()
deployer = badger.deployer
keeper = badger.keeper
badger.token.transfer(manager, Wei("1000 ether"), {"from": badger.keeper})
digg.token.transfer(manager, Wei("100 gwei"), {"from": badger.keeper})
before = badger.token.balanceOf(badger.devMultisig)
wbtc = interface.IERC20(registry.tokens.wbtc)
badger_swap_amount = Wei("100 ether")
digg_swap_amount = Wei("10 gwei")
badger_transfer_amount = Wei("10 ether")
digg_transfer_amount = Wei("1 gwei")
# with brownie.reverts("Initializable: contract is already initialized"):
# manager.initialize(
# badger.deployer,
# badger.keeper,
# badger.keeper,
# badger.guardian,
# badger.devMultisig,
# {"from": badger.keeper},
# ),
testStrat = badger.getStrategy("native.badger")
# # Can add strategy
# manager.approveStrategy(testStrat, {"from": deployer})
# assert manager.isApprovedStrategy(testStrat) == True
# # Can revoke strategy
# manager.revokeStrategy(testStrat, {"from": deployer})
# assert manager.isApprovedStrategy(testStrat) == False
# Get tokens
before = wbtc.balanceOf(manager)
manager.swapExactTokensForTokensUniswap(
badger.token,
badger_swap_amount,
[badger.token, registry.tokens.wbtc],
{"from": keeper},
)
after = wbtc.balanceOf(manager)
console.print("token swap uni", {"before": before, "after": after})
assert after > before
manager.swapExactTokensForTokensSushiswap(
badger.token,
badger_swap_amount,
[badger.token, registry.tokens.wbtc],
{"from": keeper},
)
after2 = wbtc.balanceOf(manager)
console.print("token swap sushi", {
"before": before,
"after": after,
"after2": after2
})
assert after2 > after
for key in strat_keys:
console.print("[blue]=== Running for {} ===[/blue]".format(key))
strat = badger.getStrategy(key)
# manager.approveStrategy(strat, {"from": deployer})
# ===== Convert And Transfer Assets
want = interface.IERC20(strat.want())
# Native Staking
if key == "native.badger":
before = snap_strategy_balance(strat, manager)
manager.transferWant(strat.want(), strat, badger_transfer_amount,
{"from": keeper})
after = snap_strategy_balance(strat, manager)
diff = diff_numbers_by_key(before, after)
console.log("transfer only", key, before, after, diff)
if key == "native.digg":
before = snap_strategy_balance(strat, manager)
manager.transferWant(strat.want(), strat, digg_transfer_amount,
{"from": keeper})
after = snap_strategy_balance(strat, manager)
diff = diff_numbers_by_key(before, after)
console.log("transfer only", key, before, after, diff)
startToken = ""
amount = 0
if "Badger" in key:
startToken = badger.token
amount = badger_swap_amount
elif "Digg" in key:
startToken = digg.token
amount = digg_swap_amount
# LP Setts
if "uni" in key:
before = snap_strategy_balance(strat, manager)
console.print("PreSwap", {
"key": key,
"startToken": startToken,
"amount": amount
})
manager.swapExactTokensForTokensUniswap(startToken, amount,
[startToken, wbtc],
{"from": keeper})
manager.addLiquidityUniswap(startToken, wbtc, {"from": keeper})
after_swap = snap_strategy_balance(strat, manager)
diff_swap = diff_numbers_by_key(before, after_swap)
console.log("post swap", key, before, after_swap, diff_swap)
manager.transferWant(strat.want(), strat, want.balanceOf(manager),
{"from": keeper})
after_transfer = snap_strategy_balance(strat, manager)
diff_transfer = diff_numbers_by_key(after_swap, after_transfer)
console.log("post transfer", key, after_swap, after_transfer,
diff_transfer)
if "sushi" in key:
before = snap_strategy_balance(strat, manager)
manager.swapExactTokensForTokensSushiswap(startToken, amount,
[startToken, wbtc],
{"from": keeper})
manager.addLiquiditySushiswap(startToken, wbtc, {"from": keeper})
after_swap = snap_strategy_balance(strat, manager)
diff_swap = diff_numbers_by_key(before, after_swap)
console.log("post swap", key, before, after_swap, diff_swap)
manager.transferWant(strat.want(), strat, want.balanceOf(manager),
{"from": keeper})
after_transfer = snap_strategy_balance(strat, manager)
diff_transfer = diff_numbers_by_key(after_swap, after_transfer)
console.log("post transfer", key, after_swap, after_transfer,
diff_transfer)
tx = manager.deposit(strat, {"from": keeper})
print("deposit events", tx.events)
if strat.isTendable():
tx = manager.tend(strat, {"from": keeper})
print("tend events", tx.events)
if key != "native.uniBadgerWbtc":
tx = manager.harvest(strat, {"from": keeper})
print("harvest events", tx.events)
def main():
"""
What contracts are required?
Sett (Proxy)
GuestList (Proxy)
Strategy (Logic + Proxy)
What addresses do I need?
Fee splitter
Mushroom fee address
All that good stuff
"""
badger = connect_badger()
digg = badger.digg
dev = badger.deployer
distribute_from_whales(dev, assets=["digg"])
digg.token.transfer(badger.devMultisig, digg.token.balanceOf(dev),
{"from": dev})
badger.keeper = "0x872213E29C85d7e30F1C8202FC47eD1Ec124BB1D"
badger.guardian = "0x29F7F8896Fb913CF7f9949C623F896a154727919"
# Connect Governance
# multi = GnosisSafe(badger.devMultisig)
# safe = ApeSafe(badger.devMultisig.address)
# ops = ApeSafe(badger.opsMultisig.address)
# helper = ApeSafeHelper(badger, safe)
# Initialize Contracts
want = interface.IERC20(registry.tokens.renbtc)
vault.initialize(
want,
controller,
badger.deployer,
badger.keeper,
badger.guardian,
False,
"",
"",
{"from": badger.deployer},
)
strat.initialize(
badger.opsMultisig,
badger.opsMultisig,
controller,
badger.keeper,
badger.guardian,
[want],
[1000, 1000, 50, 0],
{"from": badger.deployer},
)
controller = safe.contract("0x9b4efA18c0c6b4822225b81D150f3518160f8609")
guestList = VipCappedGuestListBbtcUpgradeable.at(vault.guestList())
vault.unpause({"from": badger.deployer})
guestList.initialize(vault, {"from": badger.deployer})
# guestList.setUserDepositCap(1 * 10 ** want.deicmals(), {"from": badger.deployer})
# guestList.setTotalDepositCap(10 * 10 ** want.deicmals(), {"from": badger.deployer})
vault.setGuestList(guestList, {"from": badger.deployer})
vault.setGovernance(badger.opsMultisig, {"from": badger.deployer})
guestList.transferOwnership(badger.opsMultisig, {"from": badger.deployer})
# Connect Contracts [Safe owned]
# controller.setVault(want, vault)
# controller.approveStrategy(want, vault)
# guestList = VipCappedGuestListBbtcUpgradeable.at(vault.guestList())
# strategy = StabilizeStrategyDiggV1.at("0xA6af1B913E205B8E9B95D3B30768c0989e942316")
# strategy = StabilizeStrategyDiggV1.deploy({"from": dev})
# strategy.initialize(
# badger.devMultisig,
# dev,
# controller,
# badger.keeper,
# badger.guardian,
# 0,
# [stabilizeVault, diggTreasury],
# [250, 0, 50, 250],
# {"from": dev},
# )
# diggTreasury.initialize(strategy, {"from": dev})
"""
def setup(StrategyConvexStakingOptimizer, ):
# Assign accounts
with open(digg_config.prod_json) as f:
badger_deploy = json.load(f)
deployer = accounts.at(badger_deploy["deployer"], force=True)
guardian = accounts.at(badger_deploy["guardian"], force=True)
keeper = accounts.at(badger_deploy["keeper"], force=True)
governance = accounts.at(badger_deploy["timelock"], force=True)
strategist = accounts[3]
user1 = accounts[4]
user2 = accounts[5]
user3 = accounts[6]
namedAccounts = {
"deployer": deployer,
"guardian": guardian,
"keeper": keeper,
"governance": governance,
"strategist": strategist,
"user1": user1,
"user2": user2,
"user3": user3,
}
# Setup Badger system
badger = connect_badger(badger_config.prod_json)
distribute_test_ether(deployer, Wei("20 ether"))
# Key of Sett to migrate (ONLY UNCOMMENT THE ONE TO TEST):
settKey = "native.renCrv"
# settKey = "native.sbtcCrv"
# settKey = "native.tbtcCrv"
# Connect to prod controller and vault
vault = badger.sett_system.vaults[settKey]
print("Vault for " + settKey + " fetched with address " + vault.address)
controller = interface.IController(vault.controller())
print("Controller for " + settKey + " fetched with address " +
controller.address)
# Deploy and initialize the strategy
if settKey == "native.renCrv":
params = sett_config.native.convexRenCrv.params
want = sett_config.native.convexRenCrv.params.want
# Transfer assets to users
distribute_from_whales(user1, 1, "renCrv")
if settKey == "native.sbtcCrv":
params = sett_config.native.convexSbtcCrv.params
want = sett_config.native.convexSbtcCrv.params.want
# Transfer assets to users
distribute_from_whales(user1, 1, "sbtcCrv")
if settKey == "native.tbtcCrv":
params = sett_config.native.convexTbtcCrv.params
want = sett_config.native.convexTbtcCrv.params.want
# Transfer assets to users
distribute_from_whales(user1, 1, "tbtcCrv")
contract = StrategyConvexStakingOptimizer.deploy({"from": deployer})
strategy = deploy_proxy(
"StrategyConvexStakingOptimizer",
StrategyConvexStakingOptimizer.abi,
contract.address,
web3.toChecksumAddress(badger.devProxyAdmin.address),
contract.initialize.encode_input(
governance.address,
strategist.address,
controller.address,
keeper.address,
guardian.address,
[
params.want,
badger.badgerTree.address,
params.cvxHelperVault,
params.cvxCrvHelperVault,
],
params.pid,
[
params.performanceFeeGovernance,
params.performanceFeeStrategist,
params.withdrawalFee,
],
(
params.curvePool.swap,
params.curvePool.wbtcPosition,
params.curvePool.numElements,
),
),
deployer,
)
# Finish setup
yield namedtuple("setup",
"badger controller vault strategy namedAccounts")(
badger, controller, vault, strategy, namedAccounts)
def deploy(self, sett_type=SettType.DEFAULT, deploy=True) -> BadgerSystem:
if not deploy:
self.badger = connect_badger(badger_config.prod_json)
self.pre_deploy_setup(deploy=deploy)
distribute_test_ether(self.deployer, Wei("20 ether"))
distribute_from_whales(self.deployer)
self.controller = self.badger.sett_system.controllers[self.key]
self.vault = self.badger.sett_system.vaults[self.key]
self.post_vault_deploy_setup(deploy=deploy)
self.strategy = self.badger.sett_system.strategies[self.key]
self.post_deploy_setup(deploy=deploy)
if self.vault.paused():
self.vault.unpause({"from": self.governance})
return self.badger
self.badger = deploy_badger_minimal(self.deployer, self.keeper,
self.guardian)
self.controller = self.badger.add_controller(self.key)
self.deploy_required_logic()
self.pre_deploy_setup(deploy=deploy)
(params, want) = self.fetch_params()
self.params = params
self.want = want
distribute_test_ether(self.deployer, Wei("20 ether"))
distribute_from_whales(self.deployer)
self.controller = self.badger.add_controller(self.key)
self.vault = self.badger.deploy_sett(
self.key,
self.want,
self.controller,
governance=self.governance,
strategist=self.strategist,
keeper=self.keeper,
guardian=self.guardian,
sett_type=sett_type,
)
self.post_vault_deploy_setup(deploy=deploy)
print("Deploying Strategy with key: ", self.key)
self.strategy = self.badger.deploy_strategy(
self.key,
self.strategyName,
self.controller,
self.params,
governance=self.governance,
strategist=self.strategist,
keeper=self.keeper,
guardian=self.guardian,
)
self.badger.wire_up_sett(self.vault, self.strategy, self.controller)
self.post_deploy_setup(deploy=deploy)
assert self.vault.paused()
self.vault.unpause({"from": self.governance})
return self.badger
def test_main():
badger = connect_badger()
digg = badger.digg
dev = badger.deployer
distribute_from_whales(dev, assets=["digg"])
digg.token.transfer(badger.devMultisig, digg.token.balanceOf(dev),
{"from": dev})
multi = GnosisSafe(badger.devMultisig)
safe = ApeSafe(badger.devMultisig.address)
ops = ApeSafe(badger.opsMultisig.address)
vault = safe.contract_from_abi(
badger.getSett("experimental.digg").address,
"StabilizeDiggSett",
StabilizeDiggSett.abi,
)
controller = ops.contract("0x9b4efA18c0c6b4822225b81D150f3518160f8609")
logic = StabilizeDiggSett.deploy({"from": dev})
guestList = VipCappedGuestListBbtcUpgradeable.deploy({"from": dev})
guestList.initialize(vault)
guestList.setGuestRoot(
"0x71ef21975aea159ba123526bd3b7e28487fb70e424f3450274293eeeaefcab6f",
{"from": dev},
)
guestList.setTotalDepositCap(MaxUint256, {"from": dev})
guestList.setUserDepositCap(MaxUint256, {"from": dev})
badger.testProxyAdmin.upgrade(vault, logic, {"from": dev})
stabilizeVault = "0xE05D2A6b97dce9B8e59ad074c2E4b6D51a24aAe3"
diggTreasury = DiggTreasury.deploy({"from": dev})
strategy = StabilizeStrategyDiggV1.deploy({"from": dev})
strategy.initialize(
badger.devMultisig,
dev,
controller,
badger.keeper,
badger.guardian,
0,
[stabilizeVault, diggTreasury],
[250, 0, 50, 250],
{"from": dev},
)
diggTreasury.initialize(strategy, {"from": dev})
"""
address _governance,
address _strategist,
address _controller,
address _keeper,
address _guardian,
uint256 _lockedUntil,
address[2] memory _vaultConfig,
uint256[4] memory _feeConfig
"""
print("governance", controller.governance())
vault.unpause()
vault.setController(controller)
controller.approveStrategy(digg.token, strategy)
controller.setStrategy(digg.token, strategy)
print(controller.address)
print(vault.address)
print(controller.vaults(digg.token))
assert controller.vaults(digg.token) == vault
assert controller.strategies(digg.token) == strategy
assert vault.token() == strategy.want()
diggToken = safe.contract(digg.token.address)
diggToken.approve(vault, MaxUint256)
a = digg.token.balanceOf(badger.devMultisig)
assert vault.guestList() == AddressZero
vault.setGuestList(guestList)
assert vault.guestList() == guestList
assert digg.token.balanceOf(badger.devMultisig) > 1000000
assert digg.token.allowance(badger.devMultisig, vault) == MaxUint256
vault.setKeeper(badger.keeper)
assert vault.keeper() == badger.keeper
vault.deposit(a // 2)
tx = vault.earn()
# vault.earn({"from": badger.keeper})
strategy.rebalance({"from": badger.keeper})
vault.withdrawAll()
