def run_app(
address,
keystore_path,
gas_price,
eth_rpc_endpoint,
registry_contract_address,
secret_registry_contract_address,
discovery_contract_address,
listen_address,
mapped_socket,
max_unresponsive_time,
api_address,
rpc,
sync_check,
console,
password_file,
web_ui,
datadir,
transport,
matrix_server,
network_id,
extra_config=None,
**kwargs,
):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
if transport == 'udp' and not mapped_socket:
raise RuntimeError('Missing socket')
address_hex = to_normalized_address(address) if address else None
address_hex, privatekey_bin = prompt_account(address_hex, keystore_path,
password_file)
address = to_canonical_address(address_hex)
(listen_host, listen_port) = split_endpoint(listen_address)
(api_host, api_port) = split_endpoint(api_address)
if datadir is None:
datadir = os.path.join(os.path.expanduser('~'), '.raiden')
config = deepcopy(App.DEFAULT_CONFIG)
if extra_config:
merge_dict(config, extra_config)
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
config['transport_type'] = transport
config['matrix']['server'] = matrix_server
config['transport'][
'nat_keepalive_retries'] = DEFAULT_NAT_KEEPALIVE_RETRIES
timeout = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES
config['transport']['nat_keepalive_timeout'] = timeout
privatekey_hex = hexlify(privatekey_bin)
config['privatekey_hex'] = privatekey_hex
rpc_host, rpc_port = eth_endpoint_to_hostport(eth_rpc_endpoint)
rpc_client = JSONRPCClient(
rpc_host,
rpc_port,
privatekey_bin,
gas_price,
)
blockchain_service = BlockChainService(privatekey_bin, rpc_client)
net_id = blockchain_service.network_id
if net_id != network_id:
if network_id in constants.ID_TO_NETWORKNAME and net_id in constants.ID_TO_NETWORKNAME:
print((
"The chosen ethereum network '{}' differs from the ethereum client '{}'. "
'Please update your settings.').format(
constants.ID_TO_NETWORKNAME[network_id],
constants.ID_TO_NETWORKNAME[net_id]))
else:
print((
"The chosen ethereum network id '{}' differs from the ethereum client '{}'. "
'Please update your settings.').format(network_id, net_id))
sys.exit(1)
config['chain_id'] = network_id
if sync_check:
check_synced(blockchain_service)
database_path = os.path.join(datadir, 'netid_%s' % net_id, address_hex[:8],
'log.db')
config['database_path'] = database_path
print(
'\nYou are connected to the \'{}\' network and the DB path is: {}'.
format(
constants.ID_TO_NETWORKNAME.get(net_id) or net_id,
database_path,
), )
contract_addresses_given = (registry_contract_address is not None and
secret_registry_contract_address is not None
and discovery_contract_address is not None)
contract_addresses_known = net_id in constants.ID_TO_NETWORK_CONFIG
if not contract_addresses_given and not contract_addresses_known:
print((
"There are known contract addresses for network id '{}'. Please provide "
'them in the command line or the configuration file.'
).format(net_id))
sys.exit(1)
contract_addresses = constants.ID_TO_NETWORK_CONFIG.get(net_id, dict())
try:
token_network_registry = blockchain_service.token_network_registry(
registry_contract_address
or contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], )
except ContractVersionMismatch:
handle_contract_version_mismatch('token network registry',
registry_contract_address)
except AddressWithoutCode:
handle_contract_no_code('token network registry',
registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address('token network registry',
registry_contract_address)
try:
secret_registry = blockchain_service.secret_registry(
secret_registry_contract_address
or contract_addresses[CONTRACT_SECRET_REGISTRY], )
except ContractVersionMismatch:
handle_contract_version_mismatch('secret registry',
secret_registry_contract_address)
except AddressWithoutCode:
handle_contract_no_code('secret registry',
secret_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address('secret registry',
secret_registry_contract_address)
discovery = None
if transport == 'udp':
check_discovery_registration_gas(blockchain_service, address)
try:
dicovery_proxy = blockchain_service.discovery(
discovery_contract_address
or contract_addresses[CONTRACT_ENDPOINT_REGISTRY], )
discovery = ContractDiscovery(
blockchain_service.node_address,
dicovery_proxy,
)
except ContractVersionMismatch:
handle_contract_version_mismatch('discovery',
discovery_contract_address)
except AddressWithoutCode:
handle_contract_no_code('discovery', discovery_contract_address)
except AddressWrongContract:
handle_contract_wrong_address('discovery',
discovery_contract_address)
throttle_policy = TokenBucket(
config['transport']['throttle_capacity'],
config['transport']['throttle_fill_rate'],
)
transport = UDPTransport(
discovery,
mapped_socket.socket,
throttle_policy,
config['transport'],
)
elif transport == 'matrix':
# matrix gets spammed with the default retry-interval of 1s, wait a little more
if config['transport'][
'retry_interval'] == DEFAULT_TRANSPORT_RETRY_INTERVAL:
config['transport']['retry_interval'] *= 5
try:
transport = MatrixTransport(config['matrix'])
except RaidenError as ex:
click.secho(f'FATAL: {ex}', fg='red')
sys.exit(1)
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
try:
chain_config = constants.ID_TO_NETWORK_CONFIG.get(net_id, {})
start_block = chain_config.get(constants.START_QUERY_BLOCK_KEY, 0)
raiden_app = App(
config=config,
chain=blockchain_service,
query_start_block=start_block,
default_registry=token_network_registry,
default_secret_registry=secret_registry,
transport=transport,
discovery=discovery,
)
except RaidenError as e:
click.secho(f'FATAL: {e}', fg='red')
sys.exit(1)
try:
raiden_app.start()
except filelock.Timeout:
name_or_id = constants.ID_TO_NETWORKNAME.get(network_id, network_id)
print(
f'FATAL: Another Raiden instance already running for account {address_hex} on '
f'network id {name_or_id}', )
sys.exit(1)
return raiden_app
def app(
address,
keystore_path,
gas_price,
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.blockchain_service import BlockChainService
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)
(listen_host, listen_port) = split_endpoint(listen_address)
(api_host, api_port) = split_endpoint(api_address)
if datadir is None:
datadir = os.path.join(os.path.expanduser('~'), '.raiden')
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
privatekey_hex = hexlify(privatekey_bin)
config['privatekey_hex'] = privatekey_hex
endpoint = eth_rpc_endpoint
# Fallback to 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,
gas_price,
)
blockchain_service = BlockChainService(
privatekey_bin,
rpc_client,
gas_price,
)
# this assumes the eth node is already online
check_json_rpc(rpc_client)
check_discovery_registration_gas(blockchain_service, address)
net_id = int(blockchain_service.client.rpccall_with_retry('net_version'))
if sync_check:
check_synced(net_id, blockchain_service)
database_path = os.path.join(datadir, 'netid_%s' % net_id, address_hex[:8],
'log.db')
config['database_path'] = database_path
print('You are connected to the {} network and the DB path is: {}'.format(
ID_TO_NETWORKNAME[net_id],
database_path,
))
registry = blockchain_service.registry(registry_contract_address, )
discovery = ContractDiscovery(
blockchain_service.node_address,
blockchain_service.discovery(discovery_contract_address))
return App(
config,
blockchain_service,
registry,
discovery,
)
def app(address, keystore_path, gas_price, 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.blockchain_service 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
if not check_json_rpc(rpc_client):
sys.exit(1)
blockchain_service = BlockChainService(
privatekey_bin,
rpc_client,
GAS_LIMIT,
gas_price,
)
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,
gas_price,
eth_rpc_endpoint,
registry_contract_address,
secret_registry_contract_address,
discovery_contract_address,
listen_address,
rpccorsdomain,
mapped_socket,
log_config,
log_file,
log_json,
max_unresponsive_time,
send_ping_time,
api_address,
rpc,
sync_check,
console,
password_file,
web_ui,
datadir,
nat,
transport,
matrix_server,
network_id,
config_file,
extra_config=None,
):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
if transport == 'udp' and not mapped_socket:
raise RuntimeError('Missing socket')
address_hex = to_normalized_address(address) if address else None
address_hex, privatekey_bin = prompt_account(address_hex, keystore_path,
password_file)
address = to_canonical_address(address_hex)
(listen_host, listen_port) = split_endpoint(listen_address)
(api_host, api_port) = split_endpoint(api_address)
if datadir is None:
datadir = os.path.join(os.path.expanduser('~'), '.raiden')
config = deepcopy(App.DEFAULT_CONFIG)
if extra_config:
merge_dict(config, extra_config)
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
config['transport_type'] = transport
config['matrix']['server'] = matrix_server
config['transport'][
'nat_keepalive_retries'] = DEFAULT_NAT_KEEPALIVE_RETRIES
timeout = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES
config['transport']['nat_keepalive_timeout'] = timeout
privatekey_hex = hexlify(privatekey_bin)
config['privatekey_hex'] = privatekey_hex
rpc_host, rpc_port = eth_endpoint_to_hostport(eth_rpc_endpoint)
rpc_client = JSONRPCClient(
rpc_host,
rpc_port,
privatekey_bin,
gas_price,
)
blockchain_service = BlockChainService(privatekey_bin, rpc_client)
# this assumes the eth node is already online
check_json_rpc(blockchain_service)
net_id = blockchain_service.network_id
if net_id != network_id:
if network_id in constants.ID_TO_NETWORKNAME and net_id in constants.ID_TO_NETWORKNAME:
print((
"The chosen ethereum network '{}' differs from the ethereum client '{}'. "
'Please update your settings.').format(
constants.ID_TO_NETWORKNAME[network_id],
constants.ID_TO_NETWORKNAME[net_id]))
else:
print((
"The chosen ethereum network id '{}' differs from the ethereum client '{}'. "
'Please update your settings.').format(network_id, net_id))
sys.exit(1)
if sync_check:
check_synced(blockchain_service)
database_path = os.path.join(datadir, 'netid_%s' % net_id, address_hex[:8],
'log.db')
config['database_path'] = database_path
print(
'You are connected to the \'{}\' network and the DB path is: {}'.
format(
constants.ID_TO_NETWORKNAME.get(net_id) or net_id,
database_path,
), )
try:
registry = blockchain_service.registry(registry_contract_address, )
except ContractVersionMismatch:
print(
'Deployed registry contract version mismatch. '
'Please update your Raiden installation.', )
sys.exit(1)
try:
secret_registry = blockchain_service.secret_registry(
secret_registry_contract_address, )
except ContractVersionMismatch:
print(
'Deployed secret registry contract version mismatch. '
'Please update your Raiden installation.', )
sys.exit(1)
discovery = None
if transport == 'udp':
check_discovery_registration_gas(blockchain_service, address)
try:
discovery = ContractDiscovery(
blockchain_service.node_address,
blockchain_service.discovery(discovery_contract_address),
)
except ContractVersionMismatch:
print('Deployed discovery contract version mismatch. '
'Please update your Raiden installation.')
sys.exit(1)
throttle_policy = TokenBucket(
config['transport']['throttle_capacity'],
config['transport']['throttle_fill_rate'],
)
transport = UDPTransport(
discovery,
mapped_socket.socket,
throttle_policy,
config['transport'],
)
elif transport == 'matrix':
transport = MatrixTransport(config['matrix'])
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
raiden_app = App(
config,
blockchain_service,
registry,
secret_registry,
transport,
discovery,
)
return raiden_app
def app(
address,
keystore_path,
gas_price,
eth_rpc_endpoint,
registry_contract_address,
secret_registry_contract_address,
discovery_contract_address,
listen_address,
rpccorsdomain,
mapped_socket,
log_config,
log_file,
log_json,
max_unresponsive_time,
send_ping_time,
api_address,
rpc,
sync_check,
console,
password_file,
web_ui,
datadir,
nat,
transport,
matrix_server,
network_id,
config_file,
extra_config=None,
):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
if transport == 'udp' and not mapped_socket:
raise RuntimeError('Missing socket')
address_hex = to_normalized_address(address) if address else None
address_hex, privatekey_bin = prompt_account(address_hex, keystore_path, password_file)
address = to_canonical_address(address_hex)
(listen_host, listen_port) = split_endpoint(listen_address)
(api_host, api_port) = split_endpoint(api_address)
if datadir is None:
datadir = os.path.join(os.path.expanduser('~'), '.raiden')
config = deepcopy(App.DEFAULT_CONFIG)
if extra_config:
merge_dict(config, extra_config)
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
config['transport_type'] = transport
config['matrix']['server'] = matrix_server
config['transport']['nat_keepalive_retries'] = DEFAULT_NAT_KEEPALIVE_RETRIES
timeout = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES
config['transport']['nat_keepalive_timeout'] = timeout
privatekey_hex = hexlify(privatekey_bin)
config['privatekey_hex'] = privatekey_hex
rpc_host, rpc_port = eth_endpoint_to_hostport(eth_rpc_endpoint)
rpc_client = JSONRPCClient(
rpc_host,
rpc_port,
privatekey_bin,
gas_price,
)
blockchain_service = BlockChainService(privatekey_bin, rpc_client)
net_id = blockchain_service.network_id
if net_id != network_id:
if network_id in constants.ID_TO_NETWORKNAME and net_id in constants.ID_TO_NETWORKNAME:
print((
"The chosen ethereum network '{}' differs from the ethereum client '{}'. "
'Please update your settings.'
).format(constants.ID_TO_NETWORKNAME[network_id], constants.ID_TO_NETWORKNAME[net_id]))
else:
print((
"The chosen ethereum network id '{}' differs from the ethereum client '{}'. "
'Please update your settings.'
).format(network_id, net_id))
sys.exit(1)
config['chain_id'] = network_id
if sync_check:
check_synced(blockchain_service)
database_path = os.path.join(datadir, 'netid_%s' % net_id, address_hex[:8], 'log.db')
config['database_path'] = database_path
print(
'\nYou are connected to the \'{}\' network and the DB path is: {}'.format(
constants.ID_TO_NETWORKNAME.get(net_id) or net_id,
database_path,
),
)
try:
token_network_registry = blockchain_service.token_network_registry(
registry_contract_address,
)
except ContractVersionMismatch:
print(
'Deployed registry contract version mismatch. '
'Please update your Raiden installation.',
)
sys.exit(1)
try:
secret_registry = blockchain_service.secret_registry(
secret_registry_contract_address,
)
except ContractVersionMismatch:
print(
'Deployed secret registry contract version mismatch. '
'Please update your Raiden installation.',
)
sys.exit(1)
discovery = None
if transport == 'udp':
check_discovery_registration_gas(blockchain_service, address)
try:
discovery = ContractDiscovery(
blockchain_service.node_address,
blockchain_service.discovery(discovery_contract_address),
)
except ContractVersionMismatch:
print('Deployed discovery contract version mismatch. '
'Please update your Raiden installation.')
sys.exit(1)
throttle_policy = TokenBucket(
config['transport']['throttle_capacity'],
config['transport']['throttle_fill_rate'],
)
transport = UDPTransport(
discovery,
mapped_socket.socket,
throttle_policy,
config['transport'],
)
elif transport == 'matrix':
# matrix gets spammed with the default retry-interval of 1s, wait a little more
if config['transport']['retry_interval'] == DEFAULT_TRANSPORT_RETRY_INTERVAL:
config['transport']['retry_interval'] *= 5
try:
transport = MatrixTransport(config['matrix'])
except RaidenError as ex:
click.secho(f'FATAL: {ex}', fg='red')
sys.exit(1)
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
try:
raiden_app = App(
config=config,
chain=blockchain_service,
query_start_block=constants.ID_TO_QUERY_BLOCK[net_id],
default_registry=token_network_registry,
default_secret_registry=secret_registry,
transport=transport,
discovery=discovery,
)
except RaidenError as e:
click.secho(f'FATAL: {e}', fg='red')
sys.exit(1)
return raiden_app
def app(
address,
keystore_path,
gas_price,
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.blockchain_service 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 = hexlify(privatekey_bin)
config['privatekey_hex'] = privatekey_hex
endpoint = eth_rpc_endpoint
# Fallback to 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
if not check_json_rpc(rpc_client):
sys.exit(1)
blockchain_service = BlockChainService(
privatekey_bin,
rpc_client,
GAS_LIMIT,
gas_price,
)
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 into this account.'
.format(discovery_tx_cost / denoms.ether, balance / 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 run_app(
address,
keystore_path,
gas_price,
eth_rpc_endpoint,
registry_contract_address,
secret_registry_contract_address,
discovery_contract_address,
listen_address,
mapped_socket,
max_unresponsive_time,
api_address,
rpc,
sync_check,
console,
password_file,
web_ui,
datadir,
transport,
matrix_server,
network_id,
network_type,
extra_config=None,
**kwargs,
):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
if not assert_sqlite_version():
log.error('SQLite3 should be at least version {}'.format(
'.'.join(SQLITE_MIN_REQUIRED_VERSION), ))
sys.exit(1)
if transport == 'udp' and not mapped_socket:
raise RuntimeError('Missing socket')
address_hex = to_normalized_address(address) if address else None
address_hex, privatekey_bin = prompt_account(address_hex, keystore_path,
password_file)
address = to_canonical_address(address_hex)
(listen_host, listen_port) = split_endpoint(listen_address)
(api_host, api_port) = split_endpoint(api_address)
if datadir is None:
datadir = os.path.join(os.path.expanduser('~'), '.raiden')
config = deepcopy(App.DEFAULT_CONFIG)
if extra_config:
merge_dict(config, extra_config)
config['transport']['udp']['host'] = listen_host
config['transport']['udp']['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['transport']['udp']['external_ip'] = mapped_socket.external_ip
config['transport']['udp'][
'external_port'] = mapped_socket.external_port
config['transport_type'] = transport
config['transport']['matrix']['server'] = matrix_server
config['transport']['udp'][
'nat_keepalive_retries'] = DEFAULT_NAT_KEEPALIVE_RETRIES
timeout = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES
config['transport']['udp']['nat_keepalive_timeout'] = timeout
privatekey_hex = hexlify(privatekey_bin)
config['privatekey_hex'] = privatekey_hex
parsed_eth_rpc_endpoint = urlparse(eth_rpc_endpoint)
if not parsed_eth_rpc_endpoint.scheme:
eth_rpc_endpoint = f'http://{eth_rpc_endpoint}'
web3 = Web3(HTTPProvider(eth_rpc_endpoint))
try:
node_version = web3.version.node # pylint: disable=no-member
except ConnectTimeout:
raise EthNodeCommunicationError(
"Couldn't connect to the ethereum node")
supported, _ = is_supported_client(node_version)
if not supported:
click.secho(
'You need a Byzantium enabled ethereum node. Parity >= 1.7.6 or Geth >= 1.7.2',
fg='red',
)
sys.exit(1)
rpc_client = JSONRPCClient(
web3,
privatekey_bin,
gas_price_strategy=gas_price,
)
blockchain_service = BlockChainService(privatekey_bin, rpc_client)
net_id = blockchain_service.network_id
if net_id != network_id:
if network_id in ID_TO_NETWORKNAME and net_id in ID_TO_NETWORKNAME:
click.secho(
f"The chosen ethereum network '{ID_TO_NETWORKNAME[network_id]}' "
f"differs from the ethereum client '{ID_TO_NETWORKNAME[net_id]}'. "
"Please update your settings.",
fg='red',
)
else:
click.secho(
f"The chosen ethereum network id '{network_id}' differs from the "
f"ethereum client '{net_id}'. "
"Please update your settings.",
fg='red',
)
sys.exit(1)
config['chain_id'] = network_id
if network_type == 'main':
config['network_type'] = NetworkType.MAIN
# Forcing private rooms to true for the mainnet
config['transport']['matrix']['private_rooms'] = True
else:
config['network_type'] = NetworkType.TEST
network_type = config['network_type']
chain_config = {}
contract_addresses_known = False
contract_addresses = dict()
if net_id in ID_TO_NETWORK_CONFIG:
network_config = ID_TO_NETWORK_CONFIG[net_id]
not_allowed = (NetworkType.TEST not in network_config
and network_type == NetworkType.TEST)
if not_allowed:
click.secho(
'The chosen network {} has no test configuration but a test network type '
'was given. This is not allowed.'.format(
ID_TO_NETWORKNAME[network_id], ),
fg='red',
)
sys.exit(1)
if network_type in network_config:
chain_config = network_config[network_type]
contract_addresses = chain_config['contract_addresses']
contract_addresses_known = True
if sync_check:
check_synced(blockchain_service)
contract_addresses_given = (registry_contract_address is not None and
secret_registry_contract_address is not None
and discovery_contract_address is not None)
if not contract_addresses_given and not contract_addresses_known:
click.secho(
f"There are no known contract addresses for network id '{net_id}'. "
"Please provide them in the command line or in the configuration file.",
fg='red',
)
sys.exit(1)
try:
token_network_registry = blockchain_service.token_network_registry(
registry_contract_address
or contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], )
except ContractVersionMismatch:
handle_contract_version_mismatch('token network registry',
registry_contract_address)
except AddressWithoutCode:
handle_contract_no_code('token network registry',
registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address('token network registry',
registry_contract_address)
try:
secret_registry = blockchain_service.secret_registry(
secret_registry_contract_address
or contract_addresses[CONTRACT_SECRET_REGISTRY], )
except ContractVersionMismatch:
handle_contract_version_mismatch('secret registry',
secret_registry_contract_address)
except AddressWithoutCode:
handle_contract_no_code('secret registry',
secret_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address('secret registry',
secret_registry_contract_address)
database_path = os.path.join(
datadir,
f'node_{pex(address)}',
f'netid_{net_id}',
f'network_{pex(token_network_registry.address)}',
f'v{RAIDEN_DB_VERSION}_log.db',
)
config['database_path'] = database_path
print(
'\nYou are connected to the \'{}\' network and the DB path is: {}'.
format(
ID_TO_NETWORKNAME.get(net_id) or net_id,
database_path,
), )
discovery = None
if transport == 'udp':
check_discovery_registration_gas(blockchain_service, address)
try:
dicovery_proxy = blockchain_service.discovery(
discovery_contract_address
or contract_addresses[CONTRACT_ENDPOINT_REGISTRY], )
discovery = ContractDiscovery(
blockchain_service.node_address,
dicovery_proxy,
)
except ContractVersionMismatch:
handle_contract_version_mismatch('discovery',
discovery_contract_address)
except AddressWithoutCode:
handle_contract_no_code('discovery', discovery_contract_address)
except AddressWrongContract:
handle_contract_wrong_address('discovery',
discovery_contract_address)
throttle_policy = TokenBucket(
config['transport']['udp']['throttle_capacity'],
config['transport']['udp']['throttle_fill_rate'],
)
transport = UDPTransport(
discovery,
mapped_socket.socket,
throttle_policy,
config['transport']['udp'],
)
elif transport == 'matrix':
try:
transport = MatrixTransport(config['transport']['matrix'])
except RaidenError as ex:
click.secho(f'FATAL: {ex}', fg='red')
sys.exit(1)
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
raiden_event_handler = RaidenEventHandler()
try:
start_block = chain_config.get(START_QUERY_BLOCK_KEY, 0)
raiden_app = App(
config=config,
chain=blockchain_service,
query_start_block=start_block,
default_registry=token_network_registry,
default_secret_registry=secret_registry,
transport=transport,
raiden_event_handler=raiden_event_handler,
discovery=discovery,
)
except RaidenError as e:
click.secho(f'FATAL: {e}', fg='red')
sys.exit(1)
try:
raiden_app.start()
except RuntimeError as e:
click.secho(f'FATAL: {e}', fg='red')
sys.exit(1)
except filelock.Timeout:
name_or_id = ID_TO_NETWORKNAME.get(network_id, network_id)
click.secho(
f'FATAL: Another Raiden instance already running for account {address_hex} on '
f'network id {name_or_id}',
fg='red',
)
sys.exit(1)
return raiden_app
def app(
address,
keystore_path,
gas_price,
eth_rpc_endpoint,
registry_contract_address,
discovery_contract_address,
listen_address,
rpccorsdomain,
mapped_socket,
log_config,
log_file,
log_json,
max_unresponsive_time,
send_ping_time,
api_address,
rpc,
sync_check,
console,
password_file,
web_ui,
datadir,
eth_client_communication,
nat,
transport,
matrix_server
):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
from raiden.network.blockchain_service import BlockChainService
if transport == 'udp' and not mapped_socket:
raise RuntimeError('Missing socket')
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)
(listen_host, listen_port) = split_endpoint(listen_address)
(api_host, api_port) = split_endpoint(api_address)
if datadir is None:
datadir = os.path.join(os.path.expanduser('~'), '.raiden')
config = deepcopy(App.DEFAULT_CONFIG)
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
config['transport_type'] = transport
config['matrix']['server'] = matrix_server
config['protocol']['nat_keepalive_retries'] = DEFAULT_NAT_KEEPALIVE_RETRIES
timeout = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES
config['protocol']['nat_keepalive_timeout'] = timeout
privatekey_hex = hexlify(privatekey_bin)
config['privatekey_hex'] = privatekey_hex
endpoint = eth_rpc_endpoint
# Fallback to 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,
gas_price,
)
blockchain_service = BlockChainService(
privatekey_bin,
rpc_client,
gas_price,
)
# this assumes the eth node is already online
check_json_rpc(rpc_client)
if sync_check:
check_synced(blockchain_service)
net_id = blockchain_service.network_id
database_path = os.path.join(datadir, 'netid_%s' % net_id, address_hex[:8], 'log.db')
config['database_path'] = database_path
print(
'You are connected to the \'{}\' network and the DB path is: {}'.format(
ID_TO_NETWORKNAME[net_id],
database_path,
)
)
try:
registry = blockchain_service.registry(
registry_contract_address,
)
except ContractVersionMismatch:
print(
'Deployed registry contract version mismatch. '
'Please update your Raiden installation.'
)
sys.exit(1)
discovery = None
if transport == 'udp':
check_discovery_registration_gas(blockchain_service, address)
try:
discovery = ContractDiscovery(
blockchain_service.node_address,
blockchain_service.discovery(discovery_contract_address)
)
except ContractVersionMismatch:
print('Deployed discovery contract version mismatch. '
'Please update your Raiden installation.')
sys.exit(1)
throttle_policy = TokenBucket(
config['protocol']['throttle_capacity'],
config['protocol']['throttle_fill_rate']
)
transport = UDPTransport(
discovery,
mapped_socket.socket,
throttle_policy,
config['protocol'],
)
elif transport == 'matrix':
transport = MatrixTransport(config['matrix'])
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
raiden_app = App(
config,
blockchain_service,
registry,
transport,
discovery,
)
return raiden_app