async def ecRecover(self, message: str, signature: bytes): w3 = Web3() signable_message = encode_defunct(text=message) checksum_address = w3.hls.account.recover_message(signable_message, signature=signature) return checksum_address
def console(ipc_path: Path, use_ipython: bool=True, env: Dict[str, Any]=None, banner: str=DEFAULT_BANNER) -> Any: """ Method that starts the chain, setups the helios CLI and register the cleanup function. """ if env is None: env = {} # if ipc_path is not found, raise an exception with a useful message if not ipc_path.exists(): raise FileNotFoundError(create_missing_ipc_error_message(ipc_path)) # wait to import web3, because it's somewhat large, and not usually used from helios_web3 import HeliosWeb3 as Web3 from web3 import IPCProvider #w3 = web3.Web3(web3.IPCProvider(ipc_path)) w3 = Web3(IPCProvider(ipc_path)) namespace = merge({'w3': w3}, env) if use_ipython: ipython_shell(namespace, banner)() else: python_shell(namespace, banner)()
def _test_get_accounts_with_receivable_transactions(): w3 = Web3(IPCProvider(ipc_path)) INSTANCE_0 = get_primary_node_private_helios_key(0) new_account_address_hex_1 = w3.personal.newAccount(test_password) new_account_address_hex_2 = w3.personal.newAccount(test_password) tx = [{ 'from': INSTANCE_0.public_key.to_checksum_address(), 'to': new_account_address_hex_1, 'value': 1 }, { 'from': INSTANCE_0.public_key.to_checksum_address(), 'to': new_account_address_hex_1, 'value': 1 }, { 'from': INSTANCE_0.public_key.to_checksum_address(), 'to': new_account_address_hex_2, 'value': 1 }] print("Sending transactions") w3.personal.sendTransactions(tx, 'dev') time.sleep(0.5) print("Getting accounts over all time") accounts_with_receivable = w3.personal.getAccountsWithReceivableTransactions( ) assert (new_account_address_hex_1 in accounts_with_receivable and new_account_address_hex_2 in accounts_with_receivable) print("Getting accounts over short time") accounts_with_receivable = w3.personal.getAccountsWithReceivableTransactions( int(time.time()) - 10) assert (new_account_address_hex_1 in accounts_with_receivable and new_account_address_hex_2 in accounts_with_receivable) print("Getting accounts over future time") accounts_with_receivable = w3.personal.getAccountsWithReceivableTransactions( int(time.time()) + 1) assert (accounts_with_receivable == []) print("Receiving transactions") w3.personal.receiveTransactions(new_account_address_hex_1, test_password) w3.personal.receiveTransactions(new_account_address_hex_2, test_password) time.sleep(0.5) print("Getting accounts over all time") accounts_with_receivable = w3.personal.getAccountsWithReceivableTransactions( ) assert (new_account_address_hex_1 not in accounts_with_receivable and new_account_address_hex_2 not in accounts_with_receivable) print("Getting accounts over short time") accounts_with_receivable = w3.personal.getAccountsWithReceivableTransactions( int(time.time()) - 10) assert (new_account_address_hex_1 not in accounts_with_receivable and new_account_address_hex_2 not in accounts_with_receivable)
def _save_account(self, account, password): w3 = Web3() new_account_json_encrypted = w3.hls.account.encrypt(account.privateKey, password) keyfile_name = "HLS_account_{}".format(account.address) keyfile_path = self.rpc_context.keystore_dir / keyfile_name f = open(str(keyfile_path), "w") f.write(json.dumps(new_account_json_encrypted)) f.close()
async def _unlock_account(self, wallet_address: bytes, password: str): normalized_wallet_address = to_normalized_address(wallet_address) print("Unlocking account {}".format(normalized_wallet_address)) w3 = Web3() keystore = self._get_keystore_for_address(normalized_wallet_address) private_key = w3.hls.account.decrypt(keystore, password) account = w3.hls.account.privateKeyToAccount(private_key) return account
async def sign(self, message: str, wallet_address: bytes, password: str = None): # using EIP 191 https://github.com/ethereum/eth-account/blob/master/eth_account/messages.py normalized_wallet_address = to_normalized_address(wallet_address) account = self._get_unlocked_account_or_unlock_now(wallet_address, password) signable_message = encode_defunct(text = message) w3 = Web3() signed_message = w3.hls.account.sign_message(signable_message, account.privateKey) return signed_message['signature'].hex()
def _test_signing_messages(): w3 = Web3(IPCProvider(ipc_path)) INSTANCE_0 = get_primary_node_private_helios_key(0) message = 'my_cool_message' signature = w3.personal.sign(message, INSTANCE_0.public_key.to_canonical_address(), 'dev') recovered_address = w3.personal.ecRecover(message, signature) assert (recovered_address == INSTANCE_0.public_key.to_checksum_address())
def _test_send_receive_transactions(): w3 = Web3(IPCProvider(ipc_path)) INSTANCE_0 = get_primary_node_private_helios_key(0) new_account_address_hex_1 = w3.personal.newAccount(test_password) new_account_address_hex_2 = w3.personal.newAccount(test_password) tx = [{ 'from': INSTANCE_0.public_key.to_checksum_address(), 'to': new_account_address_hex_1, 'value': 1 }, { 'from': INSTANCE_0.public_key.to_checksum_address(), 'to': new_account_address_hex_1, 'value': 1 }, { 'from': INSTANCE_0.public_key.to_checksum_address(), 'to': new_account_address_hex_2, 'value': 1 }] print("Sending transaction") tx_hashes = w3.personal.sendTransactions(tx, 'dev') # # Make sure the hashes exists # time.sleep(0.5) # If it doesnt exist, it will throw an exception print("Checking transaction exists") tx_from_node = w3.hls.getTransaction(tx_hashes[0]) tx_from_node = w3.hls.getTransaction(tx_hashes[1]) # # Receive the transaction # print("Receiving transactions") tx_hashes_1 = w3.personal.receiveTransactions(new_account_address_hex_1, test_password) tx_hashes_2 = w3.personal.receiveTransactions(new_account_address_hex_2, test_password) # # Make sure the hash exists # time.sleep(0.5) # If it doesnt exist, it will throw an exception print("Checking transactions exists") tx_from_node = w3.hls.getTransaction(tx_hashes_1[0]) tx_from_node = w3.hls.getTransaction(tx_hashes_1[1]) tx_from_node = w3.hls.getTransaction(tx_hashes_2[0])
def _save_account(self, account, password): if not self._account_address_cache_ready.is_set(): raise BaseRPCError("Account cache is still building. Please wait and try again in a moment.") w3 = Web3() new_account_json_encrypted = w3.hls.account.encrypt(account.privateKey, password) keyfile_name = "HLS_account_{}".format(account.address) keyfile_path = self._rpc_context.keystore_dir / keyfile_name f = open(str(keyfile_path), "w") f.write(json.dumps(new_account_json_encrypted)) f.close() self._account_address_cache.add(account.address)
def _test_DOS_with_many_transactions_on_rpc(): # w3 = web3.Web3(web3.IPCProvider(ipc_path)) w3 = Web3(IPCProvider(ipc_path)) w3_instance_1 = Web3(IPCProvider(ipc_path)) start_time = time.time() num_transactions = 0 while True: for instance_num in range(10): to_account = w3.hls.account.create() print("Sending 100 tx from instance {}".format(instance_num)) txs = [] for i in range(100): txs.append({ 'to': to_account.address, 'value': 1, }) num_transactions += 1 signed_block, header_dict, transactions = prepare_and_sign_block( w3, txs, get_primary_node_private_helios_key(instance_num)) response = w3.hls.sendRawBlock(signed_block['rawBlock']) time.sleep(1.1) tx_per_second = (num_transactions / (time.time() - start_time)) print("Transactions per second = {}".format(tx_per_second)) gas_price_instance_0 = w3.hls.gasPrice print('gas_price_instance_0 {}'.format(gas_price_instance_0)) gas_price_instance_1 = w3_instance_1.hls.gasPrice print('gas_price_instance_1 {}'.format(gas_price_instance_1)) time.sleep(4)
def _test_key_management(): w3 = Web3(IPCProvider(ipc_path)) # # Import a raw key # print("Creating new account") new_account = w3.hls.account.create() private_key = new_account.key w3.personal.importRawKey(private_key, test_password) # # List the account # print("Listing accounts") list_of_accounts = w3.personal.listAccounts() assert (new_account.address in list_of_accounts) # # Load the account # print("Unlocking account with incorrect password") with pytest.raises(ValueError): w3.personal.unlockAccount(new_account.address, 'incorrect') print("Unlocking account with correct password") w3.personal.unlockAccount(new_account.address, test_password) # # New Account # new_account_address_hex = w3.personal.newAccount(test_password) # # List the account # print("Listing accounts") list_of_accounts = w3.personal.listAccounts() assert (new_account_address_hex in list_of_accounts) print("Unlocking account with incorrect password") with pytest.raises(ValueError): w3.personal.unlockAccount(new_account_address_hex, 'incorrect') print("Unlocking account with correct password") w3.personal.unlockAccount(new_account_address_hex, test_password)
def _test_simple_responses(): w3 = Web3(IPCProvider(ipc_path)) ping = w3.hls.ping assert (ping == True) block_number = w3.hls.blockNumber( instance(1).public_key.to_checksum_address()) assert (block_number == 0) gas_price = w3.hls.gasPrice assert (gas_price == 1) gas_price = w3.hls.getGasPrice() assert (gas_price == 1) protocol_version = w3.hls.protocolVersion assert (protocol_version == '63') syncing = w3.hls.syncing assert (syncing == False)
async def newAccount(self, password: str): w3 = Web3() new_account = w3.hls.account.create() self._save_account(new_account, password) return to_checksum_address(new_account.address)
async def importRawKey(self, keydata: bytes, password: str): w3 = Web3() new_account = w3.hls.account.privateKeyToAccount(keydata) self._save_account(new_account, password) return to_checksum_address(new_account.address)
def _test_send_receive_transaction_delayed_unlock(): w3 = Web3(IPCProvider(ipc_path)) INSTANCE_0 = get_primary_node_private_helios_key(0) new_account_address_hex = w3.personal.newAccount(test_password) tx = { 'from': INSTANCE_0.public_key.to_checksum_address(), 'to': new_account_address_hex, 'value': 1 } print("Unlocking account") w3.personal.unlockAccount(INSTANCE_0.public_key.to_checksum_address(), 'dev', 5) print("Sending transaction") tx_hash = w3.personal.sendTransaction(tx) # # Make sure the hash exists # time.sleep(0.5) # If it doesnt exist, it will throw an exception print("Checking transaction exists") tx_from_node = w3.hls.getTransaction(tx_hash) # # Unlock account for time that is too short # print("Unlocking account") w3.personal.unlockAccount(INSTANCE_0.public_key.to_checksum_address(), 'dev', 1) time.sleep(1) print("Sending transaction") with pytest.raises(ValueError): w3.personal.sendTransaction(tx) # # Unlock twice, and make sure it replaces the old time with the new one # print("Unlocking account") w3.personal.unlockAccount(INSTANCE_0.public_key.to_checksum_address(), 'dev', 300) w3.personal.unlockAccount(INSTANCE_0.public_key.to_checksum_address(), 'dev', 1) time.sleep(1) print("Sending transaction") with pytest.raises(ValueError): w3.personal.sendTransaction(tx) # # Unlock twice, and make sure it replaces the old time with the new one # print("Unlocking account") w3.personal.unlockAccount(INSTANCE_0.public_key.to_checksum_address(), 'dev', 2) w3.personal.unlockAccount(INSTANCE_0.public_key.to_checksum_address(), 'dev', 300) time.sleep(3) print("Sending transaction") tx_hash = w3.personal.sendTransaction(tx) # # Make sure the hash exists # time.sleep(0.5) # If it doesnt exist, it will throw an exception print("Checking transaction exists") tx_from_node = w3.hls.getTransaction(tx_hash) # # Unlock the account, then lock it before trying to send. Make sure it locked # print("Unlocking account") w3.personal.unlockAccount(INSTANCE_0.public_key.to_checksum_address(), 'dev', 300) w3.personal.lockAccount(INSTANCE_0.public_key.to_checksum_address()) print("Sending transaction") with pytest.raises(ValueError): w3.personal.sendTransaction(tx)