def setup(): """ Connect to badger system, and configure multisig for running transactions in local fork without access to accounts """ # Connect badger system from file badger = connect_badger("deploy-final.json") digg = connect_digg("deploy-final.json") # Sanity check file addresses expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77" assert badger.devMultisig == expectedMultisig # Multisig wrapper multi = GnosisSafe(badger.devMultisig, testMode=True) manager = BadgerRewardsManager.at( "0x5B60952481Eb42B66bdfFC3E049025AC5b91c127") for key in strat_keys: print(key) strategy = badger.getStrategy(key) multi.execute( MultisigTxMetadata( description="Transfer Keeper for {}".format(key)), { "to": strategy.address, "data": strategy.setKeeper.encode_input(manager) }, ) return manager
def main(): badger = connect_badger(badger_config.prod_json, load_keeper=True, load_guardian=True) pendingContentHash = ( "0x346ec98585b52d981d43584477e1b831ce32165cb8e0a06d14d236241b36328e") pendingFile = "rewards-1-" + str(pendingContentHash) + ".json" with open(pendingFile) as f: after_file = json.load(f) pendingRewards = after_file # pendingRewards = fetch_current_rewards_tree(badger) currentRewards = fetch_current_rewards_tree(badger) accounts[0].transfer(badger.keeper, Wei("5 ether")) accounts[0].transfer(badger.guardian, Wei("5 ether")) # Upgrade Rewards Tree multi = GnosisSafe(badger.devMultisig) newLogic = BadgerTree.at("0x0f81D3f48Fedb8E67a5b87A8a4De57766157f19B") multi.execute( MultisigTxMetadata(description="Upgrade Tree", ), { "to": badger.opsProxyAdmin.address, "data": badger.opsProxyAdmin.upgrade.encode_input(badger.badgerTree, newLogic), }, ) assert (badger.badgerTree.hasRole(DEFAULT_ADMIN_ROLE, badger.devMultisig.address) == True) assert badger.badgerTree.getRoleMemberCount(DEFAULT_ADMIN_ROLE) == 1 assert badger.badgerTree.hasRole(ROOT_PROPOSER_ROLE, badger.keeper.address) == True assert badger.badgerTree.getRoleMemberCount(ROOT_PROPOSER_ROLE) == 1 # assert badger.badgerTree.hasRole(ROOT_VALIDATOR_ROLE, badger.guardian.address) == True # assert badger.badgerTree.getRoleMemberCount(ROOT_VALIDATOR_ROLE) == 1 assert badger.badgerTree.hasRole(PAUSER_ROLE, badger.guardian.address) == True assert badger.badgerTree.getRoleMemberCount(PAUSER_ROLE) == 1 assert badger.badgerTree.hasRole(UNPAUSER_ROLE, badger.devMultisig.address) == True assert badger.badgerTree.getRoleMemberCount(UNPAUSER_ROLE) == 1 verify_rewards( badger, pendingRewards["startBlock"], pendingRewards["endBlock"], currentRewards, pendingRewards, )
def upgrade_sett(self, id, newLogic): sett = self.getSett(id) multi = GnosisSafe(self.devMultisig) id = multi.addTx( MultisigTxMetadata(description="Upgrade timelock"), { "to": self.proxyAdmin.address, "data": self.proxyAdmin.upgrade.encode_input(sett, newLogic), }, ) tx = multi.executeTx(id)
def governance_queue_transaction(self, target, signature, data, eta, eth=0) -> str: multi = GnosisSafe(self.devMultisig) id = multi.addTx( MultisigTxMetadata(description="Queue timelock transaction"), { "to": self.governanceTimelock.address, "data": self.governanceTimelock.queueTransaction.encode_input( target, eth, signature, data, eta, ), }, ) multi.executeTx(id) txHash = Web3.solidityKeccak( [ "address", "uint256", "string", "bytes", "uint256", ], [ target, eth, signature, data, eta, ], ).hex() txFilename = "{}.json".format(txHash) with open(os.path.join(TIMELOCK_DIR, txFilename), "w") as f: # Dump tx data to timelock pending tx dir. txData = { "target": target, "eth": eth, "signature": signature, "data": data.hex(), "eta": eta, } f.write(json.dumps(txData, indent=4, sort_keys=True)) return txFilename
def multisig_action(badger: BadgerSystem): multi = GnosisSafe(badger.opsMultisig) key = "native.bDiggBtcb" vault = badger.getSett(key) strategy = badger.getStrategy(key) multi.execute( MultisigTxMetadata(description="Set PoolId"), {"to": strategy.address, "data": strategy.setWantPid.encode_input(104)}, ) assert strategy.wantPid() == 104
def configure_router(self): admin = self.admin multi = GnosisSafe(admin) for strategy in self.strategies.values(): multi.execute( MultisigTxMetadata(description="Add Swap Strategy {}".format( strategy.address)), { "to": strategy.address, "data": self.router.addSwapStrategy.encode_input(strategy.address), }, )
def main(): badger = connect_badger(badger_config.prod_json, load_keeper=True, load_guardian=True) pendingContentHash = "0x07baafa95bf7c39ba948753dda64b2e82854b5a7597f6de9e15c23a96d0bfad3" pendingFile = "rewards-1-" + str(pendingContentHash) + ".json" with open(pendingFile) as f: after_file = json.load(f) pendingRewards = after_file pendingRewards = fetch_current_rewards_tree(badger) currentRewards = fetch_current_rewards_tree(badger) accounts[0].transfer(badger.keeper, Wei("5 ether")) accounts[0].transfer(badger.guardian, Wei("5 ether")) # Upgrade Rewards Tree multi = GnosisSafe(badger.devMultisig) newLogic = BadgerTree.deploy({"from": badger.keeper}) multi.execute( MultisigTxMetadata( description="Upgrade Tree", ), { "to": badger.devProxyAdmin.address, "data": badger.devProxyAdmin.upgrade.encode_input(badger.badgerTree, newLogic), }, ) assert badger.badgerTree.hasRole(DEFAULT_ADMIN_ROLE, badger.devMultisig.address) == True assert badger.badgerTree.getRoleMemberCount(DEFAULT_ADMIN_ROLE) == 1 assert badger.badgerTree.hasRole(ROOT_PROPOSER_ROLE, badger.keeper.address) == True assert badger.badgerTree.getRoleMemberCount(ROOT_PROPOSER_ROLE) == 1 assert badger.badgerTree.hasRole(ROOT_VALIDATOR_ROLE, badger.guardian.address) == True assert badger.badgerTree.getRoleMemberCount(ROOT_VALIDATOR_ROLE) == 1 assert badger.badgerTree.hasRole(PAUSER_ROLE, badger.guardian.address) == True assert badger.badgerTree.getRoleMemberCount(PAUSER_ROLE) == 1 assert badger.badgerTree.hasRole(UNPAUSER_ROLE, badger.devMultisig.address) == True assert badger.badgerTree.getRoleMemberCount(UNPAUSER_ROLE) == 1 # verify_rewards(badger, pendingRewards["startBlock"], pendingRewards["endBlock"], currentRewards, pendingRewards) # push_rewards(badger, pendingContentHash) if rpc.is_active(): test_claims(badger, pendingRewards["startBlock"], pendingRewards["endBlock"], currentRewards, pendingRewards)
def configure_strategies_grant_swapper_role(self, swapper): admin = self.admin multi = GnosisSafe(admin) for strategy in self.strategies.values(): multi.execute( MultisigTxMetadata( description="Add Swapper Role to {}".format(swapper)), { "to": swapper, "data": strategy.grantRole.encode_input(strategy.SWAPPER_ROLE(), swapper), }, )
def main(): """ Transfer badger to recipient, ensuring they are approved as recipient first Use test tx, full tx model Can convert from dollar value """ badger = connect_badger("deploy-final.json") expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77" assert badger.devMultisig == expectedMultisig multi = GnosisSafe(badger.devMultisig) # Parameters recipient = "0xd34C1d3853214bf049B760Ef48A580bfa7A9c8a1" dollars = 50000 # amount = from_dollars(badger, badger.token.address, dollars) amount = Wei("15907.8892303 ether") params = { "dollars": dollars, "recipient": recipient, "amount": amount, "amount_scaled": val(amount), "use_test_payment": False } console.print("===== Pre Transfer =====", style="bold cyan") console.print(params) transfer_badger(recipient, params) console.print("===== Post Transfer =====", style="bold cyan")
def main(): badger = connect_badger("deploy-final.json") multi = GnosisSafe(badger.opsMultisig) account = accounts.load("badger_proxy_deployer") print(account.address) amount = Wei("10000 ether") # print(badger.deployer) # print(badger.token.balanceOf(badger.deployer), badger.token.balanceOf(badger.opsMultisig)) # multi.execute(MultisigTxMetadata(description="Transfer badger to EOA"), { # "to": badger.token.address, # "data": badger.token.transfer.encode_input(account, Wei("10000 ether")) # }) # print(badger.token.balanceOf(account), badger.token.balanceOf(badger.opsMultisig)) # assert badger.token.balanceOf(account) >= amount bBadger = badger.getSett("native.badger") # badger.token.approve(bBadger, amount, {"from": account}) # bBadger.deposit(amount, {"from": account}) # tx_wait() print(bBadger.balanceOf(account)) airdropProxy = AirdropDistributor.at( "0xd17c7effa924b55951e0f6d555b3a3ea34451179") bBadger.transfer(airdropProxy, bBadger.balanceOf(account), {"from": account})
def main(): """ Transfer badger to recipient, ensuring they are approved as recipient first Use test tx, full tx model Can convert from dollar value """ badger = connect_badger("deploy-final.json") expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77" assert badger.devMultisig == expectedMultisig multi = GnosisSafe(badger.devMultisig) # Parameters recipient = "0xD73b03F1Ea390fEB20D879e4DFb83F1245C8D4be" dollars = 45000 # amount = from_dollars(badger, badger.token.address, dollars) amount = Wei("45000 ether") params = { "dollars": dollars, "recipient": recipient, "amount": amount, "amount_scaled": val(amount), "use_test_payment": True } console.print("===== Pre Transfer =====", style="bold cyan") console.print(params) transfer_badger(recipient, params) console.print("===== Post Transfer =====", style="bold cyan")
def configure_bridge(badger: BadgerSystem, bridge: BridgeSystem): """ Configures bridge to use curve token wrapper. """ multi = GnosisSafe(badger.devMultisig) id = multi.addTx( MultisigTxMetadata(description="Set curve token wrapper on adapter",), { "to": bridge.adapter.address, "data": bridge.adapter.setCurveTokenWrapper.encode_input( bridge.curveTokenWrapper.address ), }, ) multi.executeTx(id)
def whitelist_adapter_crv_sett( badger: BadgerSystem, bridge: BridgeSystem, multi: GnosisSafe, settID: str, ): sett = badger.sett_system.vaults[settID] id = multi.addTx( MultisigTxMetadata( description="Approve adapter access to sett {}".format(settID) ), { "to": sett.address, "data": sett.approveContractAccess.encode_input(bridge.adapter.address), }, ) multi.executeTx(id)
def grant_token_locking_permission(badger: BadgerSystem, locker): multi = GnosisSafe(badger.devMultisig) for key in keys: geyser = badger.getGeyser(key) print(key, geyser) multi.execute( MultisigTxMetadata( description="Add Geyser permission for {} to {}".format(key, locker) ), { "to": geyser.address, "data": geyser.grantRole.encode_input(TOKEN_LOCKER_ROLE, locker), }, ) assert geyser.hasRole(TOKEN_LOCKER_ROLE, locker)
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 main(): badger = connect_badger() digg = badger.digg raw = 0.9566301 scaled = raw * 10**18 centralizedOracle = GnosisSafe(digg.centralizedOracle) print("Raw Link") print(raw) print("Formatted for Median Oracle") print(f"{scaled:.0f}") tx = centralizedOracle.execute( MultisigTxMetadata(description="Set Market Data"), { "to": digg.marketMedianOracle.address, "data": digg.marketMedianOracle.pushReport.encode_input(scaled), }, )
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 governance_execute_transaction(self, txFilename): multi = GnosisSafe(self.devMultisig) with open(os.path.join(TIMELOCK_DIR, txFilename), "r") as f: txData = json.load(f) id = multi.addTx( MultisigTxMetadata(description="Execute timelock transaction"), { "to": self.governanceTimelock.address, "data": self.governanceTimelock.executeTransaction.encode_input( txData["target"], txData["eth"], txData["signature"], txData["data"], txData["eta"], ), }, ) if multisig_success(multi.executeTx(id)): os.remove(os.path.join(TIMELOCK_DIR, txFilename))
def main(): """ - Swap tokens according to parameters. Swapped tokens are returned to the swapper - Send test transaction to recipient. Amount is one Wei. - Send full transaction to recipient. Amount is specified amount minus one Wei. """ badger = connect_badger("deploy-final.json") expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77" assert badger.devMultisig == expectedMultisig multi = GnosisSafe(badger.devMultisig) # Parameters recipient = "0x08CeCe3D7e70f13afa91953Ba12b2315598ad7EA" dollars = 65000 # Trade 'at max' Badger for exact amount of end coin max_in = from_dollars(badger, badger.token.address, dollars * 1.2) # exact_amount_out = from_dollars(badger, registry.tokens.wbtc, dollars) exact_amount_out = dollars * 10**6 params = { "dollars": dollars, "recipient": recipient, "token_in": badger.token.address, "token_out": registry.tokens.usdt, "swap_mode": SwapMode.EXACT_AMOUNT_OUT, "max_in": max_in, "max_in_scaled": val(max_in), "exact_amount_out": exact_amount_out, "exact_amount_out_scaled": val(exact_amount_out), "path": [ badger.token.address, registry.tokens.wbtc, registry.tokens.usdc, registry.tokens.usdt ], } console.print("===== Pre Swap =====", style="bold cyan") console.print(params) swap_transfer(recipient, params) console.print("===== Post Swap =====", style="bold cyan")
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(): ''' Queues crv sett upgrades to support depositFor() calls. Also whitelists bridge adapter for crv setts. ''' badger = connect_badger(badger_config.prod_json) bridge = connect_bridge(badger_config.prod_json) multi = GnosisSafe(badger.devMultisig) for settID in CRV_SETTS_TO_UPGRADE: txFilename = queue_upgrade_crv_sett(badger, settID) console.print("[orange] queued up timelock tx {} [/orange]".format(txFilename)) whitelist_adapter_crv_sett(badger, bridge, multi, settID)
def test_signal_token_lock(badger: BadgerSystem, locker): opsMulti = GnosisSafe(badger.opsMultisig) for key in keys: geyser = badger.getGeyser(key) print(key, geyser) opsMulti.execute( MultisigTxMetadata(description="Test signal token lock"), { "to": locker.address, "data": locker.signalTokenLocks.encode_input([ (geyser, badger.token, 1, 1, chain.time()), (geyser, badger.digg.token, 2, 2, chain.time()), ]), }, ) print(geyser.getUnlockSchedulesFor(badger.token)) print(geyser.getUnlockSchedulesFor(badger.digg.token))
def generate(self, badger, multi, key, distributions, start=0, duration=0, end=0): dists = [] for asset, dist in distributions.items(): if dist == 0: continue console.print( "===== Distributions for asset {} on {} =====".format(asset, key), style="bold yellow", ) token = asset_to_address(asset) # == Distribute to Geyser == geyser = badger.getGeyser(key) rewardsEscrow = badger.rewardsEscrow multi = GnosisSafe(badger.devMultisig) opsMulti = GnosisSafe(badger.opsMultisig) print(key, geyser, rewardsEscrow) if rewardsEscrow.isApproved(geyser) == False: multi.execute( MultisigTxMetadata( description="Approve Recipient" ), { "to": rewardsEscrow.address, "data": rewardsEscrow.approveRecipient.encode_input(geyser), }, ) # Approve Geyser as recipient if required if not rewardsEscrow.isApproved(geyser): multi.execute( MultisigTxMetadata( description="Approve StakingRewards " + key, operation="transfer", ), { "to": rewardsEscrow.address, "data": rewardsEscrow.approveRecipient.encode_input(geyser), }, ) numSchedules = geyser.unlockScheduleCount(token) console.print( "Geyser Distribution for {}: {}".format(key, val(dist)), style="yellow", ) dists.append((geyser, asset_to_address(asset), dist, duration, start)) console.log(key, dists) return dists
def main(): """ Connect to badger system, and configure multisig for running transactions in local fork without access to accounts """ # Connect badger system from file badger = connect_badger("deploy-final.json") # Sanity check file addresses expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77" assert badger.devMultisig == expectedMultisig # Multisig wrapper multi = GnosisSafe(badger.devMultisig, testMode=True)
def main(): """ Connect to badger system, and configure multisig for running transactions in local fork without access to accounts """ # Connect badger system from file badger = connect_badger("deploy-final.json") # Sanity check file addresses expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77" assert badger.devMultisig == expectedMultisig # Multisig wrapper multi = GnosisSafe(badger.devMultisig) unlockLogic = UnlockScheduler.at( "0xc63d8a22d18dd42a9de8343fd7c888bda3e7516d") print( unlockLogic.initialize.encode_input(badger.opsMultisig, badger.opsMultisig, badger.guardian, badger.opsMultisig)) # dep2 = accounts.load("badger-deployer-2") unlockProxy = UnlockScheduler.at( "0x1AADc00011939499a4d263d657Dd74b0E1176cF9") # unlockProxy = deploy_proxy( # "UnlockScheduler", # UnlockScheduler.abi, # unlockLogic.address, # badger.opsProxyAdmin.address, # unlockLogic.initialize.encode_input( # badger.opsMultisig, badger.opsMultisig, badger.guardian, badger.opsMultisig # ), # dep2, # ) assert badger.opsProxyAdmin.getProxyImplementation( unlockProxy) == unlockLogic grant_token_locking_permission(badger, unlockProxy) # Test run: Attempt to set unlock schedules test_signal_token_lock(badger, unlockProxy)
def setup_badger(badger: BadgerSystem): # Set paths key = "native.bDiggBtcb" sett = badger.getSett(key) strategy = badger.getStrategy(key) multi = GnosisSafe(badger.opsMultisig) multi.execute( MultisigTxMetadata(description="Set path"), { "to": strategy.address, "data": strategy.setTokenSwapPath.encode_input( registry.pancake.cake, strategy.token0(), [ registry.pancake.cake, registry.tokens.btcb, strategy.token0() ], ), }, ) multi.execute( MultisigTxMetadata(description="Set path"), { "to": strategy.address, "data": strategy.setTokenSwapPath.encode_input( registry.pancake.cake, strategy.token1(), [registry.pancake.cake, registry.tokens.btcb], ), }, )
def transfer(self, token, amount, recipient): rewardsEscrow = self.badger.rewardsEscrow multi = GnosisSafe(self.badger.devMultisig) # Approve Geyser as recipient if required if not rewardsEscrow.isApproved(recipient): multi.execute( MultisigTxMetadata(description="Approve Recipient " + recipient.address), { "to": rewardsEscrow.address, "data": rewardsEscrow.approveRecipient.encode_input(recipient), }, ) before = token.balanceOf(recipient) # Top up Tree # TODO: Make the amount based on what we'll require for the next week id = multi.addTx( MultisigTxMetadata(description="Send {} {} to {}".format( token, amount, recipient)), { "to": rewardsEscrow.address, "data": rewardsEscrow.transfer.encode_input(token, recipient, amount), }, ) tx = multi.executeTx(id) print(tx.call_trace()) after = token.balanceOf(recipient) console.print({"before": before, "after": after}) assert after == before + amount
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 swap_transfer(recipient, params): badger = connect_badger("deploy-final.json") expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77" assert badger.devMultisig == expectedMultisig multi = GnosisSafe(badger.devMultisig) one_wei = Wei("1") end_token = interface.IERC20(params["path"][-1]) console.print("Executing Swap:", style="yellow") console.print(params) # === Approve Uniswap Router on Rewards Escrow if not approved === uniswap = UniswapSystem() assert badger.rewardsEscrow.isApproved(badger.token) assert badger.rewardsEscrow.isApproved(uniswap.router) # === Approve UNI Router for Badger === # Note: The allowance must first be set to 0 id = multi.addTx( MultisigTxMetadata( description="Approve UNI Router to send BADGER", operation="call", callInfo={ 'address': uniswap.router, 'amount': params["max_in"] // 2 }, ), params={ "to": badger.rewardsEscrow.address, "data": badger.rewardsEscrow.call.encode_input( badger.token, 0, badger.token.approve.encode_input(uniswap.router, 0), ), }, ) tx = multi.executeTx(id) # Set proper allowance id = multi.addTx( MultisigTxMetadata( description="Approve UNI Router to send BADGER", operation="call", callInfo={ 'address': uniswap.router, 'amount': params["max_in"] // 2 }, ), params={ "to": badger.rewardsEscrow.address, "data": badger.rewardsEscrow.call.encode_input( badger.token, 0, badger.token.approve.encode_input(uniswap.router, params["max_in"]), ), }, ) tx = multi.executeTx(id) console.print({ "rewardsEscrowBalance": val(badger.token.balanceOf(badger.rewardsEscrow)), "rewardsEscrowRouterAllowance": val(badger.token.allowance(badger.rewardsEscrow, uniswap.router)), "max_in": val(params["max_in"]), }) assert badger.token.balanceOf(badger.rewardsEscrow) > params["max_in"] assert (badger.token.allowance(badger.rewardsEscrow, uniswap.router) >= params["max_in"]) # === Trade Badger for USDC through WBTC === before = end_token.balanceOf(badger.rewardsEscrow) beforeBadger = badger.token.balanceOf(badger.rewardsEscrow) console.print({"EAO": params["exact_amount_out"]}) expiration = chain.time() + 8000 id = multi.addTx( MultisigTxMetadata( description="Trade Badger for output token", operation="call", callInfo={}, ), params={ "to": badger.rewardsEscrow.address, "data": badger.rewardsEscrow.call.encode_input( uniswap.router, 0, uniswap.router.swapTokensForExactTokens.encode_input( params["exact_amount_out"], MaxUint256, params["path"], badger.rewardsEscrow, expiration, ), ), }, ) tx = multi.executeTx(id) print(tx.call_trace()) print(tx.events) printUniTrade( method="swapTokensForExactTokens", params=( params["exact_amount_out"], params["max_in"], params['path'], badger.rewardsEscrow, expiration, ), ) console.log("=== Post Trade ===") console.print({ 'before_input_coin': beforeBadger, 'after_input_coin': badger.token.balanceOf(badger.rewardsEscrow), 'before_output_coin': before, 'post_output_coin': end_token.balanceOf(badger.rewardsEscrow), 'end_token': end_token, 'chain_time_before': chain.time() }) assert end_token.balanceOf( badger.rewardsEscrow) >= params["exact_amount_out"] # === Approve Recipient if not approved === if not badger.rewardsEscrow.isApproved(recipient): id = multi.addTx( MultisigTxMetadata( description="Approve the transfer recipient", operation="approveRecipient", callInfo={}, ), params={ "to": badger.rewardsEscrow.address, "data": badger.rewardsEscrow.approveRecipient.encode_input(recipient), }, ) multi.executeTx(id) assert badger.rewardsEscrow.isApproved(recipient) # === Test Payment to recipient === before = end_token.balanceOf(recipient) id = multi.addTx( MultisigTxMetadata( description="Test payment to recipientt", operation="transfer", callInfo={ "to": recipient, "amount": one_wei }, ), params={ "to": badger.rewardsEscrow.address, "data": badger.rewardsEscrow.transfer.encode_input(end_token, recipient, one_wei), }, ) multi.executeTx(id) after = end_token.balanceOf(recipient) assert after == before + one_wei # === Full Payment to recipient === rest = params["exact_amount_out"] - 1 before = end_token.balanceOf(recipient) id = multi.addTx( MultisigTxMetadata( description="$12k payment to auditor, in USDC", operation="transfer", callInfo={ "to": recipient, "amount": rest }, ), params={ "to": badger.rewardsEscrow.address, "data": badger.rewardsEscrow.transfer.encode_input(end_token, recipient, rest), }, ) multi.executeTx(id) after = end_token.balanceOf(recipient) assert after == before + rest print(before, after, before + params["exact_amount_out"]) console.print("\n[green] ✅ Actions Complete [/green]")
def testTransactions(self): rewardsEscrow = self.badger.rewardsEscrow multi = GnosisSafe(self.badger.devMultisig) opsMulti = GnosisSafe(self.badger.opsMultisig) # Setup accounts[7].transfer(multi.get_first_owner(), Wei("2 ether")) print( "Supplied ETH", accounts.at(multi.get_first_owner(), force=True).balance(), ) badger = self.badger tree = self.badger.badgerTree before = badger.token.balanceOf(tree) top_up = Wei("100000 ether") top_up_digg = Wei("40 gwei") harvest_badger = Wei("30000 ether") harvest_digg = Wei("40 gwei") # Top up Tree # TODO: Make the amount based on what we'll require for the next week id = multi.addTx( MultisigTxMetadata(description="Top up badger tree with Badger"), { "to": rewardsEscrow.address, "data": rewardsEscrow.transfer.encode_input(badger.token, tree, top_up), }, ) tx = multi.executeTx(id) after = badger.token.balanceOf(tree) assert after == before + top_up before = badger.digg.token.balanceOf(tree) tx = multi.execute( MultisigTxMetadata(description="Top up badger tree with DIGG"), { "to": rewardsEscrow.address, "data": rewardsEscrow.transfer.encode_input(badger.digg.token, tree, top_up_digg), }, ) print(tx.call_trace(), before, after) after = badger.digg.token.balanceOf(tree) assert after == before + top_up_digg # multi.execute( # MultisigTxMetadata(description="Top up rewards manager with Badger"), # { # "to": rewardsEscrow.address, # "data": rewardsEscrow.transfer.encode_input( # badger.token, badger.badgerRewardsManager, harvest_badger # ), # }, # ) multi.execute( MultisigTxMetadata(description="Top up rewards manager with DIGG"), { "to": rewardsEscrow.address, "data": rewardsEscrow.transfer.encode_input( badger.digg.token, badger.badgerRewardsManager, harvest_digg), }, ) # grant_token_locking_permission(self.badger, self.badger.unlockScheduler) geyserDists = [] for key, distribution in self.distributions.items(): if distribution.hasGeyserDistribution() == True: print("has geyser distribution", key) dist = GeyserDistributor() dists = dist.generate( badger, multi, key, distributions=distribution.getGeyserDistributions(), start=self.start, duration=self.duration, end=self.end, ) geyserDists.extend(dists) console.log("after " + key, geyserDists) # Add unlock schedeules inbulk console.log(geyserDists) tx = opsMulti.execute( MultisigTxMetadata(description="Signal unlock schedules"), { "to": badger.unlockScheduler.address, "data": badger.unlockScheduler.signalTokenLocks.encode_input( geyserDists), }, ) print(tx.call_trace()) tokens = [self.badger.token.address, self.badger.digg.token.address] for key in geyser_keys: print(key) geyser = self.badger.getGeyser(key) for token in tokens: print(token) console.log( "{} schedules for {}".format(token, key), geyser.getUnlockSchedulesFor(token), )