def test_get_privkey(keystore_mock):
account_manager = AccountManager(keystore_mock)
assert '0xf696ecb5c767263c797a035db6f6008d38d852960ed33a491a58390b003fb605' == encode_hex(
account_manager.get_privkey('0d5a0e4fece4b84365b9b8dba6e6d41348c73645',
'123'), )
assert '0xf696ecb5c767263c797a035db6f6008d38d852960ed33a491a58390b003fb605' == encode_hex(
account_manager.get_privkey(
'0x0d5a0e4fece4b84365b9b8dba6e6d41348c73645', '123'), )
assert '0x36fa966441f259501110ba88f8212dfd7f8bacb07862a7d5cf8f31c1a64551e5' == encode_hex(
account_manager.get_privkey('3593403033d18b82f7b4a0f18e1ed24623d23b20',
'123'), )
assert '0x36fa966441f259501110ba88f8212dfd7f8bacb07862a7d5cf8f31c1a64551e5' == encode_hex(
account_manager.get_privkey(
'0x3593403033d18b82f7b4a0f18e1ed24623d23b20', '123'), )
# failures
with pytest.raises(ValueError) as exc:
account_manager.get_privkey(
'0x3593403033d18b82f7b4a0f18e1ed24623d23b20', '456')
assert 'MAC mismatch' in str(exc.value)
with pytest.raises(ValueError) as exc:
account_manager.get_privkey('a05934d3033d18b82f7b4adf18e1ed24e3d23b19',
'123')
assert (
'Keystore file not found for 0xa05934d3033d18b82f7b4adf18e1ed24e3d23b19'
in str(exc.value))
def get_private_key(keystore):
accmgr = AccountManager(keystore)
if not accmgr.accounts:
raise RuntimeError("No Ethereum accounts found in the user's system")
addresses = list(accmgr.accounts.keys())
return accmgr.get_privkey(addresses[0], DEFAULT_PASSPHRASE)
def get_private_key():
keystore = os.path.join(os.environ['RST_DATADIR'], 'keystore')
accmgr = AccountManager(keystore)
if not accmgr.accounts:
raise RuntimeError('No Ethereum accounts found in the user\'s system')
addresses = list(accmgr.accounts.keys())
return accmgr.get_privkey(addresses[0], TEST_ACCOUNT_PASSWORD)
def get_private_key():
keystore = os.path.join(os.environ['RST_DATADIR'], 'keystore')
accmgr = AccountManager(keystore)
if not accmgr.accounts:
raise RuntimeError('No Ethereum accounts found in the user\'s system')
addresses = list(accmgr.accounts.keys())
return accmgr.get_privkey(addresses[0], TEST_ACCOUNT_PASSWORD)
def unlock_account_with_passwordfile(
account_manager: AccountManager, address_hex: AddressHex, password_file: TextIO
) -> PrivateKey:
password = password_file.read().strip("\r\n")
try:
return account_manager.get_privkey(address_hex, password.strip())
except ValueError:
raise KeystoreAuthenticationError(f"Incorrect password for {address_hex} in file.")
def unlock_account_with_passwordfile(account_manager: AccountManager,
address_hex: AddressHex,
password_file: TextIO) -> PrivateKey:
password = password_file.read().strip("\r\n")
try:
return account_manager.get_privkey(address_hex, password.strip())
except ValueError:
click.secho(
f"Incorrect password for {address_hex} in file. Aborting ...",
fg="red")
sys.exit(1)
def matrix_api_shell(address, password, server):
am = AccountManager(os.path.expanduser("~/.ethereum/keystore"))
signer = LocalSigner(am.get_privkey(to_checksum_address(address),
password))
server_name = server.split("//")[1]
matrix_password = encode_hex(signer.sign(server_name.encode()))
api = GMatrixHttpApi(server)
resp = api.login("m.login.password",
user=to_normalized_address(address),
password=matrix_password)
api.token = resp["access_token"]
IPython.embed(
header=f"Use the `api` object to interact with matrix on {server}.")
def get_login(address, password) -> None:
path = os.path.expanduser("~/.ethereum/keystore")
if sys.platform.startswith("darwin"):
path = os.path.expanduser("~/Library/Ethereum/keystore")
am = AccountManager(path)
signer = LocalSigner(am.get_privkey(to_checksum_address(address), password))
print(f"Username: {to_normalized_address(address)}")
print("Password:"******"\ttransport {i:02d}:",
encode_hex(signer.sign(f"transport{i:02d}.raiden.network".encode())),
)
def unlock_account_with_passwordfile(
account_manager: AccountManager,
address_hex: AddressHex,
password_file: io.RawIOBase,
) -> PrivateKey:
password = password_file.read()
try:
return account_manager.get_privkey(address_hex, password)
except ValueError:
click.secho(
f'Incorrect password for {address_hex} in file. Aborting ...',
fg='red',
)
sys.exit(1)
def unlock_account_with_passwordprompt(account_manager: AccountManager,
address_hex: AddressHex) -> PrivateKey:
tries = 3
for current in range(tries):
try:
checksum_address = to_checksum_address(address_hex)
password = getpass.getpass(
f"Enter the password to unlock {checksum_address}: ")
return account_manager.get_privkey(address_hex, password)
except ValueError:
print(f"Incorrect passphrase to unlock the private key. "
f"{current} out of {tries} tries. "
f"Please try again or kill the process to quit. "
f"Usually Ctrl-c.")
sys.exit(1)
def unlock_account_with_passwordprompt(
account_manager: AccountManager,
address_hex: AddressHex,
) -> PrivateKey:
tries = 3
for current in range(tries):
try:
password = getpass.getpass(
f'Enter the password to unlock {address_hex}: ',
)
return account_manager.get_privkey(address_hex, password)
except ValueError:
print(
f'Incorrect passphrase to unlock the private key. '
f'{current} out of {tries} tries. '
f'Please try again or kill the process to quit. '
f'Usually Ctrl-c.',
)
sys.exit(1)
def test_get_privkey():
account_manager = AccountManager(test_keystore)
'f696ecb5c767263c797a035db6f6008d38d852960ed33a491a58390b003fb605' == encode_hex(
account_manager.get_privkey('0d5a0e4fece4b84365b9b8dba6e6d41348c73645', '123')
)
'f696ecb5c767263c797a035db6f6008d38d852960ed33a491a58390b003fb605' == encode_hex(
account_manager.get_privkey('0x0d5a0e4fece4b84365b9b8dba6e6d41348c73645', '123')
)
'36fa966441f259501110ba88f8212dfd7f8bacb07862a7d5cf8f31c1a64551e5' == encode_hex(
account_manager.get_privkey('3593403033d18b82f7b4a0f18e1ed24623d23b20', '123')
)
'36fa966441f259501110ba88f8212dfd7f8bacb07862a7d5cf8f31c1a64551e5' == encode_hex(
account_manager.get_privkey('0x3593403033d18b82f7b4a0f18e1ed24623d23b20', '123')
)
# failures
with pytest.raises(ValueError) as exc:
account_manager.get_privkey('0x3593403033d18b82f7b4a0f18e1ed24623d23b20', '456')
assert 'MAC mismatch. Password incorrect?' in exc.value
with pytest.raises(ValueError) as exc:
account_manager.get_privkey('a05934d3033d18b82f7b4adf18e1ed24e3d23b19', '123')
assert 'Keystore file not found for a05934d3033d18b82f7b4adf18e1ed24e3d23b19' in exc.value
def test_get_privkey(keystore_mock):
account_manager = AccountManager(keystore_mock)
assert "0xf696ecb5c767263c797a035db6f6008d38d852960ed33a491a58390b003fb605" == encode_hex(
account_manager.get_privkey("0x0d5a0e4FECE4b84365b9B8DbA6e6D41348C73645", "123")
)
assert "0x36fa966441f259501110ba88f8212dfd7f8bacb07862a7d5cf8f31c1a64551e5" == encode_hex(
account_manager.get_privkey("0x3593403033d18b82f7b4a0F18e1ED24623D23b20", "123")
)
# failures
with pytest.raises(ValueError) as exc:
account_manager.get_privkey("0x3593403033d18b82f7b4a0F18e1ED24623D23b20", "456")
assert "MAC mismatch" in str(exc.value)
with pytest.raises(KeystoreFileNotFound) as exc:
account_manager.get_privkey("0xa05934d3033D18b82F7b4AdF18E1eD24E3D23b19", "123")
assert "Keystore file not found for 0xa05934d3033D18b82F7b4AdF18E1eD24E3D23b19" in str(
exc.value
)
def app(
address, # pylint: disable=too-many-arguments,too-many-locals
keystore_path,
eth_rpc_endpoint,
registry_contract_address,
discovery_contract_address,
listen_address,
socket,
logging,
logfile,
max_unresponsive_time,
send_ping_time,
api_port,
rpc,
console):
slogging.configure(logging, log_file=logfile)
# config_file = args.config_file
(listen_host, listen_port) = split_endpoint(listen_address)
config = App.default_config.copy()
config['host'] = listen_host
config['port'] = listen_port
config['max_unresponsive_time'] = max_unresponsive_time
config['send_ping_time'] = send_ping_time
config['console'] = console
config['rpc'] = rpc
config['api_port'] = api_port
config['socket'] = socket
accmgr = AccountManager(keystore_path)
if not accmgr.accounts:
raise RuntimeError('No Ethereum accounts found in the user\'s system')
if not accmgr.address_in_keystore(address):
addresses = list(accmgr.accounts.keys())
formatted_addresses = [
'[{:3d}] - 0x{}'.format(idx, addr)
for idx, addr in enumerate(addresses)
]
should_prompt = True
print('The following accounts were found in your machine:')
print('')
print('\n'.join(formatted_addresses))
print('')
while should_prompt:
idx = click.prompt('Select one of them by index to continue',
type=int)
if idx >= 0 and idx < len(addresses):
should_prompt = False
else:
print("\nError: Provided index '{}' is out of bounds\n".format(
idx))
address = addresses[idx]
unlock_tries = 3
while True:
try:
privatekey_bin = accmgr.get_privkey(address)
break
except ValueError as e:
# ValueError exception raised if the password is incorrect
if unlock_tries == 0:
print(
'Exhausted passphrase unlock attempts for {}. Aborting ...'
.format(address))
sys.exit(1)
print(
'Incorrect passphrase to unlock the private key. {} tries remaining. '
'Please try again or kill the process to quit. '
'Usually Ctrl-c.'.format(unlock_tries))
unlock_tries -= 1
privatekey_hex = privatekey_bin.encode('hex')
config['privatekey_hex'] = privatekey_hex
endpoint = eth_rpc_endpoint
if eth_rpc_endpoint.startswith("http://"):
endpoint = eth_rpc_endpoint[len("http://"):]
rpc_port = 80
elif eth_rpc_endpoint.startswith("https://"):
endpoint = eth_rpc_endpoint[len("https://"):]
rpc_port = 443
if ':' not in endpoint: # no port was given in url
rpc_host = endpoint
else:
rpc_host, rpc_port = split_endpoint(endpoint)
# user may have provided registry and discovery contracts with leading 0x
registry_contract_address = address_decoder(registry_contract_address)
discovery_contract_address = address_decoder(discovery_contract_address)
try:
blockchain_service = BlockChainService(
privatekey_bin,
registry_contract_address,
host=rpc_host,
port=rpc_port,
)
except ValueError as e:
# ValueError exception raised if:
# - The registry contract address doesn't have code, this might happen
# if the connected geth process is not synced or if the wrong address
# is provided (e.g. using the address from a smart contract deployed on
# ropsten with a geth node connected to morden)
print(e.message)
sys.exit(1)
discovery = ContractDiscovery(
blockchain_service.node_address,
blockchain_service.discovery(discovery_contract_address))
# default database directory
raiden_directory = os.path.join(os.path.expanduser('~'), '.raiden')
if not os.path.exists(raiden_directory):
os.makedirs(raiden_directory)
database_path = os.path.join(raiden_directory, 'log.db')
config['database_path'] = database_path
return App(config, blockchain_service, discovery)
def prompt_account(address_hex, keystore_path, password_file):
accmgr = AccountManager(keystore_path)
if not accmgr.accounts:
print(
'No Ethereum accounts found in the provided keystore directory {}. '
'Please provide a directory containing valid ethereum account '
'files.'.format(keystore_path),
)
sys.exit(1)
if not accmgr.address_in_keystore(address_hex):
# check if an address has been passed
if address_hex is not None:
print("Account '{}' could not be found on the system. Aborting ...".format(
address_hex))
sys.exit(1)
addresses = list(accmgr.accounts.keys())
formatted_addresses = [
'[{:3d}] - {}'.format(idx, to_checksum_address(addr))
for idx, addr in enumerate(addresses)
]
should_prompt = True
print('The following accounts were found in your machine:')
print('')
print('\n'.join(formatted_addresses))
print('')
while should_prompt:
idx = click.prompt('Select one of them by index to continue', type=int)
if 0 <= idx < len(addresses):
should_prompt = False
else:
print('\nError: Provided index "{}" is out of bounds\n'.format(idx))
address_hex = addresses[idx]
password = None
if password_file:
password = password_file.read()
if password != '':
password = password.splitlines()[0]
if password is not None:
try:
privatekey_bin = accmgr.get_privkey(address_hex, password)
except ValueError:
# ValueError exception raised if the password is incorrect
print('Incorrect password for {} in file. Aborting ...'.format(address_hex))
sys.exit(1)
else:
unlock_tries = 3
while True:
try:
privatekey_bin = accmgr.get_privkey(address_hex)
break
except ValueError:
# ValueError exception raised if the password is incorrect
if unlock_tries == 0:
print(
'Exhausted passphrase unlock attempts for {}. Aborting ...'
.format(address_hex),
)
sys.exit(1)
print(
'Incorrect passphrase to unlock the private key. {} tries remaining. '
'Please try again or kill the process to quit. '
'Usually Ctrl-c.'.format(unlock_tries),
)
unlock_tries -= 1
return address_hex, privatekey_bin
def app(address, # pylint: disable=too-many-arguments,too-many-locals
keystore_path,
eth_rpc_endpoint,
registry_contract_address,
discovery_contract_address,
listen_address,
logging,
logfile,
max_unresponsive_time,
send_ping_time):
slogging.configure(logging, log_file=logfile)
# config_file = args.config_file
(listen_host, listen_port) = split_endpoint(listen_address)
config = App.default_config.copy()
config['host'] = listen_host
config['port'] = listen_port
config['max_unresponsive_time'] = max_unresponsive_time
config['send_ping_time'] = send_ping_time
accmgr = AccountManager(keystore_path)
if not accmgr.accounts:
raise RuntimeError('No Ethereum accounts found in the user\'s system')
if not accmgr.address_in_keystore(address):
addresses = list(accmgr.accounts.keys())
formatted_addresses = [
'[{:3d}] - 0x{}'.format(idx, addr)
for idx, addr in enumerate(addresses)
]
should_prompt = True
print('The following accounts were found in your machine:')
print('')
print('\n'.join(formatted_addresses))
print('')
while should_prompt:
idx = click.prompt('Select one of them by index to continue', type=int)
if idx >= 0 and idx < len(addresses):
should_prompt = False
else:
print("\nError: Provided index '{}' is out of bounds\n".format(idx))
address = addresses[idx]
try:
privatekey_bin = accmgr.get_privkey(address)
except ValueError as e:
# ValueError exception raised if the password is incorrect, print the
# exception message and exit the process, the user may try again by
# re-executing Raiden.
print(e.message)
sys.exit(1)
privatekey_hex = privatekey_bin.encode('hex')
config['privatekey_hex'] = privatekey_hex
endpoint = eth_rpc_endpoint
if eth_rpc_endpoint.startswith("http://"):
endpoint = eth_rpc_endpoint[len("http://"):]
rpc_port = 80
elif eth_rpc_endpoint.startswith("https://"):
endpoint = eth_rpc_endpoint[len("https://"):]
rpc_port = 443
if ':' not in endpoint: # no port was given in url
rpc_host = endpoint
else:
rpc_host, rpc_port = split_endpoint(endpoint)
# user may have provided registry and discovery contracts with leading 0x
registry_contract_address = address_decoder(registry_contract_address)
discovery_contract_address = address_decoder(discovery_contract_address)
try:
blockchain_service = BlockChainService(
privatekey_bin,
registry_contract_address,
host=rpc_host,
port=rpc_port,
)
except ValueError as e:
# ValueError exception raised if:
# - The registry contract address doesn't have code, this might happen
# if the connected geth process is not synced or if the wrong address
# is provided (e.g. using the address from a smart contract deployed on
# ropsten with a geth node connected to morden)
print(e.message)
sys.exit(1)
discovery = ContractDiscovery(
blockchain_service.node_address,
blockchain_service.discovery(discovery_contract_address)
)
return App(config, blockchain_service, discovery)
def app(address, keystore_path, eth_rpc_endpoint, registry_contract_address,
discovery_contract_address, listen_address, logging, logfile,
max_unresponsive_time, send_ping_time):
slogging.configure(logging, log_file=logfile)
# config_file = args.config_file
(listen_host, listen_port) = split_endpoint(listen_address)
config = App.default_config.copy()
config['host'] = listen_host
config['port'] = listen_port
config['max_unresponsive_time'] = max_unresponsive_time
config['send_ping_time'] = send_ping_time
accmgr = AccountManager(keystore_path)
if not accmgr.accounts:
raise RuntimeError('No Ethereum accounts found in the user\'s system')
if not accmgr.address_in_keystore(address):
addresses = list(accmgr.accounts.keys())
formatted_addresses = [
'[{:3d}] - 0x{}'.format(idx, addr)
for idx, addr in enumerate(addresses)
]
should_prompt = True
while should_prompt:
idx = click.prompt(
"The following accounts were found in your machine:\n\n{}"
"\nSelect one of them by index to continue: ".format(
"\n".join(formatted_addresses)),
type=int)
if idx >= 0 and idx < len(addresses):
should_prompt = False
else:
print("\nError: Provided index '{}' is out of bounds\n".format(
idx))
address = addresses[idx]
privatekey = accmgr.get_privkey(address)
config['privatekey_hex'] = encode_hex(privatekey)
endpoint = eth_rpc_endpoint
if eth_rpc_endpoint.startswith("http://"):
endpoint = eth_rpc_endpoint[len("http://"):]
rpc_port = 80
elif eth_rpc_endpoint.startswith("https://"):
endpoint = eth_rpc_endpoint[len("https://"):]
rpc_port = 443
if ':' not in endpoint: # no port was given in url
rpc_host = endpoint
else:
rpc_host, rpc_port = split_endpoint(endpoint)
blockchain_service = BlockChainService(
privatekey,
decode_hex(registry_contract_address),
host=rpc_host,
port=rpc_port,
)
discovery = ContractDiscovery(
blockchain_service.node_address,
blockchain_service.discovery(discovery_contract_address))
return App(config, blockchain_service, discovery)
def app(
address,
keystore_path,
eth_rpc_endpoint,
registry_contract_address,
discovery_contract_address,
listen_address,
rpccorsdomain, # pylint: disable=unused-argument
mapped_socket,
logging,
logfile,
max_unresponsive_time,
send_ping_time,
api_address,
rpc,
console,
password_file,
datadir):
from raiden.app import App
from raiden.network.rpc.client import BlockChainService
# config_file = args.config_file
(listen_host, listen_port) = split_endpoint(listen_address)
(api_host, api_port) = split_endpoint(api_address)
config = App.DEFAULT_CONFIG.copy()
config['host'] = listen_host
config['port'] = listen_port
config['console'] = console
config['rpc'] = rpc
config['api_host'] = api_host
config['api_port'] = api_port
if mapped_socket:
config['socket'] = mapped_socket.socket
config['external_ip'] = mapped_socket.external_ip
config['external_port'] = mapped_socket.external_port
else:
config['socket'] = None
config['external_ip'] = listen_host
config['external_port'] = listen_port
retries = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES
config['protocol']['nat_keepalive_retries'] = retries
config['protocol']['nat_keepalive_timeout'] = send_ping_time
accmgr = AccountManager(keystore_path)
if not accmgr.accounts:
raise RuntimeError('No Ethereum accounts found in the user\'s system')
if not accmgr.address_in_keystore(address):
addresses = list(accmgr.accounts.keys())
formatted_addresses = [
'[{:3d}] - 0x{}'.format(idx, addr)
for idx, addr in enumerate(addresses)
]
should_prompt = True
print('The following accounts were found in your machine:')
print('')
print('\n'.join(formatted_addresses))
print('')
while should_prompt:
idx = click.prompt('Select one of them by index to continue',
type=int)
if idx >= 0 and idx < len(addresses):
should_prompt = False
else:
print("\nError: Provided index '{}' is out of bounds\n".format(
idx))
address = addresses[idx]
password = None
if password_file:
password = password_file.read().splitlines()[0]
if password:
try:
privatekey_bin = accmgr.get_privkey(address, password)
except ValueError as e:
# ValueError exception raised if the password is incorrect
print('Incorrect password for {} in file. Aborting ...'.format(
address))
sys.exit(1)
else:
unlock_tries = 3
while True:
try:
privatekey_bin = accmgr.get_privkey(address)
break
except ValueError as e:
# ValueError exception raised if the password is incorrect
if unlock_tries == 0:
print(
'Exhausted passphrase unlock attempts for {}. Aborting ...'
.format(address))
sys.exit(1)
print(
'Incorrect passphrase to unlock the private key. {} tries remaining. '
'Please try again or kill the process to quit. '
'Usually Ctrl-c.'.format(unlock_tries))
unlock_tries -= 1
privatekey_hex = privatekey_bin.encode('hex')
config['privatekey_hex'] = privatekey_hex
endpoint = eth_rpc_endpoint
# Fallback default port if only an IP address is given
rpc_port = 8545
if eth_rpc_endpoint.startswith("http://"):
endpoint = eth_rpc_endpoint[len("http://"):]
rpc_port = 80
elif eth_rpc_endpoint.startswith("https://"):
endpoint = eth_rpc_endpoint[len("https://"):]
rpc_port = 443
if ':' not in endpoint: # no port was given in url
rpc_host = endpoint
else:
rpc_host, rpc_port = split_endpoint(endpoint)
# user may have provided registry and discovery contracts with leading 0x
registry_contract_address = address_decoder(registry_contract_address)
discovery_contract_address = address_decoder(discovery_contract_address)
try:
blockchain_service = BlockChainService(
privatekey_bin,
registry_contract_address,
host=rpc_host,
port=rpc_port,
)
except ValueError as e:
# ValueError exception raised if:
# - The registry contract address doesn't have code, this might happen
# if the connected geth process is not synced or if the wrong address
# is provided (e.g. using the address from a smart contract deployed on
# ropsten with a geth node connected to morden)
print(e.message)
sys.exit(1)
discovery = ContractDiscovery(
blockchain_service.node_address,
blockchain_service.discovery(discovery_contract_address))
if datadir is None:
# default database directory
raiden_directory = os.path.join(os.path.expanduser('~'), '.raiden')
else:
raiden_directory = datadir
if not os.path.exists(raiden_directory):
os.makedirs(raiden_directory)
user_db_dir = os.path.join(raiden_directory, address[:6])
if not os.path.exists(user_db_dir):
os.makedirs(user_db_dir)
database_path = os.path.join(user_db_dir, 'log.db')
config['database_path'] = database_path
return App(config, blockchain_service, discovery)
def prompt_account(address_hex, keystore_path, password_file):
accmgr = AccountManager(keystore_path)
if not accmgr.accounts:
raise RuntimeError('No Ethereum accounts found in the user\'s system')
if not accmgr.address_in_keystore(address_hex):
# check if an address has been passed
if address_hex is not None:
print(
"Account '{}' could not be found on the system. Aborting ...".
format(address_hex))
sys.exit(1)
addresses = list(accmgr.accounts.keys())
formatted_addresses = [
'[{:3d}] - 0x{}'.format(idx, addr)
for idx, addr in enumerate(addresses)
]
should_prompt = True
print('The following accounts were found in your machine:')
print('')
print('\n'.join(formatted_addresses))
print('')
while should_prompt:
idx = click.prompt('Select one of them by index to continue',
type=int)
if idx >= 0 and idx < len(addresses):
should_prompt = False
else:
print("\nError: Provided index '{}' is out of bounds\n".format(
idx))
address_hex = addresses[idx]
password = None
if password_file:
password = password_file.read().splitlines()[0]
if password:
try:
privatekey_bin = accmgr.get_privkey(address_hex, password)
except ValueError:
# ValueError exception raised if the password is incorrect
print('Incorrect password for {} in file. Aborting ...'.format(
address_hex))
sys.exit(1)
else:
unlock_tries = 3
while True:
try:
privatekey_bin = accmgr.get_privkey(address_hex)
break
except ValueError:
# ValueError exception raised if the password is incorrect
if unlock_tries == 0:
print(
'Exhausted passphrase unlock attempts for {}. Aborting ...'
.format(address_hex))
sys.exit(1)
print(
'Incorrect passphrase to unlock the private key. {} tries remaining. '
'Please try again or kill the process to quit. '
'Usually Ctrl-c.'.format(unlock_tries))
unlock_tries -= 1
return address_hex, privatekey_bin
def app(address,
keystore_path,
eth_rpc_endpoint,
registry_contract_address,
discovery_contract_address,
listen_address,
logging,
logfile,
max_unresponsive_time,
send_ping_time):
slogging.configure(logging, log_file=logfile)
# config_file = args.config_file
(listen_host, listen_port) = split_endpoint(listen_address)
config = App.default_config.copy()
config['host'] = listen_host
config['port'] = listen_port
config['max_unresponsive_time'] = max_unresponsive_time
config['send_ping_time'] = send_ping_time
accmgr = AccountManager(keystore_path)
if not accmgr.accounts:
raise RuntimeError('No Ethereum accounts found in the user\'s system')
if not accmgr.address_in_keystore(address):
addresses = list(accmgr.accounts.keys())
formatted_addresses = [
'[{:3d}] - 0x{}'.format(idx, addr)
for idx, addr in enumerate(addresses)
]
should_prompt = True
while should_prompt:
idx = click.prompt(
"The following accounts were found in your machine:\n\n{}"
"\nSelect one of them by index to continue: ".format(
"\n".join(formatted_addresses)),
type=int
)
if idx >= 0 and idx < len(addresses):
should_prompt = False
else:
print("\nError: Provided index '{}' is out of bounds\n".format(idx))
address = addresses[idx]
privatekey = accmgr.get_privkey(address)
config['privatekey_hex'] = encode_hex(privatekey)
endpoint = eth_rpc_endpoint
if eth_rpc_endpoint.startswith("http://"):
endpoint = eth_rpc_endpoint[len("http://"):]
rpc_port = 80
elif eth_rpc_endpoint.startswith("https://"):
endpoint = eth_rpc_endpoint[len("https://"):]
rpc_port = 443
if ':' not in endpoint: # no port was given in url
rpc_host = endpoint
else:
rpc_host, rpc_port = split_endpoint(endpoint)
blockchain_service = BlockChainService(
privatekey,
decode_hex(registry_contract_address),
host=rpc_host,
port=rpc_port,
)
discovery = ContractDiscovery(
blockchain_service,
decode_hex(discovery_contract_address) # FIXME: double encoding
)
return App(config, blockchain_service, discovery)
