def main():
badger = connect_badger()
digg = badger.digg
safe = ApeSafe(badger.devMultisig.address)
abi = Sett.abi
badgerToken = safe.contract(badger.token.address)
diggToken = safe.contract(digg.token.address)
bBadger = safe.contract_from_abi(
badger.getSett("native.badger").address, "Sett", abi)
bDigg = safe.contract_from_abi(
badger.getSett("native.digg").address, "Sett", abi)
rewardsEscrow = safe.contract(badger.rewardsEscrow.address)
# Exchange renBTC for wBTC
wbtc = tokens.erc20_by_key("wbtc")
renbtc = tokens.erc20_by_key("renbtc")
snap = BalanceSnapshotter([wbtc, renbtc], [badger.devMultisig])
snap.snap(name="Before", print=True)
crv_swap(badger, safe, amount_in=367606868, max_slippage=0.005)
snap.snap(name="After")
snap.diff_last_two()
helper = ApeSafeHelper(badger, safe)
helper.publish()
def main():
badger = connect_badger("deploy-final.json")
digg = badger.digg
admin = badger.devProxyAdmin
multisig = badger.devMultisig
contracts = badger.contracts_upgradeable
deployer = badger.deployer
expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77"
assert multisig == expectedMultisig
safe = ApeSafe(badger.devMultisig.address)
abi = Sett.abi
diggToken = safe.contract(digg.token.address)
bDigg = safe.contract_from_abi(
badger.getSett("native.digg").address, "Sett", abi)
rewardsEscrow = safe.contract_from_abi(badger.rewardsEscrow.address,
"RewardsEscrow", RewardsEscrow.abi)
teamVesting = safe.contract(badger.teamVesting.address)
voting = safe.contract_from_abi(badger.daoBadgerTimelock.address,
"IVoting", interface.IVoting.abi)
aragon = AragonSystem()
aragonVoting = aragon.getVotingAt(
web3.toChecksumAddress("0xdc344bfb12522bf3fa58ef0d6b9a41256fc79a1b"))
token_registry = registry.token_system()
dev = accounts.at(badger.devMultisig.address, force=True)
tokens = [
token_registry.erc20_by_address(registry.tokens.farm),
token_registry.erc20_by_address(registry.tokens.xSushi),
token_registry.erc20_by_address(registry.curve.pools.sbtcCrv.token),
token_registry.erc20_by_address(registry.curve.pools.renCrv.token),
token_registry.erc20_by_address(registry.curve.pools.tbtcCrv.token),
token_registry.erc20_by_address(registry.sushi.lpTokens.sushiWbtcWeth),
token_registry.erc20_by_address(registry.tokens.dfd),
]
snap = BalanceSnapshotter(tokens, [badger.devMultisig, badger.dao.agent])
snap.snap(name="Before Transfers")
for id in vote_ids:
voting.vote(id, True, True)
rewardsEscrow.call(aragonVoting, 0,
aragonVoting.vote.encode_input(id, True, True))
teamVesting.call(aragonVoting, 0,
aragonVoting.vote.encode_input(id, True, True))
snap.snap(name="After Transfers")
snap.diff_last_two()
safe_tx = safe.multisend_from_receipts()
safe.preview(safe_tx)
data = safe.print_transaction(safe_tx)
safe.post_transaction(safe_tx)
def main():
badger = connect_badger()
multisig = badger.devMultisig
safe = ApeSafe(multisig.address)
abi = Sett.abi
bBadger = safe.contract_from_abi(
badger.getSett("native.badger").address, "Sett", abi
)
usdcToken = safe.contract_from_abi(
registry.tokens.usdc, "IERC20", interface.IERC20.abi
)
badgerToken = safe.contract_from_abi(
badger.token.address, "IERC20", interface.IERC20.abi
)
wbtcToken = safe.contract_from_abi(
registry.tokens.wbtc, "IERC20", interface.IERC20.abi
)
rewardsEscrow = safe.contract(badger.rewardsEscrow.address)
# TODO: Do this in bBadger going forward - this is the way.
# Approve treasury multi to stake
# Deposit badger -> bBadger
snap = BalanceSnapshotter(
[badgerToken, usdcToken, wbtcToken],
[multisig, badger.deployer, badger.rewardsEscrow],
)
opolis_dest = "0x27657399177403a891CC7A22Bd6F2C00621Db7b0"
test_usdc = 1 * 10 ** 6
full_usdc = 499999 * 10 ** 6
full_badger = Wei("10163.59 ether")
full_wbtc = 3.805754301 * 10 ** 8
console.print("Sending Amounts")
snap.snap(name="Before Transfers")
usdcToken.transfer(opolis_dest, full_usdc)
rewardsEscrow.approveRecipient(opolis_dest)
rewardsEscrow.transfer(badger.token, opolis_dest, full_badger)
# badgerToken.transfer(opolis_dest, full_badger)
wbtcToken.transfer(opolis_dest, full_wbtc)
snap.snap(name="After Transfers")
snap.diff_last_two()
safe_tx = safe.multisend_from_receipts()
safe.preview(safe_tx)
data = safe.print_transaction(safe_tx)
safe.post_transaction(safe_tx)
def main():
badger = connect_badger()
multisig = badger.paymentsMultisig
safe = ApeSafe(multisig.address)
payments = load_ltcc_recipients("data/ltcc_recipients.csv")
payments.calc_totals()
payments.print_recipients()
abi = Sett.abi
bBadger = safe.contract_from_abi(
badger.getSett("native.badger").address, "Sett", abi
)
usdcToken = safe.contract_from_abi(
registry.tokens.usdc, "IERC20", interface.IERC20.abi
)
badgerToken = safe.contract_from_abi(
badger.token.address, "IERC20", interface.IERC20.abi
)
# TODO: Do this in bBadger going forward - this is the way.
# Approve treasury multi to stake
# Deposit badger -> bBadger
snap = BalanceSnapshotter(
[badgerToken, bBadger, usdcToken],
[multisig, badger.deployer, badger.rewardsEscrow],
)
for recipient in payments.recipients:
snap.add_account(recipient.address)
snap.snap(name="Before bBadger Deposit")
assert bBadger.approved(multisig)
badger_total = payments.totals["badger"]
assert badgerToken.balanceOf(multisig.address) >= badger_total
bBadger_total = badger_to_bBadger(badger, badger_total)
badgerToken.approve(bBadger, badger_total)
assert badgerToken.allowance(multisig.address, bBadger.address) >= badger_total
bBadger.deposit(badger_total)
snap.snap(name="After bBadger Deposit")
snap.diff_last_two()
safe_tx = safe.multisend_from_receipts()
safe.preview(safe_tx)
data = safe.print_transaction(safe_tx)
safe.post_transaction(safe_tx)
def main():
badger = connect_badger()
multisig = badger.devMultisig
safe = ApeSafe(multisig.address)
payments = load_ltcc_recipients("scripts/actions/treasury/ltcc_recipients.csv")
payments.print_recipients()
abi = Sett.abi
bBadger = safe.contract_from_abi(
badger.getSett("native.badger").address, "Sett", abi
)
usdcToken = safe.contract_from_abi(registry.tokens.usdc, "IERC20", interface.IERC20.abi)
badgerToken = safe.contract_from_abi(badger.token.address, "IERC20", interface.IERC20.abi)
# TODO: Do this in bBadger going forward - this is the way.
# Approve treasury multi to stake
# Deposit badger -> bBadger
snap = BalanceSnapshotter(
[badgerToken, bBadger, usdcToken], [multisig, badger.deployer, badger.rewardsEscrow]
)
for recipient in payments.recipients:
snap.add_account(recipient.address)
snap.snap(name="Before Transfers")
for recipient in payments.recipients:
bBadger_amount = badger_to_bBadger(badger, recipient.get_amount("badger"))
console.print(recipient.address, recipient.get_amount("badger"), bBadger_amount)
diff = bBadger_amount - bBadger.balanceOf(multisig)
console.print(bBadger.balanceOf(multisig), diff)
if bBadger.balanceOf(multisig) < bBadger_amount:
assert diff < Wei("0.1 ether")
bBadger_amount = bBadger.balanceOf(multisig)
# tx = usdcToken.transfer(recipient.address, recipient.get_amount("usdc"))
tx = bBadger.transfer(recipient.address, bBadger_amount)
snap.snap(name="After Transfers")
snap.diff_last_two()
safe_tx = safe.multisend_from_receipts()
safe.preview(safe_tx)
data = safe.print_transaction(safe_tx)
safe.post_transaction(safe_tx)
def main():
badger = connect_badger("deploy-final.json")
digg = badger.digg
admin = badger.devProxyAdmin
multisig = badger.devMultisig
contracts = badger.contracts_upgradeable
deployer = badger.deployer
expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77"
assert multisig == expectedMultisig
recipient = accounts.at("0x8Ea8a668f89a9A203d37D8a1E27e38De5bEb8380",
force=True)
safe = ApeSafe(badger.devMultisig.address)
abi = Sett.abi
badgerToken = safe.contract(badger.token.address)
diggToken = safe.contract(digg.token.address)
bBadger = safe.contract_from_abi(
badger.getSett("native.badger").address, "Sett", abi)
bDigg = safe.contract_from_abi(
badger.getSett("native.digg").address, "Sett", abi)
snap = BalanceSnapshotter(
[badgerToken, diggToken, bBadger, bDigg],
[badger.devMultisig, badger.deployer, badger.rewardsEscrow, recipient],
)
snap.snap(name="Before Transfers", print=True)
bBadger_amount = Wei("4585.501571219566358195 ether")
bDigg_amount = Wei("6.96203478522210066 ether")
# Transfer receieved amounts to badger deployer for transfer over bridge
bBadger.transfer(recipient, bBadger_amount)
bDigg.transfer(recipient, bDigg_amount)
snap.snap(name="After Transfers")
snap.diff_last_two()
safe_tx = safe.multisend_from_receipts()
safe.preview(safe_tx)
data = safe.print_transaction(safe_tx)
safe.post_transaction(safe_tx)
def main():
badger = connect_badger()
bDigg = badger.getSett("native.digg")
# rug = accounts.at(web3.toChecksumAddress("0x533e3c0e6b48010873b947bddc4721b1bdff9648"), force=True)
# print(bDigg.balanceOf(rug))
# bDigg.transfer(badger.devMultisig, amount, {"from": rug})
bDigg_to_deposit = amount
print("bDigg_to_deposit", bDigg_to_deposit)
round_1 = Wei("1 ether")
round_2 = bDigg_to_deposit - round_1
safe = ApeSafe(badger.devMultisig.address)
bDigg = safe.contract_from_abi(
"0x7e7E112A68d8D2E221E11047a72fFC1065c38e1a", "Sett", Sett.abi)
dropt = safe.contract_from_abi(
web3.toChecksumAddress("0x02660b54750efab874fb43b4b613c135c7815eef"),
"SyntheticToken",
SyntheticToken.abi,
)
kpiOptions = safe.contract_from_abi(
web3.toChecksumAddress("0xbc044745f137d4693c2aa823c760f855254fad42"),
"ExpiringMultiParty",
ExpiringMultiParty.abi,
)
snap = BalanceSnapshotter([bDigg, dropt],
[badger.devMultisig, kpiOptions, dropt])
snap.snap()
bDigg.approve(kpiOptions, bDigg_to_deposit)
kpiOptions.create([round_1], [int(round_1 * 1000)])
kpiOptions.create([round_2], [int(round_2 * 1000)])
chain.mine()
snap.snap()
snap.diff_last_two()
helper = ApeSafeHelper(badger, safe)
helper.publish()
def deploy(self, sett_type=SettType.DEFAULT, deploy=True) -> BadgerSystem:
badger = connect_badger()
digg = badger.digg
dev = badger.deployer
timelock = badger.digg.daoDiggTimelock
multi = GnosisSafe(badger.devMultisig)
safe = ApeSafe(badger.devMultisig.address)
ops = ApeSafe(badger.opsMultisig.address)
bDigg = safe.contract_from_abi(
badger.getSett("native.digg").address, "Sett", Sett.abi
)
controller = ops.contract(badger.getController("experimental").address)
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())
controller.approveStrategy(digg.token, strategy)
controller.setStrategy(digg.token, strategy)
self.badger = badger
return self.badger
def main():
badger = connect_badger("deploy-final.json")
digg = badger.digg
admin = badger.devProxyAdmin
multisig = badger.devMultisig
contracts = badger.contracts_upgradeable
deployer = badger.deployer
expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77"
assert multisig == expectedMultisig
safe = ApeSafe(badger.devMultisig.address)
abi = Sett.abi
diggToken = safe.contract(digg.token.address)
bDigg = safe.contract_from_abi(
badger.getSett("native.digg").address, "Sett", abi)
rewardsEscrow = safe.contract(badger.rewardsEscrow.address)
snap = BalanceSnapshotter(
[diggToken, bDigg],
[badger.devMultisig, badger.deployer, badger.rewardsEscrow])
snap.snap(name="Before Transfers")
ppfs = bDigg.getPricePerFullShare()
digg_to_deposit = 10 * (10**18) // (10**9)
console.print("digg_to_deposit", digg_to_deposit, ppfs)
# Transfer assets to multisig
rewardsEscrow.transfer(diggToken, badger.devMultisig, digg_to_deposit)
snap.snap(name="After Transfers")
snap.diff_last_two()
# Deposit bDigg
diggToken.approve(bDigg.address, digg_to_deposit)
tx = bDigg.deposit(digg_to_deposit)
print(tx.events)
snap.snap(name="After Deposits")
snap.diff_last_two()
safe_tx = safe.multisend_from_receipts()
safe.preview(safe_tx)
data = safe.print_transaction(safe_tx)
safe.post_transaction(safe_tx)
def crv_swap(badger, safe: ApeSafe, amount_in, max_slippage):
wbtc = safe.contract(tokens.erc20_by_key("wbtc").address)
renbtc = safe.contract(tokens.erc20_by_key("renbtc").address)
indicies = {'wbtc': 1, 'renbtc': 0}
# sbtc = interface.ICurveFi("0x7fc77b5c7614e1533320ea6ddc2eb61fa00a9714")
sbtc = safe.contract_from_abi(address=web3.toChecksumAddress(
"0x7fc77b5c7614e1533320ea6ddc2eb61fa00a9714"),
name="ICurveFi",
abi=interface.ICurveFi.abi)
# wbtc.approve(sbtc, amount_in)
renbtc.approve(sbtc, amount_in)
required_out = amount_in - int(amount_in * max_slippage)
print(required_out)
sbtc.exchange(indicies['renbtc'], indicies['wbtc'], amount_in,
required_out)
def main():
badger = connect_badger()
safe = ApeSafe(badger.opsMultisig.address)
nft = safe.contract_from_abi(
badger_nft_address, "IBadgerERC1155", interface.IBadgerERC1155.abi
)
assert nft.totalSupply(nft_id) == 210
print(len(third_set))
for recipient in third_set:
nft.safeTransferFrom(badger.opsMultisig.address, recipient, nft_id, 1, "0x")
console.print(recipient, nft.balanceOf(recipient, nft_id))
assert nft.balanceOf(recipient, nft_id) == 1
print("Remaining After Transfer", nft.balanceOf(badger.opsMultisig, nft_id))
safe_tx = safe.multisend_from_receipts()
safe.preview(safe_tx)
data = safe.print_transaction(safe_tx)
safe.post_transaction(safe_tx)
def main():
badger = connect_badger()
multisig = badger.paymentsMultisig
safe = ApeSafe(multisig.address)
helper = ApeSafeHelper(badger, safe)
payments = load_ltcc_recipients("data/ltcc_recipients.csv")
payments.calc_totals()
payments.print_recipients()
abi = Sett.abi
bBadger = safe.contract_from_abi(
badger.getSett("native.badger").address, "Sett", abi)
usdcToken = safe.contract_from_abi(registry.tokens.usdc, "IERC20",
interface.IERC20.abi)
badgerToken = safe.contract_from_abi(badger.token.address, "IERC20",
interface.IERC20.abi)
snap = BalanceSnapshotter(
[badgerToken, bBadger, usdcToken],
[multisig, badger.deployer, badger.rewardsEscrow],
)
snap.snap()
# TODO: Do this in bBadger going forward - this is the way.
# Approve treasury multi to stake
# Deposit badger -> bBadger
# console.print(f"Converting total of {val(payments.totals['badger'])} badger into bBadger")
# badgerToken.approve(bBadger, payments.totals['badger'])
# bBadger.deposit(payments.totals['badger'])
# snap.snap()
# snap.diff_last_two()
# helper.publish()
# return True
for recipient in payments.recipients:
snap.add_account(recipient.address)
snap.snap(name="Before Transfers")
for recipient in payments.recipients:
bBadger_amount = badger_to_bBadger(badger,
recipient.get_amount("badger"))
console.print(recipient.address, recipient.get_amount("badger"),
bBadger_amount)
diff = bBadger_amount - bBadger.balanceOf(multisig)
console.print(bBadger.balanceOf(multisig), diff)
if bBadger.balanceOf(multisig) < bBadger_amount:
assert diff < Wei("0.1 ether")
bBadger_amount = bBadger.balanceOf(multisig)
tx = usdcToken.transfer(recipient.address,
recipient.get_amount("usdc"))
tx = bBadger.transfer(recipient.address, bBadger_amount)
snap.snap(name="After Transfers")
snap.diff_last_two()
helper.publish()
def main():
badger = connect_badger()
digg = badger.digg
safe = ApeSafe(badger.paymentsMultisig.address)
abi = Sett.abi
badgerToken = safe.contract(badger.token.address)
diggToken = safe.contract(digg.token.address)
bBadger = safe.contract_from_abi(
badger.getSett("native.badger").address, "Sett", abi)
bDigg = safe.contract_from_abi(
badger.getSett("native.digg").address, "Sett", abi)
rewardsEscrow = safe.contract(badger.rewardsEscrow.address)
badger_usd = fetch_usd_price(badger.token.address)
eth_usd = fetch_usd_price_eth()
# USD Denominated
# badger_to_send = Wei(str(total_usd / badger_usd) + " ether")
# Badger Denominated
badger_to_send = Wei("5970.744318 ether")
table = []
table.append(["badger", badger_to_send, badger_usd])
table.append(["eth", 0, eth_usd])
print(tabulate(table, headers=["asset", "to send", "$ price"]))
snap = BalanceSnapshotter(
[badgerToken, bBadger],
[badger.devMultisig, badger.deployer, badger.rewardsEscrow],
)
snap.snap(name="Before Transfers")
# Transfer assets to multisig
# rewardsEscrow.transfer(badgerToken, safe, badger_to_send)
snap.snap(name="After Transfers")
snap.diff_last_two()
# Deposit bBadger
badgerToken.approve(bBadger.address, badger_to_send)
bBadgerBefore = bBadger.balanceOf(safe)
tx = bBadger.deposit(badger_to_send)
bBadgerAfter = bBadger.balanceOf(badger.devMultisig)
print(
"bBadger to transfer",
bBadgerAfter - bBadgerBefore,
val(bBadgerAfter - bBadgerBefore),
)
# bBadger.transfer(badger.paymentsMultisig, bBadgerAfter - bBadgerBefore)
print(tx.events)
snap.snap(name="After Deposits")
snap.diff_last_two()
safe_tx = safe.multisend_from_receipts()
safe.preview(safe_tx)
data = safe.print_transaction(safe_tx)
safe.post_transaction(safe_tx)
def main():
badger = connect_badger("deploy-final.json")
digg = badger.digg
tx_data = {
"to":
"0x8D29bE29923b68abfDD21e541b9374737B49cdAD",
"data":
"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",
}
sushiBbadgerPair = "0x0a54d4b378c8dbfc7bc93be50c85debafdb87439"
sushiBDiggPair = "0xf9440fedc72a0b8030861dcdac39a75b544e7a3c"
sushiswap = SushiswapSystem()
pair = interface.IUniswapV2Pair(sushiBbadgerPair)
console.print({
"getReserves": pair.getReserves(),
"token0": pair.token0(),
"token1": pair.token1(),
"price0CumulativeLast": pair.price0CumulativeLast(),
"price1CumulativeLast": pair.price1CumulativeLast(),
})
pair = interface.IUniswapV2Pair(sushiBDiggPair)
console.print({
"getReserves": pair.getReserves(),
"token0": pair.token0(),
"token1": pair.token1(),
"price0CumulativeLast": pair.price0CumulativeLast(),
"price1CumulativeLast": pair.price1CumulativeLast(),
})
usd_amount = 500000
weth = interface.IERC20(registry.tokens.weth)
console.log("..Before Safe")
safe = ApeSafe(badger.devMultisig.address)
ops_safe = ApeSafe(badger.opsMultisig.address)
console.log("..After Safe Setup")
# multi = GnosisSafe(badger.devMultisig)
# multi.execute(
# MultisigTxMetadata(description="Run TX"),
# {"to": tx_data["to"], "data": tx_data["data"], "operation": 1},
# )
after = get_token_balances(
[
badger.token,
digg.token,
interface.IERC20(registry.tokens.usdc),
interface.IERC20(sushiBbadgerPair),
interface.IERC20(sushiBDiggPair),
],
[badger.devMultisig],
)
after.print()
pair = interface.IUniswapV2Pair(sushiBbadgerPair)
console.print({
"getReserves": pair.getReserves(),
"token0": pair.token0(),
"token1": pair.token1(),
"price0CumulativeLast": pair.price0CumulativeLast(),
"price1CumulativeLast": pair.price1CumulativeLast(),
})
pair = interface.IUniswapV2Pair(sushiBDiggPair)
console.print({
"getReserves": pair.getReserves(),
"token0": pair.token0(),
"token1": pair.token1(),
"price0CumulativeLast": pair.price0CumulativeLast(),
"price1CumulativeLast": pair.price1CumulativeLast(),
})
router = safe.contract(sushiswap.router.address)
rewardsEscrow = safe.contract(badger.rewardsEscrow.address)
badgerToken = safe.contract(badger.token.address)
diggToken = safe.contract(digg.token.address)
digg_to_lp = Wei("8.4 gwei")
usd_per_side = 250000
# TODO: Use banteg's nice value calc script.
badger_usd = fetch_usd_price(badger.token.address)
digg_usd = fetch_usd_price(digg.token.address)
eth_usd = fetch_usd_price_eth()
console.log(eth_usd)
badger_to_swap = Wei(str(95000 / badger_usd) + " ether")
badger_to_lp = Wei(str(usd_per_side / badger_usd) + " ether")
digg_to_lp = Wei(str(usd_per_side / digg_usd) + " gwei")
eth_out = Wei(str(usd_per_side / eth_usd) + " ether")
console.print({
"badger_to_swap": badger_to_swap,
"badger_to_lp": badger_to_lp,
"digg_to_lp": digg_to_lp,
"eth_out": eth_out,
"badger_usd": badger_usd,
"digg_usd": digg_usd,
"eth_usd": eth_usd,
})
badger_to_get_from_escrow = badger_to_swap + badger_to_lp
# Get 250k worth of bBadger + $90k Amount to swap to ETH
rewardsEscrow.transfer(badger.token, badger.devMultisig,
badger_to_get_from_escrow)
# Get 250k worth of bDigg
rewardsEscrow.transfer(digg.token, badger.devMultisig, digg_to_lp)
# Sell badger for 90k USD
exact_eth = Wei(str(90000 / eth_usd) + " ether")
console.print("exact_eth", exact_eth)
assert badger.token.balanceOf(badger.devMultisig) >= badger_to_swap
print("a")
badgerToken.approve(sushiswap.router.address, badger_to_swap)
print("b")
assert (badger.token.allowance(badger.devMultisig,
sushiswap.router.address) == badger_to_swap)
router.swapTokensForExactETH(
exact_eth,
int(badger_to_swap * 1.02),
[badger.token, registry.tokens.wbtc, registry.tokens.weth],
badger.devMultisig,
chain.time() + 200000,
)
print("d")
after = get_token_balances([badger.token, digg.token],
[badger.devMultisig])
after.print()
# Deposit Badger for bBadger
# Deposit DIGG for bDigg
bBadger_address = badger.getSett("native.badger").address
bDigg_address = badger.getSett("native.digg").address
console.print(bBadger_address, bDigg_address)
abi = Sett.abi
bBadger = safe.contract_from_abi(bBadger_address, "Sett", abi)
bDigg = safe.contract_from_abi(bDigg_address, "Sett", abi)
badgerToken.approve(bBadger.address, badger_to_lp)
print(bBadger)
console.print(bBadger)
bBadger.deposit(badger_to_lp)
diggToken.approve(bDigg.address, digg_to_lp)
bDigg.approveContractAccess(badger.devMultisig)
tx = bDigg.deposit(digg_to_lp)
console.print(tx.events)
# tx = bDigg.withdraw(bDigg.balanceOf(badger.devMultisig))
# console.print(tx.events)
after = get_token_balances(
[
badger.token,
digg.token,
interface.IERC20(bDigg.address),
interface.IERC20(bBadger.address),
],
[badger.devMultisig],
)
after.print()
# Seed pools: 250k worth of bToken, 250k worth of ETH
tokenA = bBadger
amountA = (badger_to_lp * 10**18) / bBadger.getPricePerFullShare()
amountB = eth_out
# TODO: Set the amount of ETH to what is required.
after = get_token_balances(
[
badger.token,
digg.token,
interface.IERC20(bDigg.address),
interface.IERC20(bBadger.address),
interface.IERC20(sushiBbadgerPair),
interface.IERC20(sushiBDiggPair),
],
[badger.devMultisig],
)
after.print()
safe_tx = safe.multisend_from_receipts()
safe.preview(safe_tx)
data = safe.print_transaction(safe_tx)
safe.post_transaction(safe_tx)
"""
How do we get exactly 250k worth of each asset?
Calculate how much you need to get 250k
===== Normal Assets =====
250k / USD price of asset
===== For bTokens =====
How much original token to get: 250k / USD price of underlying asset
bToken will handle itself
"""
tokenA.approve(sushiswap.router, amountA)
console.print(
"addLiquidityETH",
{
"tokenA": tokenA.address,
"amountA": amountA,
"amountB": amountB,
"badger ppfs": bBadger.getPricePerFullShare(),
"original supply": Wei("4000 gwei"),
"current supply": digg.token.totalSupply(),
},
)
router.addLiquidityETH(
tokenA.address,
amountA,
int(amountA * 0.95),
int(eth_out * 0.95),
badger.devMultisig,
chain.time() + 200000,
{"value": eth_out},
)
tokenA = bDigg
amountA = ((digg_to_lp * 10**9) * 10**18) / bDigg.getPricePerFullShare()
amountA = amountA * (Wei("4000 gwei")) / digg.token.totalSupply()
print("expected bDigg", amountA)
amountA = bDigg.balanceOf(badger.devMultisig)
print("actual bDigg", amountA)
tokenA.approve(sushiswap.router, amountA)
console.print(
"addLiquidityETH",
{
"tokenA": tokenA.address,
"amountA": amountA,
"amountB": amountB,
"digg ppfs": bDigg.getPricePerFullShare(),
},
)
router.addLiquidityETH(
tokenA.address,
amountA,
int(amountA * 0.95),
int(eth_out * 0.95),
badger.devMultisig,
chain.time() + 200000,
{"value": eth_out},
)
after = get_token_balances(
[
badger.token,
digg.token,
interface.IERC20(bDigg.address),
interface.IERC20(bBadger.address),
interface.IERC20(sushiBbadgerPair),
interface.IERC20(sushiBDiggPair),
],
[badger.devMultisig],
)
after.print()
safe_tx = safe.multisend_from_receipts()
safe.preview(safe_tx)
data = safe.print_transaction(safe_tx)
safe.post_transaction(safe_tx)
pair = interface.IUniswapV2Pair(sushiBbadgerPair)
console.print({
"getReserves": pair.getReserves(),
"token0": pair.token0(),
"token1": pair.token1(),
"price0CumulativeLast": pair.price0CumulativeLast(),
"price1CumulativeLast": pair.price1CumulativeLast(),
})
pair = interface.IUniswapV2Pair(sushiBDiggPair)
console.print({
"getReserves": pair.getReserves(),
"token0": pair.token0(),
"token1": pair.token1(),
"price0CumulativeLast": pair.price0CumulativeLast(),
"price1CumulativeLast": pair.price1CumulativeLast(),
})
safe.post_transaction(safe_tx)
pair = interface.IUniswapV2Pair(sushiBbadgerPair)
console.print({
"getReserves": pair.getReserves(),
"token0": pair.token0(),
"token1": pair.token1(),
"price0CumulativeLast": pair.price0CumulativeLast(),
"price1CumulativeLast": pair.price1CumulativeLast(),
})
pair = interface.IUniswapV2Pair(sushiBDiggPair)
console.print({
"getReserves": pair.getReserves(),
"token0": pair.token0(),
"token1": pair.token1(),
"price0CumulativeLast": pair.price0CumulativeLast(),
"price1CumulativeLast": pair.price1CumulativeLast(),
})
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()
def main():
badger = connect_badger("deploy-final.json")
digg = badger.digg
admin = badger.devProxyAdmin
multisig = badger.devMultisig
contracts = badger.contracts_upgradeable
deployer = badger.deployer
expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77"
assert multisig == expectedMultisig
safe = ApeSafe(badger.devMultisig.address)
abi = Sett.abi
badgerToken = safe.contract(badger.token.address)
diggToken = safe.contract(digg.token.address)
bBadger = safe.contract_from_abi(
badger.getSett("native.badger").address, "Sett", abi)
bDigg = safe.contract_from_abi(
badger.getSett("native.digg").address, "Sett", abi)
rewardsEscrow = safe.contract(badger.rewardsEscrow.address)
badger_usd = fetch_usd_price(badger.token.address)
eth_usd = fetch_usd_price_eth()
# USD Denominated
# badger_to_send = Wei(str(total_usd / badger_usd) + " ether")
# Badger denominated
badger_to_send = Wei("5970.744318 ether")
table = []
table.append(["badger", badger_to_send, badger_usd])
table.append(["eth", 0, eth_usd])
print(tabulate(table, headers=["asset", "to send", "$ price"]))
snap = BalanceSnapshotter(
[badgerToken, bBadger],
[badger.devMultisig, badger.deployer, badger.rewardsEscrow])
snap.snap(name="Before Transfers")
# Transfer assets to multisig
rewardsEscrow.transfer(badgerToken, badger.devMultisig, badger_to_send)
snap.snap(name="After Transfers")
snap.diff_last_two()
# Deposit bBadger
badgerToken.approve(bBadger.address, badger_to_send)
bBadgerBefore = bBadger.balanceOf(badger.devMultisig)
tx = bBadger.deposit(badger_to_send)
bBadgerAfter = bBadger.balanceOf(badger.devMultisig)
print("bBadger to transfer", bBadgerAfter - bBadgerBefore,
val(bBadgerAfter - bBadgerBefore))
# bBadger.transfer(badger.treasuryMultisig, bBadgerAfter - bBadgerBefore)
print(tx.events)
snap.snap(name="After Deposits")
snap.diff_last_two()
safe_tx = safe.multisend_from_receipts()
safe.preview(safe_tx)
data = safe.print_transaction(safe_tx)
safe.post_transaction(safe_tx)