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,
log_json,
max_unresponsive_time,
send_ping_time,
api_address,
rpc,
console,
password_file,
web_ui,
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['web_ui'] = rpc and web_ui
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
address_hex = address_encoder(address) if address else None
address_hex, privatekey_bin = prompt_account(address_hex, keystore_path, password_file)
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)
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_tx_cost = GAS_PRICE * DISCOVERY_REGISTRATION_GAS
while True:
balance = blockchain_service.client.balance(address_hex)
if discovery_tx_cost <= balance:
break
print(
'Account has insufficient funds for discovery registration.\n'
'Needed: {} ETH\n'
'Available: {} ETH.\n'
'Please deposit additional funds on this account.'
.format(discovery_tx_cost / float(denoms.ether), balance / float(denoms.ether))
)
if not click.confirm('Try again?'):
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_hex[:8])
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 app(address,
keystore_path,
eth_rpc_endpoint,
registry_contract_address,
discovery_contract_address,
listen_address,
rpccorsdomain,
mapped_socket,
logging,
logfile,
log_json,
max_unresponsive_time,
send_ping_time,
api_address,
rpc,
sync_check,
console,
password_file,
web_ui,
datadir,
eth_client_communication,
nat):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
from raiden.network.rpc.client import BlockChainService
(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['web_ui'] = rpc and web_ui
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
config['protocol']['nat_keepalive_retries'] = DEFAULT_NAT_KEEPALIVE_RETRIES
timeout = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES
config['protocol']['nat_keepalive_timeout'] = timeout
address_hex = address_encoder(address) if address else None
address_hex, privatekey_bin = prompt_account(address_hex, keystore_path, password_file)
address = address_decoder(address_hex)
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)
rpc_client = JSONRPCClient(
rpc_host,
rpc_port,
privatekey_bin,
)
# this assumes the eth node is already online
patch_send_transaction(rpc_client)
patch_send_message(rpc_client)
if not check_json_rpc(rpc_client):
sys.exit(1)
blockchain_service = BlockChainService(
privatekey_bin,
rpc_client,
)
if sync_check:
check_synced(blockchain_service)
discovery_tx_cost = GAS_PRICE * DISCOVERY_REGISTRATION_GAS
while True:
balance = blockchain_service.client.balance(address)
if discovery_tx_cost <= balance:
break
print(
'Account has insufficient funds for discovery registration.\n'
'Needed: {} ETH\n'
'Available: {} ETH.\n'
'Please deposit additional funds on this account.'
.format(discovery_tx_cost / float(denoms.ether), balance / float(denoms.ether))
)
if not click.confirm('Try again?'):
sys.exit(1)
registry = blockchain_service.registry(
registry_contract_address,
)
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_hex[:8])
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,
registry,
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, # 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 app(address, keystore_path, eth_rpc_endpoint, registry_contract_address,
discovery_contract_address, listen_address, rpccorsdomain,
mapped_socket, logging, logfile, log_json, max_unresponsive_time,
send_ping_time, api_address, rpc, sync_check, console, password_file,
web_ui, datadir, eth_client_communication, nat):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
from raiden.network.rpc.client import BlockChainService
(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['web_ui'] = rpc and web_ui
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
config['protocol']['nat_keepalive_retries'] = DEFAULT_NAT_KEEPALIVE_RETRIES
timeout = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES
config['protocol']['nat_keepalive_timeout'] = timeout
address_hex = address_encoder(address) if address else None
address_hex, privatekey_bin = prompt_account(address_hex, keystore_path,
password_file)
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)
rpc_client = JSONRPCClient(
privkey=privatekey_bin,
host=rpc_host,
port=rpc_port,
print_communication=eth_client_communication,
)
# this assumes the eth node is already online
patch_send_transaction(rpc_client)
patch_send_message(rpc_client)
try:
blockchain_service = BlockChainService(
privatekey_bin,
rpc_client,
)
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)
if sync_check:
try:
net_id = int(blockchain_service.client.call('net_version'))
network = ID_TO_NETWORKNAME[net_id]
except: # pylint: disable=bare-except
print(
"Couldn't determine the network the ethereum node is connected to.\n"
"Because of this there is not way to determine the latest\n"
"block with an oracle, and the events from the ethereum\n"
"node cannot be trusted. Giving up.\n")
sys.exit(1)
url = ETHERSCAN_API.format(
network=network,
action='eth_blockNumber',
)
wait_for_sync(
blockchain_service,
url=url,
tolerance=ORACLE_BLOCKNUMBER_DRIFT_TOLERANCE,
sleep=3,
)
discovery_tx_cost = GAS_PRICE * DISCOVERY_REGISTRATION_GAS
while True:
balance = blockchain_service.client.balance(address_hex)
if discovery_tx_cost <= balance:
break
print('Account has insufficient funds for discovery registration.\n'
'Needed: {} ETH\n'
'Available: {} ETH.\n'
'Please deposit additional funds on this account.'.format(
discovery_tx_cost / float(denoms.ether),
balance / float(denoms.ether)))
if not click.confirm('Try again?'):
sys.exit(1)
registry = blockchain_service.registry(registry_contract_address, )
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_hex[:8])
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,
registry,
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 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)