def get_privatekey(self, keystore_data, password): try: key_bytes = keys.decode_keystore_json(keystore_data, password) key_hex = self.web3.toHex(key_bytes) except Exception as err: return {'code': 102, 'error': str(err)}, None return None, key_hex
def get_privkey(filename, passwd): with open(filename) as f: import json data = json.load(f) from ethereum.tools.keys import decode_keystore_json from rlp.utils import encode_hex return encode_hex(decode_keystore_json(data, passwd))
def test_key( filename, testname, testdata, ): logger.debug('running test:%r in %r' % (testname, filename)) assert keys.check_keystore_json(testdata["json"]) privkey = keys.decode_keystore_json(testdata["json"], testdata["password"]) assert utils.encode_hex(privkey) == testdata["priv"]
def __init__(self, keyfile, passfile): with open(keyfile) as data_file: data = json.load(data_file) with open(passfile) as f: password = f.read().strip('\n') privkey_bin = decode_keystore_json(data, password) self.private_key = PrivateKey(privkey_bin)
def get_private_key(keystorePtah, password): """ 获取私钥 :param keystorePtah: keystore钱包json文件路径 :param password: 钱包密码 :return:钱包私钥 """ privateKey = keys.decode_keystore_json(json.load(open(keystorePtah)), password) return privateKey
def load_keyfile(keyfile, password): """加载钱包keyfile :param keyfile: :param password: 密码 :param filename: keyfile路径 """ with open(keyfile, 'r') as f: keystore = json.loads(f.read()) if not keys.check_keystore_json(keystore): raise ValueError('invalid keyfile format') return keys.decode_keystore_json(keystore, password)
def unlock(self, password): """Unlock the account with a password. If the account is already unlocked, nothing happens, even if the password is wrong. :raises: :exc:`ValueError` (originating in ethereum.keys) if the password is wrong (and the account is locked) """ if self.locked: self._privkey = keys.decode_keystore_json(self.keystore, password) self.locked = False self.address # get address such that it stays accessible after a subsequent lock
def unlock(self, password): """Unlock the account with a password. If the account is already unlocked, nothing happens, even if the password is wrong. Raises: ValueError: (originating in ethereum.keys) if the password is wrong (and the account is locked) """ if self.locked: self._privkey = keys.decode_keystore_json(self.keystore, password) self.locked = False self.address # get address such that it stays accessible after a subsequent lock
def retrieve_private_key(password, key_file): if os.path.isfile(key_file): with open(key_file) as f: try: keystore_json = json.load(f) keystore_json['id'] = keystore_json['id'] key = ethkeys.decode_keystore_json(keystore_json, password) if not key: raise Exception return key except Exception: logging.error('Error retrieving private key.') sys.exit(1) else: logging.error("Keystore file '{}' inexistent.".format(key_file)) sys.exit(1)
def attempt(w, pw, verbose): if not isinstance(pw, str): pw = ''.join(str(i) for i in pw) if verbose > 0: print(pw) try: if 'encseed' in w: seed = getseed(w['encseed'], pw, w['ethaddr']) else: seed = decode_keystore_json(w, pw) if seed: print("""\n\nYour seed is:\n%s\n\nYour password is:\n%s\n""" % (encode_hex(seed), pw)) raise PasswordFoundException() except ValueError: return None
def get_private_key(key_path, password_path=None): """Open a JSON-encoded private key and return it If a password file is provided, uses it to decrypt the key. If not, the password is asked interactively. Raw hex-encoded private keys are supported, but deprecated.""" assert key_path, key_path if not os.path.exists(key_path): log.fatal("%s: no such file", key_path) return None if not check_permission_safety(key_path): log.fatal("Private key file %s must be readable only by its owner.", key_path) return None if password_path and not check_permission_safety(password_path): log.fatal("Password file %s must be readable only by its owner.", password_path) return None with open(key_path) as keyfile: private_key = keyfile.readline().strip() if is_hex(private_key) and len(decode_hex(private_key)) == 32: log.warning("Private key in raw format. Consider switching to JSON-encoded") else: keyfile.seek(0) try: json_data = json.load(keyfile) if password_path: with open(password_path) as password_file: password = password_file.readline().strip() else: password = getpass.getpass("Enter the private key password: "******"Invalid private key format or password!") return None return private_key
def load_keyfile(keyfile, password): """Loads a private key from the given keyfile. :param str keyfile: keyfile path :param str password: keyfile password :returns: private key :rtype: str :raises: NotImplementedError: when using Python 3 :raises: IOError: if the file is not found :raises: ValueError: if the keyfile format is invalid """ if sys.version_info.major >= 3: raise NotImplementedError('keyfile usage is only supported in python2') with open(keyfile, 'r') as f: keystore = json.load(f) from ethereum.tools import keys as keys if not keys.check_keystore_json(keystore): raise ValueError('invalid keyfile format') return keys.decode_keystore_json(keystore, password)
def load_keyfile(keyfile, password): """Loads a private key from the given keyfile. :param str keyfile: keyfile path :param str password: keyfile password :returns: private key :rtype: str :raises: NotImplementedError: when using Python 3 :raises: IOError: if the file is not found :raises: ValueError: if the keyfile format is invalid """ if sys.version_info.major >= 3: raise NotImplementedError('keyfile usage is only supported in python2') with open(keyfile, 'r') as f: keystore = json.load(f) from ethereum.tools import keys as keys if not keys.check_keystore_json(keystore): raise ValueError('invalid keyfile format') return keys.decode_keystore_json(keystore, password)
def _submit_transaction(self, data_value): amount = 0 tx_count = self.web3.eth.getTransactionCount(self.from_addr) tx_gasprice = self.web3.eth.gasPrice # tx_startgas = self.web3.eth.estimateGas({ # 'to': self.to_addr, # 'from': self.from_addr, # 'value': amount, # 'data': data_value, # }) tx_startgas = 90000 tx = Transaction( nonce=tx_count, gasprice=tx_gasprice, startgas=tx_startgas, to=self.web3.toAscii(self.to_addr), value=amount, data=self.web3.toAscii(data_value) ) key_file_json = json.loads(open(self.key_file).read()) keys = decode_keystore_json(key_file_json, self.key_pass) tx.sign(keys) tx_hex_signed = self.web3.toHex(encode(tx)) tx_id = self.web3.eth.sendRawTransaction(tx_hex_signed) print('Transaction Hash: ' + tx_id) return tx_id
def privatekey(self, account_addr, password): keystore = self.keystore(account_addr) key_bytes = keys.decode_keystore_json(keystore, password) key_hex = self.web3.toHex(key_bytes) return key_hex
def generateTX(self): try: address = self.textbox_receiver.text() if not len(address) == 42: raise Exception( 'Address must have length 42 (beginning with "0x")') unitconv = {'wei (atto)':1, 'babbage (femto)':10**3, 'lovelace (pico)':10**6,\ 'shannon (nano)':10**9, 'szabo (micro)':10**12, 'finney (milli)':10**15,\ 'ether':10**18} unit = self.combobox_unit.currentText() amount = int( float(self.textbox_amount.text().replace(',', '.')) * unitconv[unit]) if amount < 0: raise Exception('Amount must be greated than 0') nonce = int(self.textbox_nonce.text()) if nonce < 0: raise Exception('Nonce must be greated than 0') gas_price = int(self.textbox_gasprice.text()) if gas_price < 0: raise Exception('Gas price must be greated than 0') gas = int(self.textbox_gas.text()) if gas < 0: raise Exception('Gas amount must be greated than 0') #data = self.textbox_data.text().encode('utf-8') data = self.textbox_data.text() # try to get data from base16 input try: ldata = ceil(len(data[2:]) / 2) if data[:2] == '0x' else ceil(len(data) / 2) data = int(data, 16).to_bytes(ldata, 'big') except ValueError as e: data = data.encode('utf-8') # from which field do we get the networkid? if (self.radiobutton_networkid_textbox.isChecked()): # textbox networkid = int(self.textbox_networkid.text()) else: # drop down menu networkid = int(self.combobox_networkid.currentText()[:2]) if networkid < 0: raise Exception('Network ID must be greated than 0') # how to retrieve the private key? if (self.radiobutton_key.isChecked()): # directly priv_key = self.textbox_privatekey.text() else: # keystore keystorefile = self.textbox_keystore.text() keystorepw = self.textbox_keystore_pw.text() with open(keystorefile, 'r') as kf: jdata = jload(kf) priv_key = keys.decode_keystore_json(jdata, keystorepw) priv_key = self.safeBytesToHex(priv_key, 64) if not len(priv_key) in [64, 66]: raise Exception( 'Invalid private key length: got {}, expected 64 or 66'. format(len(priv_key))) #address_sender = hex(int.from_bytes(keys.privtoaddr(priv_key), 'big')) address_sender = self.safeBytesToHex(keys.privtoaddr(priv_key), 40) self.label_address_sender.setText(address_sender) priv_key = int(priv_key, 16) # generate the tx data tx = Transaction(nonce, gas_price, gas, address, amount, data) tx_signed = tx.sign(priv_key) tx_data = hex(int.from_bytes(rlpencode(tx_signed), 'big')) self.textbrowser_result.setPlainText(str(tx_data)) except Exception as e: print(dir(e)) self.textbrowser_result.setPlainText('ERROR: \n' + str(e))
def __init__(self, keyfile='', password='', private_key='', provider='', provider_endpoint_uri='http://159.89.240.147:8545', contract_address=KIN_CONTRACT_ADDRESS, contract_abi=KIN_ABI): """Create a new instance of the KIN SDK. The SDK needs a JSON-RPC provider, contract definitions and the wallet private key. The user may pass either a provider or a provider endpoint URI, in which case a default `web3:providers:HTTPProvider` will be created. If private_key is not provided, the SDK can still be used in "anonymous" mode with only the following functions available: - get_address_ether_balance - get_transaction_status - monitor_ether_transactions :param str private_key: a private key to initialize the wallet with. If either private key or keyfile are not provided, the wallet will not be initialized and methods needing the wallet will raise exception. :param str keyfile: the path to the keyfile to initialize to wallet with. Usually you will also need to supply a password for this keyfile. :param str password: a password for the keyfile. :param provider: JSON-RPC provider to work with. If not provided, a default `web3:providers:HTTPProvider` is used, inited with provider_endpoint_uri. :type provider: :class:`web3:providers:BaseProvider` :param str provider_endpoint_uri: a URI to use with a default HTTPProvider. If not provided, a default endpoint will be used. :param str contract_address: the address of the token contract. If not provided, a default KIN contract address will be used. :param dict contract_abi: The contract ABI. If not provided, a default KIN contract ABI will be used. :returns: An instance of the SDK. :rtype: :class:`~kin.TokenSDK` :raises: :class:`~kin.exceptions.SdkConfigurationError` if some of the configuration parameters are invalid. """ if not provider and not provider_endpoint_uri: raise SdkConfigurationError( 'either provider or provider endpoint must be provided') if not contract_address: raise SdkConfigurationError('token contract address not provided') try: validate_address(contract_address) except ValueError: raise SdkConfigurationError('invalid token contract address') if not contract_abi: raise SdkConfigurationError('token contract abi not provided') try: validate_abi(contract_abi) except Exception as e: raise SdkConfigurationError('invalid token contract abi: ' + str(e)) if provider: self.web3 = Web3(provider) else: self.web3 = Web3(HTTPProvider(provider_endpoint_uri)) if not self.web3.isConnected(): raise SdkConfigurationError('cannot connect to provider endpoint') self.token_contract = self.web3.eth.contract( contract_address, abi=contract_abi, ContractFactoryClass=Contract) self.private_key = None self.address = None if keyfile: with open(keyfile, 'r') as f: try: keystore = json.load(f) except Exception as e: raise SdkConfigurationError( 'invalid json in keystore file') from ethereum.tools import keys as ekeys if not ekeys.check_keystore_json(keystore): raise SdkConfigurationError('invalid keystore file') try: self.private_key = ekeys.decode_keystore_json( keystore, password) except ValueError as e: raise SdkConfigurationError('keyfile decode error: ' + str(e)) elif private_key: self.private_key = private_key if self.private_key: try: private_key_bytes = hexstr_if_str(to_bytes, self.private_key) pk = keys.PrivateKey(private_key_bytes) except ValidationError as e: raise SdkConfigurationError('cannot load private key: ' + str(e)) self.address = self.web3.eth.defaultAccount = pk.public_key.to_checksum_address( ) # monitoring filters self._pending_tx_filter = None self._new_block_filter = None