def main():
"""
Add contracts manually to guest list. They will now be approved regardless of merkle root situation
"""
badger = connect_badger()
safe = ApeSafe(badger.testMultisig.address)
helper = ApeSafeHelper(badger, safe)
for strategy_key in strategies_to_approve:
strategy_address = badger.getStrategy(strategy_key).address
source = helper.contract_from_abi(
badger.getStrategy(strategy_key).address,
"StrategyConvexStakingOptimizer",
StrategyConvexStakingOptimizer.abi,
)
for guest_list_key in guest_lists_by_id:
guestList = helper.contract_from_abi(
badger.getGuestList(guest_list_key).address,
"VipCappedGuestListBbtcUpgradeable",
VipCappedGuestListBbtcUpgradeable.abi,
)
console.print(
f"Approve [green]{strategy_address}[/green] on Guest list [yellow]{guest_list_key} ({guestList.address})[/yellow]"
)
guestList.setGuests([strategy_address], [True])
assert guestList.guests(strategy_address) == True
helper.publish()
def approve_strategies(badger, safe, helper):
"""
Approve and set strategies on the controller
"""
for key in vaults_to_add:
console.print(f"Initializing strat {key}")
controller = safe.contract(badger.getController("experimental").address)
strategy = badger.getStrategy(key)
vault = badger.getSett(key)
want = interface.IERC20(strategy.want())
console.print(
f"Approving strategy {strategy} for want {want.name()} {want.address}"
)
controller.approveStrategy(strategy.want(), strategy)
controller.setStrategy(strategy.want(), strategy)
assert controller.approvedStrategies(strategy.want(), strategy) == True
assert controller.strategies(strategy.want()) == strategy
assert controller.vaults(strategy.want()) == vault
helper.publish()
def run_persistent(function, args, num_args=1, run_interval=10):
while True:
try:
function(args[0], args[1])
except Exception as e:
console.print("[red]Error[/red]", e)
finally:
time.sleep(run_interval)
def fetch_usd_price_eth():
url = "https://api.coingecko.com/api/v3/coins/" + "ethereum"
params = "?tickers=false&community_data=false&developer_data=false&sparkline=false"
r = requests.get(url, params)
data = r.json()
usd_price = data["market_data"]["current_price"]["usd"]
console.print(usd_price)
return usd_price
def approve_strategies_timelock(badger):
"""
Approve and set strategies on the controller
"""
all_timelock_params = {}
for key in strategies_to_initialize:
strategy = badger.getStrategy(key)
vault = badger.getSett(key)
console.print(f"Initializing strat {key} ({strategy.address})")
controller = badger.getController("native")
print(controller.governance(), controller.strategist())
assert controller.governance() == badger.governanceTimelock
assert strategy.getName() == "StrategyConvexStakingOptimizer"
assert vault.token() == strategy.want()
timelock_params = {
"target": controller.address,
"signature": "approveStrategy(address,address)",
"data": encode_abi(
["address", "address"], [strategy.want(), strategy.address]
),
"eta": chain.time() + days(3.1),
}
console.print(timelock_params)
console.print(f"TX Executable at {to_utc_date(timelock_params['eta'])}")
all_timelock_params[key] = timelock_params
console.print("timelock_params", timelock_params)
txFilename = badger.governance_queue_transaction(
timelock_params["target"],
timelock_params["signature"],
timelock_params["data"],
timelock_params["eta"],
)
chain.sleep(days(3.2))
chain.mine()
for key in strategies_to_initialize:
strategy = badger.getStrategy(key)
timelock_params = all_timelock_params[key]
badger.governance_execute_transaction_from_params(timelock_params)
chain.mine()
console.print(
f"Checking strategy approval for {strategy.want()} {strategy} {controller.approvedStrategies(strategy.want(), strategy)}"
)
assert controller.approvedStrategies(strategy.want(), strategy) == True
def fetch_usd_price(token_address):
id = address_to_id(token_address)
url = "https://api.coingecko.com/api/v3/coins/" + id
params = "?tickers=false&community_data=false&developer_data=false&sparkline=false"
r = requests.get(url, params)
data = r.json()
usd_price = data["market_data"]["current_price"]["usd"]
console.print(usd_price)
return usd_price
def upgrade_vault_proxy_admins(badger, vaults_to_add):
for settID in vaults_to_add:
sett = badger.getSett(settID)
console.print(f"Sett {settID} admin is [green]{badger.getProxyAdmin(sett)}")
badger.testProxyAdmin.changeProxyAdmin(
sett, badger.opsProxyAdmin, {"from": badger.deployer}
)
console.print(
f" Changed {settID} admin -> [blue]{badger.getProxyAdmin(sett)}"
)
def fetch_daily_twap(token_address):
id = address_to_id(token_address)
url = "https://api.coingecko.com/api/v3/coins/" + id
params = "?tickers=true&community_data=false&developer_data=false&sparkline=false"
r = requests.get(url, params)
data = r.json()
market_data = data["market_data"]
console.print(market_data)
return market_data
def set_vaults_on_controller(badger, safe, helper, vaults_to_add):
for settID in vaults_to_add:
sett = safe.contract(badger.getSett(settID).address)
token = interface.IERC20(sett.token())
console.print(f"Sett controller is [yellow]{sett.controller()}[/yellow]")
controller = safe.contract(badger.getController(controller_id).address)
console.print(
f"Vault for token [green]{token.name()}[/green] ({token.address}) on controller [yellow]{controller.address}[/yellow] set to [green] {settID} [blue]{sett.address}[/blue]"
)
controller.setVault(sett.token(), sett)
helper.publish()
def update_rm(badger, safe, helper):
rm = safe.contract(badger.badgerRewardsManager.address)
opsAdmin = safe.contract(badger.opsProxyAdmin.address)
logic = badger.getLogic("BadgerRewardsManager")
console.print(f"Updating RM at {rm.address} to logic {logic}")
opsAdmin.upgrade(rm, logic)
assert rm.getRoleMember(DEFAULT_ADMIN_ROLE, 0) == badger.devMultisig
helper.publish()
def upgrade_strategies(badger, helper, admin, new_logic, strategies):
"""
Upgrade strategies
"""
for key in strategies:
console.print(f"Upgrading strat {key} to new logic at {new_logic}")
admin = helper.contract_from_abi(
admin.address, "ProxyAdmin", artifacts.open_zeppelin["ProxyAdmin"]["abi"]
)
console.print(Controller)
strategy = helper.contract_from_abi(
badger.getStrategy(key).address,
"StrategyConvexStakingOptimizer",
StrategyConvexStakingOptimizer.abi,
)
vault = helper.contract_from_abi(badger.getSett(key).address, "Sett", Sett.abi)
controller = helper.contract_from_abi(
strategy.controller(), "Controller", Controller.abi
)
want = interface.IERC20(strategy.want())
old_logic = admin.getProxyImplementation(strategy)
old_state = {
"name": strategy.getName(),
"goverannce": strategy.governance(),
"balanceOf": strategy.balanceOf(),
"balanceOfPool": strategy.balanceOfPool(),
}
admin.upgrade(strategy, new_logic)
new_state = {
"name": strategy.getName(),
"goverannce": strategy.governance(),
"balanceOf": strategy.balanceOf(),
"balanceOfPool": strategy.balanceOfPool(),
}
# Ensure selected state values stay consistent across upgrade
for key, old_value in old_state.items():
new_value = new_state[key]
assert new_value == old_value
# Extra Initialization Steps
# strategy.initializeApprovals()
# strategy.setAutoCompoundingBps(2000)
# strategy.setAutoCompoundingPerformanceFeeGovernance(5000)
helper.publish()
def change_proxy_admin(badger, helper, admin, new_admin, setts):
admin = helper.contract_from_abi(
admin.address, "ProxyAdmin", artifacts.open_zeppelin["ProxyAdmin"]["abi"]
)
new_admin = helper.contract_from_abi(
new_admin.address, "ProxyAdmin", artifacts.open_zeppelin["ProxyAdmin"]["abi"]
)
for key in setts:
sett = badger.getSett(key)
console.print(f"Change proxy admin of {key} {sett.address} to {new_admin}")
admin.changeProxyAdmin(sett, new_admin)
assert new_admin.getProxyAdmin(sett) == new_admin
helper.publish()
def transfer_for_strategy(badger: BadgerSystem, key, amount, decimals=18):
console.print("Transferring Amount for Strategy {}".format(key),
val(amount, decimals))
manager = badger.badgerRewardsManager
strategy = badger.getStrategy(key)
before = snap_strategy_balance(badger, key, manager)
transfer_for_strategy_internal(badger, key, amount)
after = snap_strategy_balance(badger, key, manager)
diff = diff_numbers_by_key(before, after)
console.print("[green]==Transfer for {}==[/green]".format(key))
to_tabulate("Diff {}".format(key), diff)
def set_strategy_fees(
badger,
helper,
withdrawalFee,
performanceFeeStrategist,
performanceFeeGovernance,
strategies,
):
for key in strategies:
console.print(
f"Setting strategy fees on {key} to {withdrawalFee} / {performanceFeeStrategist} / {performanceFeeGovernance}"
)
strategy = helper.contract_from_abi(
badger.getStrategy(key).address,
"StrategyConvexStakingOptimizer",
StrategyConvexStakingOptimizer.abi,
)
vault = helper.contract_from_abi(badger.getSett(key).address, "Sett", Sett.abi)
controller = helper.contract_from_abi(
strategy.controller(), "Controller", Controller.abi
)
want = interface.IERC20(strategy.want())
old_state = {
"withdrawalFee": strategy.withdrawalFee(),
"performanceFeeStrategist": strategy.performanceFeeStrategist(),
"performanceFeeGovernance": strategy.performanceFeeGovernance(),
}
if old_state["withdrawalFee"] != withdrawalFee:
strategy.setWithdrawalFee(withdrawalFee)
if old_state["performanceFeeStrategist"] != performanceFeeStrategist:
strategy.setPerformanceFeeStrategist(performanceFeeStrategist)
if old_state["performanceFeeGovernance"] != performanceFeeGovernance:
strategy.setPerformanceFeeGovernance(performanceFeeGovernance)
new_state = {
"withdrawalFee": strategy.withdrawalFee(),
"performanceFeeStrategist": strategy.performanceFeeStrategist(),
"performanceFeeGovernance": strategy.performanceFeeGovernance(),
}
assert new_state["withdrawalFee"] == withdrawalFee
assert new_state["performanceFeeStrategist"] == performanceFeeStrategist
assert new_state["performanceFeeGovernance"] == performanceFeeGovernance
helper.publish()
def set_guest_lists(badger, safe, helper, vaults_to_add):
for key in vaults_to_add:
guestList = AddressZero
sett = helper.contract_from_abi(
badger.getSett(key).address, "SettV3", SettV3.abi
)
print(sett.governance())
console.print(f"Setting guest list [blue]{guestList}[/blue] on vault {key}")
if guestList != AddressZero:
assert guestList.wrapper() == sett
sett.setGuestList(guestList)
assert sett.guestList() == guestList
helper.publish()
def main():
badger = connect_badger()
safe = ApeSafe(badger.testMultisig.address)
helper = ApeSafeHelper(badger, safe)
for source_key in to_approve:
source = badger.getStrategy(source_key).address
# source = helper.contract_from_abi(badger.getStrategy(source_key), "StrategyConvexStakingOptimizer", StrategyConvexStakingOptimizer.abi)
for dest_key in destination_setts:
destination = helper.contract_from_abi(
badger.getSett(dest_key).address, "SettV3", SettV3.abi)
console.print(
f"Approve [green]{source}[/green] on Sett [yellow]{dest_key} ({destination.address})"
)
destination.approveContractAccess(source)
helper.publish()
def main():
badger = connect_badger()
new_logic = StrategyConvexStakingOptimizer.deploy(
{"from": badger.deployer})
tm = accounts.at(badger.testMultisig.address, force=True)
strategy = badger.getStrategy("native.pbtcCrv")
console.print("Before", {"curvePool": strategy.curvePool()})
badger.testProxyAdmin.upgrade(strategy, new_logic, {"from": tm})
strategy.setCurvePoolSwap(registry.curve.pools.pbtcCrv.swap, {"from": tm})
console.print("After", {"curvePool": strategy.curvePool()})
strategy = badger.getStrategy("native.obtcCrv")
# console.print("Before 2", {
# "curvePool": strategy.curvePool()
# })
# badger.testProxyAdmin.upgrade(strategy, new_logic, {'from': tm})
strategy.setCurvePoolSwap(registry.curve.pools.obtcCrv.swap, {"from": tm})
# console.print("After 2", {
# "curvePool": strategy.curvePool()
# })
strategy = badger.getStrategy("native.bbtcCrv")
# console.print("Before 3", {
# "curvePool": strategy.curvePool()
# })
# badger.testProxyAdmin.upgrade(strategy, new_logic, {'from': tm})
strategy.setCurvePoolSwap(registry.curve.pools.bbtcCrv.swap, {"from": tm})
# console.print("After 3", {
# "curvePool": strategy.curvePool()
# })
if rpc.is_active():
"""
Test: Load up testing accounts with ETH
"""
accounts[0].transfer(badger.deployer, Wei("5 ether"))
accounts[0].transfer(badger.keeper, Wei("5 ether"))
accounts[0].transfer(badger.guardian, Wei("5 ether"))
skip = keeper_config.get_active_chain_skipped_setts("harvest")
harvest_all(badger, skip)
def main():
badger = connect_badger(badger_config.prod_json)
deployer = badger.deployer
multi = GnosisSafe(badger.devMultisig)
rebaseParams = {}
rebaseParams[
"minRebaseTimeIntervalSec"] = badger.digg.uFragmentsPolicy.minRebaseTimeIntervalSec(
)
rebaseParams[
"rebaseWindowOffsetSec"] = badger.digg.uFragmentsPolicy.rebaseWindowOffsetSec(
)
rebaseParams[
"rebaseWindowLengthSec"] = badger.digg.uFragmentsPolicy.rebaseWindowLengthSec(
)
console.print(rebaseParams)
newWindowLength = hours(6)
console.print(newWindowLength)
multi.execute(
MultisigTxMetadata(description="Set Rebase Params"),
{
"to":
badger.digg.uFragmentsPolicy.address,
"data":
badger.digg.uFragmentsPolicy.setRebaseTimingParameters.
encode_input(
rebaseParams["minRebaseTimeIntervalSec"],
rebaseParams["rebaseWindowOffsetSec"],
newWindowLength,
),
},
)
chain.mine()
tx = badger.digg.orchestrator.rebase({"from": badger.deployer})
print(tx.call_trace())
tx = badger.digg.orchestrator.rebase({"from": badger.deployer})
print(tx.call_trace())
def unpause_vaults(badger, safe, helper, vaults_to_add):
for key in vaults_to_add:
console.print(f"Unpause Vaults {key}")
controller = safe.contract(badger.getController("experimental").address)
vault = safe.contract(badger.getSett(key).address)
strategy = badger.getStrategy(key)
assert strategy.paused() == False
console.print(
{
"vault_gov": vault.governance(),
"strat_gov": strategy.governance(),
}
)
vault.unpause()
assert vault.paused() == False
def harvest_all(badger: BadgerSystem, skip):
for key, vault in badger.sett_system.vaults.items():
if key in skip:
continue
console.print("\n[bold yellow]===== Harvest: " + str(key) +
" =====[/bold yellow]\n")
print("Harvest: " + key)
snap = SnapshotManager(badger, key)
strategy = badger.getStrategy(key)
keeper = accounts.at(badger.keeper)
before = snap.snap()
if strategy.keeper() == badger.badgerRewardsManager:
snap.settHarvestViaManager(
strategy,
{
"from": keeper,
"gas_limit": 2000000,
"allow_revert": True
},
confirm=False,
)
else:
snap.settHarvest(
{
"from": keeper,
"gas_limit": 2000000,
"allow_revert": True
},
confirm=False,
)
tx_wait()
if rpc.is_active():
chain.mine()
after = snap.snap()
snap.printCompare(before, after)
def set_withdrawal_fee(badger, safe, helper, vaults_to_add):
vaults_to_add = ["experimental.sushiIBbtcWbtc"]
for key in vaults_to_add:
console.print(f"Reduce Fees on Strats {key}")
controller = safe.contract(badger.getController("experimental").address)
# vault = safe.contract(badger.getSett(key).address)
assert strategy.withdrawalFee() == 50
strategy = safe.contract(badger.getStrategy(key).address)
assert strategy.paused() == False
console.print(
{
"strat_gov": strategy.governance(),
}
)
strategy.setWithdrawalFee(20)
assert strategy.withdrawalFee() == 20
helper.publish()
def main():
"""
Add contracts manually to guest list. They will now be approved regardless of merkle root situation
"""
badger = connect_badger()
safe = ApeSafe(badger.testMultisig.address)
helper = ApeSafeHelper(badger, safe)
for guest_list_key in guest_lists_by_id:
guestList = helper.contract_from_abi(
badger.getGuestList(guest_list_key).address,
"VipCappedGuestListBbtcUpgradeable",
VipCappedGuestListBbtcUpgradeable.abi,
)
console.print(
f"Set guest root to [green]{root}[/green] on Guest list [yellow]{guest_list_key} ({guestList.address})[/yellow]"
)
guestList.setGuestRoot(root)
assert guestList.guestRoot() == root
helper.publish()
def allow_strategies_on_rewards_manager(badger, safe, helper, vaults_to_add):
earner = "0x46099Ffa86aAeC689D11F5D5130044Ff7082C2AD"
keeper = "0x73433896620E71f7b1C72405b8D2898e951Ca4d5"
external_harvester = "0x64E2286148Fbeba8BEb4613Ede74bAc7646B2A2B"
for key in vaults_to_add:
console.print(f"Keeper Tuneup {key}")
controller = safe.contract(badger.getController("experimental").address)
sett = safe.contract(badger.getSett(key).address)
if sett.controller() != controller:
print(
f"Sett controller is {sett.controller()} rather than {controller.address}"
)
continue
strategy = safe.contract(badger.getSett(key).address)
rm = safe.contract(badger.badgerRewardsManager.address)
# Set all Sett keepers to RM
if sett.keeper() != rm:
console.print(f"Sett {key} keeper -> {rm.address}")
sett.setKeeper(rm)
# Set all Strategy keepers to RM
if strategy.keeper() != rm:
console.print(f"Strategy {key} keeper -> {rm.address}")
strategy.setKeeper(rm)
helper.publish()
def get_active_network(self):
active_network = network.show_active()
# return "bsc"
if active_network == None:
if "--network" not in sys.argv:
console.print(
"Network not found, defaulting to 'eth' (did you set the --network flag?)"
)
name = "eth"
else:
network_idx = sys.argv.index("--network")
name = self.network_name(sys.argv[network_idx + 1])
else:
name = self.network_name(active_network)
if name:
console.print("[cyan]Γ°ΕΈβΒ² Active network: {}[/cyan]".format(name))
return name
else:
raise Exception(
"Chain ID {} not recognized".format(active_network))
def set_performance_fees(
badger, helper, performanceFeeGovernance, performanceFeeStrategist, strats
):
for key in strats:
console.print(
f"Set Fees on Strats {key}",
{
"performanceFeeGovernance": performanceFeeGovernance,
"performanceFeeStrategist": performanceFeeStrategist,
},
)
strategy = helper.contract_from_abi(
badger.getStrategy(key).address,
"StrategyConvexStakingOptimizer",
StrategyConvexStakingOptimizer.abi,
)
strategy.setPerformanceFeeGovernance(1000)
strategy.setPerformanceFeeStrategist(0)
assert strategy.performanceFeeGovernance() == 1000
assert strategy.performanceFeeStrategist() == 0
helper.publish()
def upgrade_setts(badger, helper, admin, new_logic, setts):
"""
Upgrade setts
"""
for key in setts:
console.print(f"Upgrading strat {key} to new logic at {new_logic}")
admin = helper.contract_from_abi(
admin.address, "ProxyAdmin", artifacts.open_zeppelin["ProxyAdmin"]["abi"]
)
vault = helper.contract_from_abi(
badger.getSett(key).address, "SettV4", SettV4.abi
)
want = interface.IERC20(vault.token())
old_logic = admin.getProxyImplementation(vault)
old_state = {
"version": vault.version(),
"governance": vault.governance(),
"balance": vault.balance(),
}
console.print(old_state)
admin.upgrade(vault, new_logic)
assert admin.getProxyImplementation(vault) == new_logic
new_state = {
"version": vault.version(),
"governance": vault.governance(),
"balance": vault.balance(),
}
console.print(new_state)
# Ensure selected state values stay consistent across upgrade
for key, old_value in old_state.items():
new_value = new_state[key]
assert new_value == old_value
helper.publish()
def modify_guest_lists(badger, helper, vault_keys):
for key in vault_keys:
guestList = helper.contract_from_abi(
badger.getGuestList(key).address,
"VipCappedGuestListBbtcUpgradeable",
VipCappedGuestListBbtcUpgradeable.abi,
)
console.print(
f"π [yellow]Modifying guest list[/yellow] [blue]{guestList.address}[/blue] for key {key}"
)
console.print(" [purple]Params[/purple]", params)
old_cap = guestList.totalDepositCap()
new_cap = old_cap * 4
console.print({"old cap": old_cap, "new_cap": new_cap})
guestList.setUserDepositCap(new_cap)
guestList.setTotalDepositCap(new_cap)
assert guestList.guestRoot() == EmptyBytes32
helper.publish()
def config_guest_lists(badger):
for key in vaults_to_add:
guestList = badger.getGuestList(key)
sett = badger.getSett(key)
console.print(
f"π [yellow]Configuring guest list[/yellow] [blue]{guestList.address}[/blue] for key {key}"
)
console.print(" [purple]Params[/purple]", params)
old_cap = guestList.totalDepositCap()
new_cap = old_cap * 4
console.print({"old cap": old_cap, "new_cap": new_cap})
guestList.initialize(sett, {"from": badger.deployer})
guestList.setUserDepositCap(
params["user_deposit_cap"], {"from": badger.deployer}
)
guestList.setTotalDepositCap(
params["total_deposit_cap"], {"from": badger.deployer}
)
guestList.setGuestRoot(params["root"], {"from": badger.deployer})
def set_strategies_on_controller(badger, safe, helper, controller_id, vaults_to_add):
for key in vaults_to_add:
controller = safe.contract_from_abi(
badger.getController(controller_id).address, "Controller", Controller.abi
)
vault = safe.contract_from_abi(
badger.getSett(key).address, "SettV3", SettV3.abi
)
strategy = safe.contract_from_abi(
badger.getStrategy(key).address,
"StrategyConvexStakingOptimizer",
StrategyConvexStakingOptimizer.abi,
)
console.print(
f"Approve & Set strategy {strategy.address} ({strategy.getName()}) for {key} controller {controller_id}"
)
want = interface.IERC20(strategy.want())
before_ppfs = vault.getPricePerFullShare()
before_balance = vault.balance()
before_strategy = controller.strategies(want)
before_name = interface.IStrategy(before_strategy).getName()
controller.setStrategy(want, strategy)
after_ppfs = vault.getPricePerFullShare()
after_balance = vault.balance()
after_strategy = controller.strategies(want)
after_name = strategy.getName()
after_balance == before_balance
before_ppfs == after_ppfs
console.print(
{
"before_name": before_name,
"before_strategy": before_strategy,
"balance": before_balance,
"ppfs": before_ppfs,
}
)
console.print(
{
"after_name": after_name,
"after_strategy": after_strategy,
"balance": after_balance,
"ppfs": after_ppfs,
}
)
assert vault.controller() == controller
print(strategy.controller())
# assert strategy.controller() == controller
assert controller.approvedStrategies(want, strategy) == True
assert controller.strategies(want) == strategy.address
assert strategy.paused() == False
helper.publish()
def migrate_strategies_via_migrator(badger):
migrator = MigrationAssistant.at("0x8b459f4d8949f3748dc34430bc91441c954dc391")
data = migrator.migrate.encode_input(
badger.getController("native").address,
[
(
registry.curve.pools.renCrv.token,
"0x444B860128B7Bf8C0e864bDc3b7a36a940db7D88",
badger.getStrategy("native.renCrv").address,
),
(
registry.curve.pools.sbtcCrv.token,
"0x3Efc97A8e23f463e71Bf28Eb19690d097797eb17",
badger.getStrategy("native.sbtcCrv").address,
),
(
registry.curve.pools.tbtcCrv.token,
"0xE2fA197eAA5C726426003074147a08beaA59403B",
badger.getStrategy("native.tbtcCrv").address,
),
],
)
a = badger.getSett("native.renCrv")
b = badger.getSett("native.sbtcCrv")
c = badger.getSett("native.tbtcCrv")
d = badger.getStrategy("native.renCrv")
e = badger.getStrategy("native.sbtcCrv")
f = badger.getStrategy("native.tbtcCrv")
old_ren = interface.IStrategy("0x444B860128B7Bf8C0e864bDc3b7a36a940db7D88")
old_sbtc = interface.IStrategy("0x3Efc97A8e23f463e71Bf28Eb19690d097797eb17")
old_tbtc = interface.IStrategy("0xE2fA197eAA5C726426003074147a08beaA59403B")
console.print(
{
"ren": a.balance(),
"sbtc": b.balance(),
"tbtc": c.balance(),
"ren_ppfs": a.getPricePerFullShare(),
"sbtc_ppfs": b.getPricePerFullShare(),
"tbtc_ppfs": c.getPricePerFullShare(),
"ren_strat_pool": d.balanceOfPool(),
"ren_strat_want": d.balanceOfWant(),
"sbtc_strat_pool": e.balanceOfPool(),
"sbtc_strat_want": e.balanceOfWant(),
"tbtc_strat_pool": f.balanceOfPool(),
"tbtc_strat_want": f.balanceOfWant(),
"old_ren_strat_pool": old_ren.balanceOfPool(),
"old_ren_strat_want": old_ren.balanceOfWant(),
"old_sbtc_strat_pool": old_sbtc.balanceOfPool(),
"old_sbtc_strat_want": old_sbtc.balanceOfWant(),
"old_tbtc_strat_pool": old_tbtc.balanceOfPool(),
"old_tbtc_strat_want": old_tbtc.balanceOfWant(),
}
)
tokens = [
interface.IERC20(registry.curve.pools.renCrv.token),
interface.IERC20(registry.curve.pools.sbtcCrv.token),
interface.IERC20(registry.curve.pools.tbtcCrv.token),
]
entities = [
a,
b,
c,
d,
e,
f,
badger.getController("native"),
"0x444B860128B7Bf8C0e864bDc3b7a36a940db7D88",
"0x3Efc97A8e23f463e71Bf28Eb19690d097797eb17",
"0xE2fA197eAA5C726426003074147a08beaA59403B",
]
table = []
for entity in entities:
for token in tokens:
table.append([entity, token.name(), token.balanceOf(entity)])
print(tabulate(table, ["entity", "asset", "value"]))
multi = GnosisSafe(badger.opsMultisig)
# 'to': badger.getController("native").address,
tx = multi.execute(
MultisigTxMetadata(description="CRV Migration"),
{"to": migrator.address, "data": data, "operation": 1},
)
a.earn({"from": badger.deployer})
b.earn({"from": badger.deployer})
c.earn({"from": badger.deployer})
console.print(
{
"ren": a.balance(),
"sbtc": b.balance(),
"tbtc": c.balance(),
"ren_ppfs": a.getPricePerFullShare(),
"sbtc_ppfs": b.getPricePerFullShare(),
"tbtc_ppfs": c.getPricePerFullShare(),
"ren_strat_pool": d.balanceOfPool(),
"ren_strat_want": d.balanceOfWant(),
"sbtc_strat_pool": e.balanceOfPool(),
"sbtc_strat_want": e.balanceOfWant(),
"tbtc_strat_pool": f.balanceOfPool(),
"tbtc_strat_want": f.balanceOfWant(),
"old_ren_strat_pool": old_ren.balanceOfPool(),
"old_ren_strat_want": old_ren.balanceOfWant(),
"old_sbtc_strat_pool": old_sbtc.balanceOfPool(),
"old_sbtc_strat_want": old_sbtc.balanceOfWant(),
"old_tbtc_strat_pool": old_tbtc.balanceOfPool(),
"old_tbtc_strat_want": old_tbtc.balanceOfWant(),
}
)
