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 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() 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 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(): """ First, swap half of the USDC into DAI Deposit USDC portion in to Yearn USDC Vault V2 Deposit DAI portion in to Yearn DAI Vault V2 For the deposits, create small test transactions first """ badger = connect_badger() safe = ApeSafe(badger.paymentsMultisig.address) helper = ApeSafeHelper(badger, safe) # Fetch tokens for snap + interactions usdc = safe.contract("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48") dai = safe.contract("0x6B175474E89094C44Da98b954EedeAC495271d0F") yDai = safe.contract("0x19D3364A399d251E894aC732651be8B0E4e85001") yUsdc = safe.contract("0x5f18C75AbDAe578b483E5F43f12a39cF75b973a9") usdc_to_swap = 35000 * 10**6 ## 1.5 * 10^6 (Million) * 10^6 (Decimals) # TODO: Track the balances of the tokens representing your position here: AAVE USDC (aUSDC), Compound USDC (cUSDC), y3Crv Vault Position (y3Crv) snap = BalanceSnapshotter( [usdc, dai, yDai, yUsdc], [ badger.paymentsMultisig, ], ) snap.snap() current_dai_balance = dai.balanceOf(badger.devMultisig.address) ## NOTE: Swap to DAI with Curve ## Coins[0] == DAI ## Coins[1] == UDC curve_pool = safe.contract("0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7") dai_out = curve_pool.get_dy(1, 0, usdc_to_swap) with_slippage = dai_out * 0.99 print("With slippage") print(with_slippage) usdc.approve(curve_pool.address, usdc_to_swap) curve_pool.exchange(1, 0, usdc_to_swap, with_slippage) post_swap_balance = dai.balanceOf(badger.devMultisig.address) dai_to_deposit = post_swap_balance - current_dai_balance print("dai_to_deposit") print(dai_to_deposit) chain.sleep(10) chain.mine() snap.snap() snap.diff_last_two() ## Publish all Txs helper.publish()
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("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 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(): """ First, swap half of the USDC into DAI Deposit USDC portion in to Yearn USDC Vault V2 Deposit DAI portion in to Yearn DAI Vault V2 For the deposits, create small test transactions first """ badger = connect_badger() expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77" assert badger.devMultisig == expectedMultisig safe = ApeSafe(badger.devMultisig.address) helper = ApeSafeHelper(badger, safe) # Fetch tokens for snap + interactions usdc = safe.contract("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48") dai = safe.contract("0x6B175474E89094C44Da98b954EedeAC495271d0F") yDai = safe.contract("0x19D3364A399d251E894aC732651be8B0E4e85001") yUsdc = safe.contract("0x5f18C75AbDAe578b483E5F43f12a39cF75b973a9") usdc_to_deposit = "1500000000000" usdc_to_swap = "1500000000000" ## 1.5 * 10^6 (Million) * 10^6 (Decimals) # TODO: Track the balances of the tokens representing your position here: AAVE USDC (aUSDC), Compound USDC (cUSDC), y3Crv Vault Position (y3Crv) snap = BalanceSnapshotter( [usdc, dai, yDai, yUsdc], [ badger.devMultisig, ], ) snap.snap() current_dai_balance = dai.balanceOf(badger.devMultisig.address) ## NOTE: Swap to DAI with Curve ## Coins[0] == DAI ## Coins[1] == UDC curve_pool = safe.contract("0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7") dai_out = curve_pool.get_dy(1, 0, usdc_to_swap) with_slippage = dai_out * 0.99 print("With slippage") print(with_slippage) usdc.approve(curve_pool.address, usdc_to_swap) curve_pool.exchange(1, 0, usdc_to_swap, with_slippage) post_swap_balance = dai.balanceOf(badger.devMultisig.address) dai_to_deposit = post_swap_balance - current_dai_balance print("dai_to_deposit") print(dai_to_deposit) snap.snap() snap.diff_last_two() ## NOTE: Deposit DAI to Yearn ## TODO: Get balance of DAI to determine how to deposit yDaiVault = helper.contract_from_abi( "0x19D3364A399d251E894aC732651be8B0E4e85001", "yDaiVault", interface.VaultAPI.abi, ) dai.approve(yDaiVault.address, dai_to_deposit) yDaiVault.deposit(dai_to_deposit) snap.snap() snap.diff_last_two() ## NOTE: Deposit USDC to Yearn yUsdcVault = helper.contract_from_abi( "0x5f18C75AbDAe578b483E5F43f12a39cF75b973a9", "yUsdcVault", iinterface.VaultAPI.abi, ) usdc.approve(yUsdcVault.address, usdc_to_deposit) yUsdcVault.deposit(usdc_deposit_amount) ## DONE snap.snap() snap.diff_last_two() ## Publish all Txs helper.publish()
def main(): """ AAVE Compoound y3Crv """ badger = connect_badger() expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77" assert badger.devMultisig == expectedMultisig # AAVE aave = registry.aave_system() tokens = registry.token_system() compound = registry.compound_system() usdc = tokens.erc20_by_key("usdc") dfd = tokens.erc20_by_key("dfd") ausdc = tokens.erc20_by_key("ausdc") cusdc = compound.ctoken("usdc") safe = ApeSafe(badger.devMultisig.address) # TODO: Track the balances of the tokens representing your position here: AAVE USDC (aUSDC), Compound USDC (cUSDC), y3Crv Vault Position (y3Crv) # TODO: Figure out the addresses of these derived tokens # TODO: Track the balances of all the appropriate contracts where the USDC ends up snap = BalanceSnapshotter( [usdc, ausdc, cusdc, dfd, badger.token], [ badger.devMultisig, aave.lendingPool, cusdc, compound.comptroller, badger.badgerTree, ], ) usdc_per_position = Wei("3237154580000 wei") # szabo = 10^6 round_1 = Wei("1000000 wei") round_2 = usdc_per_position - round_1 print(round_1, round_2) lendingPool = safe.contract(aave.lendingPool.address) usdcToken = safe.contract(usdc.address) dfd = safe.contract(dfd.address) rewardsEscrow = safe.contract(badger.rewardsEscrow.address) comptroller = safe.contract(compound.comptroller.address) cusdc = safe.contract(cusdc.address) snap.snap() # Tree Tokens """ Deposit badger from rewardsEscrow, and DFD from self. About 200k tokens. 60k Badger 200k DFD (We have plenty of DIGG) """ # rewardsEscrow.transfer(badger.token, badger.badgerTree, Wei("50000 ether")) # dfd.transfer(badger.badgerTree, Wei("200000 ether")) # # AAVE Deposit Test # usdcToken.approve(aave.lendingPool, round_1) # lendingPool.deposit(usdc, round_1, badger.devMultisig, 0) # Compound Deposit Test """ comptroller.enterMarkets([usdc]) usdc.approve(cUSDC) cUSDC.mint(<usdc amount>) """ # comptroller.enterMarkets([usdc]) # usdcToken.approve(cusdc, round_1) # cusdc.redeem(round_1) # lendingPool.withdraw(usdc, round_1, badger.devMultisig) snap.snap() snap.diff_last_two() # AAVE Deposit Full usdcToken.approve(aave.lendingPool, round_2) lendingPool.deposit(usdc, round_2, badger.devMultisig, 0) # Compound Deposit Full usdcToken.approve(cusdc, round_2) cusdc.mint(round_2) snap.snap() snap.diff_last_two() helper = ApeSafeHelper(badger, safe) helper.publish() """
def main(): """ Transfer badger to recipient, ensuring they are approved as recipient first Use test tx, full tx model Can convert from dollar value Assumes each token is a safeContract """ badger = connect_badger() digg = badger.digg multisig = badger.devMultisig safe = ApeSafe(multisig.address) helper = ApeSafeHelper(badger, safe) rewardsEscrow = helper.contract_from_abi(badger.rewardsEscrow.address, "RewardsEscrow", RewardsEscrow.abi) vesting = helper.contract_from_abi(badger.digg.daoDiggTimelock.address, "SimpleTimelock", SimpleTimelock.abi) # dfd = helper.contract_from_abi(registry.token_address_by_key("dfd"), "IERC20", interface.IERC20.abi) diggToken = helper.contract_from_abi(badger.digg.token.address, "IERC20", interface.IERC20.abi) transfers = [ TransferOp(badger.paymentsMultisig, badger.token, Wei("51222 ether")), # TransferOp(badger.badgerTree, badger.token, Wei("20000 ether")), # TransferOp(badger.badgerTree, dfd, Wei("200000 ether")), # TransferOp(badger.badgerRewardsManager, badger.token, Wei("10000 ether")), # TransferOp(badger.badgerRewardsManager, diggToken, Wei("2 gwei")), ] snap = BalanceSnapshotter( [badger.token, badger.digg.token], [ badger.badgerTree, badger.badgerRewardsManager, badger.devMultisig, badger.rewardsEscrow, badger.paymentsMultisig, ], ) snap.snap() rewards_escrow_tokens = [badger.token] for transfer in transfers: recipient = transfer.recipient token = transfer.token amount = transfer.amount console.print("Transfer", recipient, token, amount) # Transfer from rewards escrow if token.address in rewards_escrow_tokens: if not rewardsEscrow.isApproved(recipient): rewardsEscrow.approveRecipient(recipient) rewardsEscrow.transfer(token, recipient, amount) # Default: Transfer from treasury else: # Unlock from vesting if token.address == badger.digg.token.address: vesting.release(amount) token.transfer(recipient, amount) snap.snap() snap.diff_last_two() 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 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)
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)