def main(): migrator = None bridge_connector = None rewards_liquidator = None migration_executor_addr = None if c.wh_migrator_addr is None: log.nb('Wormhole migration components are not yet deployed') if c.get_is_live(): warn_live() return executor = accounts[0] (bridge_connector, rewards_liquidator, migrator) = deploy_wormhole_migration_components( executor, {'from': executor}) migration_executor_addr = executor.address else: log.ok('Wormhole migration components are already deployed') migrator = AnchorVaultMigrator.at(c.wh_migrator_addr) bridge_connector = BridgeConnectorWormhole.at(c.bridge_connector_addr) rewards_liquidator = RewardsLiquidator.at(c.rewards_liquidator_addr) migration_executor_addr = c.wh_migration_executor_addr vault = Contract.from_abi('AnchorVault', c.vault_proxy_addr, AnchorVault.abi) log.ok('AnchorVaultMigrator', migrator.address) assert_equals(' executor', migrator.executor(), migration_executor_addr) assert_equals(' state', migrator.state(), 0) assert_equals(' pre_migration_admin', migrator.pre_migration_admin(), vault.admin()) if c.get_is_live(): warn_live() return with chain_snapshot(): executor = accounts.at(migration_executor_addr, force=True) migrate_wormhole(migrator, executor, bridge_connector, rewards_liquidator) check_vault( vault_proxy_addr=c.vault_proxy_addr, vault_impl_addr=c.vault_impl_addr, beth_token_addr=c.beth_token_addr, bridge_connector_addr=bridge_connector.address, rewards_liquidator_addr=rewards_liquidator.address, insurance_connector_addr=c.insurance_connector_addr, terra_rewards_distributor_addr=c.terra_rewards_distributor_addr, vault_admin=c.dev_multisig_addr, vault_liquidations_admin=c.vault_liquidations_admin_addr, rew_liq_max_steth_eth_price_difference_percent=c. rew_liq_max_steth_eth_price_difference_percent, rew_liq_max_eth_usdc_price_difference_percent=c. rew_liq_max_eth_usdc_price_difference_percent, rew_liq_max_usdc_ust_price_difference_percent=c. rew_liq_max_usdc_ust_price_difference_percent, rew_liq_max_steth_ust_price_difference_percent=c. rew_liq_max_steth_ust_price_difference_percent)
def push(self): """Push todo to gist.github.com""" github = Github() gist_id = GistId().get() token = GithubToken().get() github.login(token) if not self.todo.name: name = "Todo" else: name = self.todo.name files = { name: { "content": self.todo_content } } log.info( "Pushing '%s' to https://gist.github.com/%s .." % (name, gist_id) ) response = github.edit_gist(gist_id, files=files) if response.status_code == 200: log.ok("Pushed success.") elif response.status_code == 401: log.warning("Github token out of date, empty the old token") GithubToken().save('') # empty the token! self.push() # and repush else: log.error("Pushed failed. %d" % response.status_code)
def get(self): """ call this method to get a token:: token = GithubToken().get() what the get() does: 1) read from "~/.todo/token" 2) check if the token read is empty. (yes)-> 1) if empty, ask user for user&passwd to access api.github.com 2) fetch the token, set to this instance and store it. 3) return the token (a string) """ if self.is_empty: user = ask_input.text("Github user:"******"Password for %s:" % user) log.info("Authorize to github.com..") response = Github().authorize(user, password) if response.status_code == 201: # 201 created log.ok("Authorized success.") # get token from dict token = response.json()["token"] self.save(token) else: log.error("Authorization failed. %d" % response.status_code) return self.content
def deploy_wormhole_migration_components(executor, tx_params): log.h('Deploying Wormhole migration components...') bridge_connector = BridgeConnectorWormhole.deploy(c.wormhole_token_bridge_addr, tx_params) log.ok('BridgeConnectorWormhole', bridge_connector.address) print() rewards_liquidator = RewardsLiquidator.deploy( c.vault_proxy_addr, c.dev_multisig_addr, int(c.rew_liq_max_steth_eth_price_difference_percent * 10**18 / 100), int(c.rew_liq_max_eth_usdc_price_difference_percent * 10**18 / 100), int(c.rew_liq_max_usdc_ust_price_difference_percent * 10**18 / 100), int(c.rew_liq_max_steth_ust_price_difference_percent * 10**18 / 100), tx_params ) log.ok('RewardsLiquidator', rewards_liquidator.address) print() migrator = AnchorVaultMigrator.deploy( rewards_liquidator, bridge_connector, tx_params ) log.ok('AnchorVaultMigrator', migrator.address) vault = Contract.from_abi('AnchorVault', c.vault_proxy_addr, AnchorVault.abi) assert_equals(' executor', migrator.executor(), executor.address) assert_equals(' state', migrator.state(), 0) assert_equals(' pre_migration_admin', migrator.pre_migration_admin(), vault.admin()) return (bridge_connector, rewards_liquidator, migrator)
def pull(self, name=None): """Pull todo from remote gist server""" if not name: # if not name figured out if self.todo.name: name = self.todo.name # use the todo.txt's name else: log.error("Please tell me todo's name to pull.") github = Github() gist_id = GistId().get() resp = github.get_gist(gist_id) if resp.status_code != 200: log.error("Pull failed.%d" % resp.status_code) dct = resp.json() # get out the data u_name = name.decode("utf8") # decode to unicode # Note that data back from github.com is unicode if u_name not in dct["files"]: log.error("File '%s' not in gist: %s" % (name, gist_id)) u_url = dct["files"][u_name]["raw_url"] url = u_url.encode("utf8") response = requests.get(url) if response.status_code == 200: todo_content = response.text.encode("utf8") self.todo_txt.write(todo_content) log.ok("Pulled success to file '%s'" % self.todo_txt.path) else: log.error("Failed to pull file from %s" % url)
def run(browser, account, is_first=True): log.status("Total points: {}".format(browser.execute_script(""" return document.getElementsByClassName("points_count")[0].innerHTML; """))) sleep(5) if is_first: log.status("Opening facebook post like page...") browser.execute_script(""" document.querySelector("a[href='/free_points/facebook_post_like']").click(); """) log.ok("Done.") sleep(5) window_before = browser.window_handles[0] try: browser.execute_script(""" document.querySelector(".single_like_button").click(); """) except: browser.execute_script(""" location.reload(); """) run(browser, account, is_first) window_after = browser.window_handles[1] browser.switch_to_window(window_after) if is_first: try: browser.execute_script(""" var btns = document.getElementById("mobile_login_bar").getElementsByTagName("a"); if (btns[0].innerHTML == "Log In") { btns[0].click(); } else { btns[1].click(); } """) sleep(2) browser.execute_script(""" document.getElementById("m_login_email").value = "{}"; document.getElementById("m_login_password").value = "{}"; document.querySelector("button[value='Log In']").click(); """.format(account["email"], account["password"])) sleep(3) except: browser.close() browser.switch_to_window(window_before) run(browser, account, is_first=True) try: browser.execute_script(""" document.querySelector("a[data-sigil*='like-reaction-flyout']").click() """) except: pass sleep(5) browser.close() browser.switch_to_window(window_before) run(browser, account, is_first=False)
def get(self, answer=None): # add answer to figure which approach to go """ call this method to get a gist_id:: gist_id = GistId().get() what the get() dose: 1) read the gist_id from file "~/.todo/gist_id" 2) check if the gist_id if empty (yes)-> 1) if the gist_id is empty, ask user to input it or new a gist directly. 2) save the new gist_id 3) return the gist_id """ if self.is_empty: print "Tell me the gist's id you want to push to:" print " 1. New a gist right now." print " 2. Let me input a gist's id." if answer is None: answer = ask_input.text("Input your answer(1/2):") if answer == '2': self.save(ask_input.text("Gist id:")) elif answer == '1': # new a gist todo_content = TodoTxt().read() todo = parser.parse(todo_content) if not todo.name: name = "Todo" else: name = todo.name files = { name: { "content": todo_content } } resp = None github = Github() token = GithubToken().get() github.login(token) # need to login log.info("Create a new gist..") resp = github.create_gist(files=files, description="Todo") if resp.status_code == 201: dct = resp.json() html_url = dct["html_url"].encode("utf8") log.ok("Create success:%s ," "pushed at file '%s'" % (html_url, name)) self.save(dct["id"]) sys.exit() elif resp.status_code == 401: log.warning("Github access denied, empty the old token") GithubToken().save('') # empty the token! # and re create self.get(answer='1') else: log.error("Create gist failed. %d" % resp.status_code) else: # exit if else input log.error("Invalid answer.") return self.content
def check_vault(vault_proxy_addr, vault_impl_addr, beth_token_addr, bridge_connector_addr, rewards_liquidator_addr, insurance_connector_addr, terra_rewards_distributor_addr, vault_admin, vault_liquidations_admin, rew_liq_max_steth_eth_price_difference_percent, rew_liq_max_eth_usdc_price_difference_percent, rew_liq_max_usdc_ust_price_difference_percent, rew_liq_max_steth_ust_price_difference_percent): # Needed to properly decode LogMessagePublished events of Wormhole bridge wormhole = interface.Wormhole(c.wormhole_addr) vault_proxy = AnchorVaultProxy.at(vault_proxy_addr) vault_impl = AnchorVault.at(vault_impl_addr) vault = Contract.from_abi('AnchorVault', vault_proxy.address, AnchorVault.abi) beth_token = bEth.at(beth_token_addr) ust_token = interface.WormholeWrappedToken(c.ust_token_addr) steth_token = interface.Lido(c.steth_token_addr) bridge_connector = BridgeConnectorWormhole.at(bridge_connector_addr) rewards_liquidator = RewardsLiquidator.at(rewards_liquidator_addr) insurance_connector = InsuranceConnector.at(insurance_connector_addr) terra_rewards_distributor_wh_encoded_addr = wh.encode_addr( terra_rewards_distributor_addr) log.ok('vault admin', vault_admin) print() log.ok('stETH', steth_token.address) log.ok('UST', ust_token.address) print() log.ok('bETH', beth_token.address) assert_equals(' admin', beth_token.admin(), vault_admin) assert_equals(' minter', beth_token.minter(), vault_proxy) # assert_equals(' totalSupply', beth_token.totalSupply(), 0) assert_equals(' name', beth_token.name(), 'bETH') assert_equals(' symbol', beth_token.symbol(), 'bETH') assert_equals(' decimals', beth_token.decimals(), 18) print() log.ok('AnchorVault impl', vault_impl.address) assert_equals(' admin', vault_impl.admin(), ZERO_ADDRESS) assert_equals(' bridge_connector', vault_impl.bridge_connector(), ZERO_ADDRESS) assert_equals(' rewards_liquidator', vault_impl.rewards_liquidator(), ZERO_ADDRESS) assert_equals(' insurance_connector', vault_impl.insurance_connector(), ZERO_ADDRESS) print() no_liquidation_interval = 0 restricted_liquidation_interval = 26 * 60 * 60 log.ok('AnchorVaultProxy', vault_proxy.address) assert_equals(' proxy_getAdmin', vault_proxy.proxy_getAdmin(), vault_admin) assert_equals(' proxy_getIsOssified', vault_proxy.proxy_getIsOssified(), False) assert_equals(' implementation', vault_proxy.implementation(), vault_impl) assert_equals(' admin', vault.admin(), vault_admin) assert_equals(' beth_token', vault.beth_token(), beth_token.address) assert_equals(' steth_token', vault.steth_token(), steth_token.address) assert_equals(' bridge_connector', vault.bridge_connector(), bridge_connector.address) assert_equals(' rewards_liquidator', vault.rewards_liquidator(), rewards_liquidator.address) assert_equals(' insurance_connector', vault.insurance_connector(), insurance_connector.address) assert_equals(' vault_liquidations_admin', vault.liquidations_admin(), vault_liquidations_admin) assert_equals(' no_liquidation_interval', vault.no_liquidation_interval(), no_liquidation_interval) assert_equals(' restricted_liquidation_interval', vault.restricted_liquidation_interval(), restricted_liquidation_interval) assert_equals(' anchor_rewards_distributor', vault.anchor_rewards_distributor(), terra_rewards_distributor_wh_encoded_addr) assert_equals(' get_rate', vault.get_rate(), 10**18) print() log.ok('BridgeConnectorWormhole', bridge_connector.address) assert_equals(' wormhole_token_bridge', bridge_connector.wormhole_token_bridge(), c.wormhole_token_bridge_addr) print() log.ok('RewardsLiquidator', rewards_liquidator.address) assert_equals(' admin', rewards_liquidator.admin(), vault_admin) assert_equals(' vault', rewards_liquidator.vault(), vault_proxy.address) assert_equals( ' max_steth_eth_price_difference_percent', rewards_liquidator.max_steth_eth_price_difference_percent(), int(rew_liq_max_steth_eth_price_difference_percent * 10**18 / 100)) assert_equals( ' max_eth_usdc_price_difference_percent', rewards_liquidator.max_eth_usdc_price_difference_percent(), int(rew_liq_max_eth_usdc_price_difference_percent * 10**18 / 100)) assert_equals( ' max_usdc_ust_price_difference_percent', rewards_liquidator.max_usdc_ust_price_difference_percent(), int(rew_liq_max_usdc_ust_price_difference_percent * 10**18 / 100)) assert_equals( ' max_steth_ust_price_difference_percent', rewards_liquidator.max_steth_ust_price_difference_percent(), int(rew_liq_max_steth_ust_price_difference_percent * 10**18 / 100)) print() log.ok('InsuranceConnector', insurance_connector.address) print() log.ok('liquidations admin', vault_liquidations_admin) log.ok( 'no liquidation interval', f'{no_liquidation_interval} sec ({no_liquidation_interval / 3600} hrs)' ) log.ok( 'restricted liquidation interval', f'{restricted_liquidation_interval} sec ({restricted_liquidation_interval / 3600} hrs)' ) log.ok('terra rewards distributor', terra_rewards_distributor_wh_encoded_addr) print() if c.get_is_live(): print('Running on a live network, cannot run further checks.') print('Run on a mainnet fork to do this.') return log.h('Performing AnchorVault fork checks') with chain_snapshot(): if not vault.can_deposit_or_withdraw(): log.h('Selling rewards...') tx = vault.collect_rewards( {'from': accounts.at(vault_liquidations_admin, force=True)}) # tx.info() assert_equals('AnchorVault.can_deposit_or_withdraw', vault.can_deposit_or_withdraw(), True) beth_supply_before = beth_token.totalSupply() bridge_balance_before = beth_token.balanceOf( c.wormhole_token_bridge_addr) log.ok('bETH total supply', beth_supply_before) log.ok('bridge bETH balance', bridge_balance_before) log.h('Obtaining stETH...') holder_1 = accounts[0] holder_2 = accounts[1] steth_token.submit(ZERO_ADDRESS, { 'from': holder_1, 'value': 3 * 10**18 }) assert steth_token.balanceOf(holder_1) > 0 log.ok('holder_1 balance', steth_token.balanceOf(holder_1)) assert_equals('holder_2 balance', steth_token.balanceOf(holder_2), 0) log.h('Submitting stETH...') terra_recipient_1 = '0x0000000000000000000000008badf00d8badf00d8badf00d8badf00d8badf00d' steth_token.approve(vault, 2 * 10**18, {'from': holder_1}) tx = vault.submit(2 * 10**18, terra_recipient_1, b'', vault.version(), {'from': holder_1}) # tx.info() assert 'Deposited' in tx.events assert tx.events['Deposited'][0].address == vault.address log.ok('Deposited event emitted') deposited_amount = tx.events['Deposited']['amount'] assert deposited_amount >= 1.999 * 10**18 and deposited_amount <= 2 * 10**18 log.ok('Deposited.amount', deposited_amount) assert_equals('holder_1 balance', beth_token.balanceOf(holder_1), 0) beth_supply = beth_token.totalSupply() assert beth_supply == beth_supply_before + deposited_amount assert_equals('bETH total supply', beth_supply, beth_supply_before + deposited_amount) bridge_balance = beth_token.balanceOf(c.wormhole_token_bridge_addr) assert bridge_balance == bridge_balance_before + deposited_amount assert_equals('bridge bETH balance', bridge_balance, bridge_balance_before + deposited_amount) assert 'LogMessagePublished' in tx.events assert tx.events['LogMessagePublished'][0].address == c.wormhole_addr log.ok('LogMessagePublished event emitted') expected_payload = wh.assemble_transfer_payload( token_address=beth_token.address, normalized_amount=wh.normalize_amount(deposited_amount, 18), to_address=terra_recipient_1, token_chain_id=wh.CHAIN_ID_ETHERUM, to_chain_id=wh.CHAIN_ID_TERRA, fee=0) assert tx.events['LogMessagePublished'][0][ 'payload'] == expected_payload log.ok('LogMessagePublished.payload', expected_payload) log.h('Submitting ETH...') bridge_balance_before = bridge_balance beth_supply_before = beth_supply terra_recipient_2 = '0x000000000000000000000000deadbeefdeadbeefdeadbeefdeadbeefdeadbeef' tx = vault.submit(1 * 10**18, terra_recipient_2, b'', vault.version(), { 'from': holder_2, 'value': 1 * 10**18 }) # tx.info() assert 'Deposited' in tx.events assert tx.events['Deposited'][0].address == vault.address log.ok('Deposited event emitted') deposited_amount = tx.events['Deposited']['amount'] assert deposited_amount >= 0.999 * 10**18 and deposited_amount <= 1 * 10**18 log.ok('Deposited.amount', deposited_amount) assert_equals('holder_2 balance', beth_token.balanceOf(holder_2), 0) beth_supply = beth_token.totalSupply() assert beth_supply == beth_supply_before + deposited_amount assert_equals('bETH total supply', beth_supply, beth_supply_before + deposited_amount) bridge_balance = beth_token.balanceOf(c.wormhole_token_bridge_addr) assert bridge_balance == bridge_balance_before + deposited_amount assert_equals('bridge bETH balance', bridge_balance, bridge_balance_before + deposited_amount) assert 'LogMessagePublished' in tx.events assert tx.events['LogMessagePublished'][0].address == c.wormhole_addr log.ok('LogMessagePublished event emitted') expected_payload = wh.assemble_transfer_payload( token_address=beth_token.address, normalized_amount=wh.normalize_amount(deposited_amount, 18), to_address=terra_recipient_2, token_chain_id=wh.CHAIN_ID_ETHERUM, to_chain_id=wh.CHAIN_ID_TERRA, fee=0) assert tx.events['LogMessagePublished'][0][ 'payload'] == expected_payload log.ok('LogMessagePublished.payload', expected_payload) log.h('Rebasing stETH by 0.02%...') lido_oracle_report(steth_rebase_percent=0.02) assert_equals('AnchorVault.can_deposit_or_withdraw', vault.can_deposit_or_withdraw(), False) log.h('Selling rewards...') liquidations_admin = accounts.at(vault.liquidations_admin(), force=True) tx = vault.collect_rewards({'from': liquidations_admin}) # tx.info() assert 'RewardsCollected' in tx.events assert tx.events['RewardsCollected'][0].address == vault.address log.ok('RewardsCollected event emitted') ust_amount = tx.events['RewardsCollected'][0]['ust_amount'] assert ust_amount > 0 log.ok('RewardsCollected.ust_amount', ust_amount) assert 'LogMessagePublished' in tx.events assert tx.events['LogMessagePublished'][0].address == c.wormhole_addr log.ok('LogMessagePublished event emitted') expected_payload = wh.assemble_transfer_payload( # See https://github.com/certusone/wormhole/blob/aff369f/ethereum/contracts/bridge/Bridge.sol#L97-L103 # For wrapped tokens, the "token address" field is set to the address of the token on its native chain token_address=str(ust_token.nativeContract()), normalized_amount=wh.normalize_amount(ust_amount, ust_token.decimals()), to_address=terra_rewards_distributor_addr, token_chain_id=ust_token.chainId(), to_chain_id=wh.CHAIN_ID_TERRA, fee=0) assert tx.events['LogMessagePublished'][0][ 'payload'] == expected_payload log.ok('LogMessagePublished.payload', expected_payload)