def check_ethereum_network_id(given_network_id: ChainID, web3: Web3) -> None:
"""
Takes the given network id and checks it against the connected network
If they don't match, exits the program with an error. If they do adds it
to the configuration and then returns it and whether it is a known network
"""
node_network_id = ChainID(int(web3.version.network)) # pylint: disable=no-member
if node_network_id != given_network_id:
given_name = ID_TO_NETWORKNAME.get(given_network_id)
network_name = ID_TO_NETWORKNAME.get(node_network_id)
given_description = f'{given_name or "Unknown"} (id {given_network_id})'
network_description = f'{network_name or "Unknown"} (id {node_network_id})'
# TODO: fix cyclic import
from raiden.ui.cli import ETH_NETWORKID_OPTION
raise RaidenError(
f"The configured network {given_description} differs "
f"from the Ethereum client's network {network_description}. The "
f"network_id can be configured using the flag {ETH_NETWORKID_OPTION}"
f"Please check your settings."
)
def check_ethereum_network_id(given_network_id: int, web3: Web3) -> None:
"""
Takes the given network id and checks it against the connected network
If they don't match, exits the program with an error. If they do adds it
to the configuration and then returns it and whether it is a known network
"""
node_network_id = int(web3.version.network) # pylint: disable=no-member
if node_network_id != given_network_id:
given_name = ID_TO_NETWORKNAME.get(given_network_id)
network_name = ID_TO_NETWORKNAME.get(node_network_id)
given_description = f'{given_name or "Unknown"} (id {given_network_id})'
network_description = f'{network_name or "Unknown"} (id {node_network_id})'
msg = (f"The configured network {given_description} differs "
f"from the Ethereum client's network {network_description}. "
f"Please check your settings.")
click.secho(msg, fg="red")
sys.exit(1)
def make_room_alias(chain_id: ChainID, *suffixes: str) -> str:
"""Given a chain_id and any number of suffixes (broadcast room names, pair of addresses),
compose and return the canonical room name for raiden network
network name from raiden_contracts.constants.ID_TO_NETWORKNAME is used for name, if available,
else numeric id
Params:
chain_id: numeric blockchain id for that room, as raiden rooms are per-chain specific
*suffixes: one or more suffixes for the name
Returns:
Qualified full room name. e.g.:
make_room_alias(3, 'discovery') == 'raiden_ropsten_discovery'
"""
network_name = ID_TO_NETWORKNAME.get(chain_id, str(chain_id))
return ROOM_NAME_SEPARATOR.join([ROOM_NAME_PREFIX, network_name, *suffixes])
def check_synced(rpc_client: JSONRPCClient) -> None:
network_id = ChainID(int(rpc_client.web3.version.network))
network_name = ID_TO_NETWORKNAME.get(network_id)
if network_name is None:
raise RaidenError(
f"Your ethereum client is connected to a non-recognized private "
f"network with network-ID {network_id}. Since we can not check if the "
f"client is synced please restart raiden with the --no-sync-check "
f"argument."
)
url = ETHERSCAN_API.format(
network=network_name if network_id != 1 else "api", action="eth_blockNumber"
)
wait_for_sync(
rpc_client=rpc_client, url=url, tolerance=ORACLE_BLOCKNUMBER_DRIFT_TOLERANCE, sleep=3
)
def check_synced(proxy_manager: ProxyManager) -> None:
network_id = ChainID(int(proxy_manager.client.web3.version.network))
network_name = ID_TO_NETWORKNAME.get(network_id)
if network_name is None:
msg = (
f"Your ethereum client is connected to a non-recognized private "
f"network with network-ID {network_id}. Since we can not check if the "
f"client is synced please restart raiden with the --no-sync-check "
f"argument."
)
click.secho(msg, fg="red")
sys.exit(1)
url = ETHERSCAN_API.format(
network=network_name if network_id != 1 else "api", action="eth_blockNumber"
)
wait_for_sync(proxy_manager, url=url, tolerance=ORACLE_BLOCKNUMBER_DRIFT_TOLERANCE, sleep=3)
def run_app(
address,
keystore_path,
gas_price,
eth_rpc_endpoint,
tokennetwork_registry_contract_address,
secret_registry_contract_address,
endpoint_registry_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,
environment_type,
unrecoverable_error_should_crash,
pathfinding_service_address,
config=None,
extra_config=None,
**kwargs,
):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
_assert_sql_version()
if transport == 'udp' and not mapped_socket:
raise RuntimeError('Missing socket')
if datadir is None:
datadir = os.path.join(os.path.expanduser('~'), '.raiden')
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)
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
config['privatekey_hex'] = encode_hex(privatekey_bin)
config[
'unrecoverable_error_should_crash'] = unrecoverable_error_should_crash
config['services'][
'pathfinding_service_address'] = pathfinding_service_address
parsed_eth_rpc_endpoint = urlparse(eth_rpc_endpoint)
if not parsed_eth_rpc_endpoint.scheme:
eth_rpc_endpoint = f'http://{eth_rpc_endpoint}'
web3 = _setup_web3(eth_rpc_endpoint)
rpc_client = JSONRPCClient(
web3,
privatekey_bin,
gas_price_strategy=gas_price,
block_num_confirmations=DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
uses_infura='infura.io' in eth_rpc_endpoint,
)
blockchain_service = BlockChainService(
privatekey_bin=privatekey_bin,
jsonrpc_client=rpc_client,
# Not giving the contract manager here, but injecting it later
# since we first need blockchain service to calculate the network id
)
given_network_id = network_id
node_network_id = blockchain_service.network_id
known_given_network_id = given_network_id in ID_TO_NETWORKNAME
known_node_network_id = node_network_id in ID_TO_NETWORKNAME
if node_network_id != given_network_id:
if known_given_network_id and known_node_network_id:
click.secho(
f"The chosen ethereum network '{ID_TO_NETWORKNAME[given_network_id]}' "
f"differs from the ethereum client '{ID_TO_NETWORKNAME[node_network_id]}'. "
"Please update your settings.",
fg='red',
)
else:
click.secho(
f"The chosen ethereum network id '{given_network_id}' differs "
f"from the ethereum client '{node_network_id}'. "
"Please update your settings.",
fg='red',
)
sys.exit(1)
config['chain_id'] = given_network_id
# interpret the provided string argument
if environment_type == Environment.PRODUCTION:
# Safe configuration: restrictions for mainnet apply and matrix rooms have to be private
config['environment_type'] = Environment.PRODUCTION
config['transport']['matrix']['private_rooms'] = True
else:
config['environment_type'] = Environment.DEVELOPMENT
environment_type = config['environment_type']
print(f'Raiden is running in {environment_type.value.lower()} mode')
chain_config = {}
contract_addresses_known = False
contracts = dict()
contracts_version = 'pre_limits' if environment_type == Environment.DEVELOPMENT else None
config['contracts_path'] = contracts_precompiled_path(contracts_version)
if node_network_id in ID_TO_NETWORKNAME and ID_TO_NETWORKNAME[
node_network_id] != 'smoketest':
deployment_data = get_contracts_deployed(node_network_id,
contracts_version)
not_allowed = ( # for now we only disallow mainnet with test configuration
network_id == 1 and environment_type == Environment.DEVELOPMENT)
if not_allowed:
click.secho(
f'The chosen network ({ID_TO_NETWORKNAME[node_network_id]}) is not a testnet, '
'but the "development" environment was selected.\n'
'This is not allowed. Please start again with a safe environment setting '
'(--environment production).',
fg='red',
)
sys.exit(1)
contracts = deployment_data['contracts']
contract_addresses_known = True
blockchain_service.inject_contract_manager(
ContractManager(config['contracts_path']))
if sync_check:
check_synced(blockchain_service, known_node_network_id)
contract_addresses_given = (
tokennetwork_registry_contract_address is not None
and secret_registry_contract_address is not None
and endpoint_registry_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 '{given_network_id}'. "
"Please provide them on the command line or in the configuration file.",
fg='red',
)
sys.exit(1)
try:
token_network_registry = blockchain_service.token_network_registry(
tokennetwork_registry_contract_address or to_canonical_address(
contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]['address'], ), )
except ContractVersionMismatch as e:
handle_contract_version_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code('token network registry',
tokennetwork_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address(
'token network registry',
tokennetwork_registry_contract_address,
)
try:
secret_registry = blockchain_service.secret_registry(
secret_registry_contract_address or to_canonical_address(
contracts[CONTRACT_SECRET_REGISTRY]['address'], ), )
except ContractVersionMismatch as e:
handle_contract_version_mismatch(e)
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_{given_network_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(given_network_id, given_network_id),
database_path,
), )
discovery = None
if transport == 'udp':
transport, discovery = _setup_udp(
config,
blockchain_service,
address,
contracts,
endpoint_registry_contract_address,
)
elif transport == 'matrix':
transport = _setup_matrix(config)
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
try:
if 'contracts' in chain_config:
start_block = chain_config['contracts']['TokenNetworkRegistry'][
'block_number']
else:
start_block = 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,
message_handler=message_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(given_network_id, given_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 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,
config=None,
extra_config=None,
**kwargs,
):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
_assert_sql_version()
if transport == 'udp' and not mapped_socket:
raise RuntimeError('Missing socket')
if datadir is None:
datadir = os.path.join(os.path.expanduser('~'), '.raiden')
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)
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 = _setup_web3(eth_rpc_endpoint)
rpc_client = JSONRPCClient(
web3,
privatekey_bin,
gas_price_strategy=gas_price,
)
blockchain_service = BlockChainService(privatekey_bin, rpc_client)
given_numeric_network_id = network_id.value if isinstance(network_id, ChainId) else network_id
node_numeric_network_id = blockchain_service.network_id
known_given_network_id = networkid_is_known(given_numeric_network_id)
known_node_network_id = networkid_is_known(node_numeric_network_id)
if known_given_network_id:
given_network_id = ChainId(given_numeric_network_id)
if known_node_network_id:
node_network_id = ChainId(node_numeric_network_id)
if node_numeric_network_id != given_numeric_network_id:
if known_given_network_id and known_node_network_id:
click.secho(
f"The chosen ethereum network '{given_network_id.name.lower()}' "
f"differs from the ethereum client '{node_network_id.name.lower()}'. "
"Please update your settings.",
fg='red',
)
else:
click.secho(
f"The chosen ethereum network id '{given_numeric_network_id}' differs "
f"from the ethereum client '{node_numeric_network_id}'. "
"Please update your settings.",
fg='red',
)
sys.exit(1)
config['chain_id'] = given_numeric_network_id
log.debug('Network type', type=network_type)
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 node_network_id in ID_TO_NETWORK_CONFIG:
network_config = ID_TO_NETWORK_CONFIG[node_network_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[node_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, known_node_network_id)
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 '{given_numeric_network_id}'. "
"Please provide them on 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_{given_numeric_network_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(given_network_id, given_numeric_network_id),
database_path,
),
)
discovery = None
if transport == 'udp':
transport, discovery = _setup_udp(
config,
blockchain_service,
address,
contract_addresses,
discovery_contract_address,
)
elif transport == 'matrix':
transport = _setup_matrix(config)
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
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,
message_handler=message_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(given_network_id, given_numeric_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 run_app(
address,
keystore_path,
gas_price,
eth_rpc_endpoint,
tokennetwork_registry_contract_address,
secret_registry_contract_address,
service_registry_contract_address,
endpoint_registry_contract_address,
user_deposit_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,
environment_type,
unrecoverable_error_should_crash,
pathfinding_service_address,
pathfinding_eth_address,
pathfinding_max_paths,
enable_monitoring,
routing_mode,
config=None,
extra_config=None,
**kwargs,
):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
_assert_sql_version()
if transport == 'udp' and not mapped_socket:
raise RuntimeError('Missing socket')
if datadir is None:
datadir = os.path.join(os.path.expanduser('~'), '.raiden')
account_manager = AccountManager(keystore_path)
check_has_accounts(account_manager)
if not address:
address_hex = prompt_account(account_manager)
else:
address_hex = to_normalized_address(address)
if password_file:
privatekey_bin = unlock_account_with_passwordfile(
account_manager,
address_hex,
password_file,
)
else:
privatekey_bin = unlock_account_with_passwordprompt(
account_manager,
address_hex,
)
address = to_canonical_address(address_hex)
(listen_host, listen_port) = split_endpoint(listen_address)
(api_host, api_port) = split_endpoint(api_address)
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
config[
'unrecoverable_error_should_crash'] = unrecoverable_error_should_crash
config['services']['pathfinding_max_paths'] = pathfinding_max_paths
config['services']['monitoring_enabled'] = enable_monitoring
parsed_eth_rpc_endpoint = urlparse(eth_rpc_endpoint)
if not parsed_eth_rpc_endpoint.scheme:
eth_rpc_endpoint = f'http://{eth_rpc_endpoint}'
web3 = _setup_web3(eth_rpc_endpoint)
node_network_id, known_node_network_id = setup_network_id_or_exit(
config, network_id, web3)
environment_type = setup_environment(config, environment_type)
contracts, contract_addresses_known = setup_contracts_or_exit(
config, node_network_id)
rpc_client = JSONRPCClient(
web3,
privatekey_bin,
gas_price_strategy=gas_price,
block_num_confirmations=DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
uses_infura='infura.io' in eth_rpc_endpoint,
)
blockchain_service = BlockChainService(
jsonrpc_client=rpc_client,
contract_manager=ContractManager(config['contracts_path']),
)
if sync_check:
check_synced(blockchain_service, known_node_network_id)
proxies = setup_proxies_or_exit(
config=config,
tokennetwork_registry_contract_address=
tokennetwork_registry_contract_address,
secret_registry_contract_address=secret_registry_contract_address,
endpoint_registry_contract_address=endpoint_registry_contract_address,
user_deposit_contract_address=user_deposit_contract_address,
service_registry_contract_address=service_registry_contract_address,
contract_addresses_known=contract_addresses_known,
blockchain_service=blockchain_service,
contracts=contracts,
routing_mode=routing_mode,
pathfinding_service_address=pathfinding_service_address,
pathfinding_eth_address=pathfinding_eth_address,
)
database_path = os.path.join(
datadir,
f'node_{pex(address)}',
f'netid_{node_network_id}',
f'network_{pex(proxies.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(node_network_id, node_network_id),
database_path,
), )
discovery = None
if transport == 'udp':
transport, discovery = setup_udp_or_exit(
config,
blockchain_service,
address,
contracts,
endpoint_registry_contract_address,
)
elif transport == 'matrix':
transport = _setup_matrix(config)
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
try:
start_block = 0
if 'TokenNetworkRegistry' in contracts:
start_block = contracts['TokenNetworkRegistry']['block_number']
raiden_app = App(
config=config,
chain=blockchain_service,
query_start_block=start_block,
default_registry=proxies.token_network_registry,
default_secret_registry=proxies.secret_registry,
default_service_registry=proxies.service_registry,
transport=transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=discovery,
user_deposit=proxies.user_deposit,
)
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(node_network_id, node_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 setup_proxies_or_exit(
config: Dict[str, Any],
tokennetwork_registry_contract_address: Address,
secret_registry_contract_address: Address,
endpoint_registry_contract_address: Address,
user_deposit_contract_address: Address,
service_registry_contract_address: Address,
blockchain_service: BlockChainService,
contracts: Dict[str, Any],
routing_mode: RoutingMode,
pathfinding_service_address: str,
) -> Proxies:
"""
Initialize and setup the contract proxies.
Depending on the provided contract addresses via the CLI, the routing mode,
the environment type and the network id try to initialize the proxies.
Returns the initialized proxies or exits the application with an error if
there is a problem.
Also depending on the given arguments populate config with PFS related settings
"""
node_network_id = config["chain_id"]
environment_type = config["environment_type"]
check_smart_contract_addresses(
environment_type,
node_network_id,
tokennetwork_registry_contract_address,
secret_registry_contract_address,
endpoint_registry_contract_address,
contracts,
)
try:
registered_address: Address
if tokennetwork_registry_contract_address is not None:
registered_address = Address(
tokennetwork_registry_contract_address)
else:
registered_address = to_canonical_address(
contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]["address"])
token_network_registry = blockchain_service.token_network_registry(
registered_address)
except ContractVersionMismatch as e:
handle_contract_version_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code("token network registry",
tokennetwork_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address("token network registry",
tokennetwork_registry_contract_address)
try:
secret_registry = blockchain_service.secret_registry(
secret_registry_contract_address or to_canonical_address(
contracts[CONTRACT_SECRET_REGISTRY]["address"]))
except ContractVersionMismatch as e:
handle_contract_version_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code("secret registry",
secret_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address("secret registry",
secret_registry_contract_address)
# If services contracts are provided via the CLI use them instead
if user_deposit_contract_address is not None:
contracts[CONTRACT_USER_DEPOSIT] = user_deposit_contract_address
if service_registry_contract_address is not None:
contracts[
CONTRACT_SERVICE_REGISTRY] = service_registry_contract_address
user_deposit = None
should_use_user_deposit = (
environment_type == Environment.DEVELOPMENT
and ID_TO_NETWORKNAME.get(node_network_id) != "smoketest"
and CONTRACT_USER_DEPOSIT in contracts)
if should_use_user_deposit:
try:
user_deposit = blockchain_service.user_deposit(
user_deposit_contract_address or to_canonical_address(
contracts[CONTRACT_USER_DEPOSIT]["address"]))
except ContractVersionMismatch as e:
handle_contract_version_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code("user deposit",
user_deposit_contract_address)
except AddressWrongContract:
handle_contract_wrong_address("user_deposit",
user_deposit_contract_address)
service_registry = None
if CONTRACT_SERVICE_REGISTRY in contracts or service_registry_contract_address:
try:
service_registry = blockchain_service.service_registry(
service_registry_contract_address or to_canonical_address(
contracts[CONTRACT_SERVICE_REGISTRY]["address"]))
except ContractVersionMismatch as e:
handle_contract_version_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code("service registry",
service_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address("secret registry",
service_registry_contract_address)
if routing_mode == RoutingMode.PFS:
check_pfs_configuration(routing_mode, environment_type,
service_registry, pathfinding_service_address)
pfs_config = configure_pfs_or_exit(
pfs_address=pathfinding_service_address,
routing_mode=routing_mode,
service_registry=service_registry,
)
msg = "Eth address of selected pathfinding service is unknown."
assert pfs_config.eth_address is not None, msg
config["services"]["pathfinding_service_address"] = pfs_config.url
config["services"]["pathfinding_eth_address"] = pfs_config.eth_address
config["services"]["pathfinding_fee"] = pfs_config.fee
else:
config["services"]["pathfinding_service_address"] = None
config["services"]["pathfinding_eth_address"] = None
proxies = Proxies(
token_network_registry=token_network_registry,
secret_registry=secret_registry,
user_deposit=user_deposit,
service_registry=service_registry,
)
return proxies
def run_app(
address: Address,
keystore_path: str,
gas_price: Callable,
eth_rpc_endpoint: str,
tokennetwork_registry_contract_address: Address,
one_to_n_contract_address: Address,
secret_registry_contract_address: Address,
service_registry_contract_address: Address,
endpoint_registry_contract_address: Address,
user_deposit_contract_address: Address,
listen_address: str,
mapped_socket,
max_unresponsive_time: int,
api_address: str,
rpc: bool,
sync_check: bool,
console: bool,
password_file: TextIO,
web_ui: bool,
datadir: str,
transport: str,
matrix_server: str,
network_id: int,
environment_type: Environment,
unrecoverable_error_should_crash: bool,
pathfinding_service_address: str,
pathfinding_max_paths: int,
enable_monitoring: bool,
resolver_endpoint: str,
routing_mode: RoutingMode,
config: Dict[str, Any],
**kwargs: Any, # FIXME: not used here, but still receives stuff in smoketest
):
# 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")
if datadir is None:
datadir = os.path.join(os.path.expanduser("~"), ".raiden")
account_manager = AccountManager(keystore_path)
web3 = Web3(HTTPProvider(rpc_normalized_endpoint(eth_rpc_endpoint)))
check_sql_version()
check_ethereum_has_accounts(account_manager)
check_ethereum_client_is_supported(web3)
check_ethereum_network_id(network_id, web3)
(address, privatekey_bin, pubkey_bin) = get_account_and_private_key(
account_manager, address, password_file
)
(listen_host, listen_port) = split_endpoint(listen_address)
(api_host, api_port) = split_endpoint(api_address)
print("Private key: " + encode_hex(privatekey_bin))
print("Public key: " + encode_hex(pubkey_bin))
config["pubkey"] = pubkey_bin
config["privatekey"] = privatekey_bin
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
config["resolver_endpoint"] = resolver_endpoint
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
config["unrecoverable_error_should_crash"] = unrecoverable_error_should_crash
config["services"]["pathfinding_max_paths"] = pathfinding_max_paths
config["services"]["monitoring_enabled"] = enable_monitoring
config["chain_id"] = network_id
setup_environment(config, environment_type)
contracts = setup_contracts_or_exit(config, network_id)
rpc_client = JSONRPCClient(
web3,
privatekey_bin,
gas_price_strategy=gas_price,
block_num_confirmations=DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
uses_infura="infura.io" in eth_rpc_endpoint,
)
blockchain_service = BlockChainService(
jsonrpc_client=rpc_client, contract_manager=ContractManager(config["contracts_path"])
)
if sync_check:
check_synced(blockchain_service)
proxies = setup_proxies_or_exit(
config=config,
tokennetwork_registry_contract_address=tokennetwork_registry_contract_address,
secret_registry_contract_address=secret_registry_contract_address,
endpoint_registry_contract_address=endpoint_registry_contract_address,
user_deposit_contract_address=user_deposit_contract_address,
service_registry_contract_address=service_registry_contract_address,
blockchain_service=blockchain_service,
contracts=contracts,
routing_mode=routing_mode,
pathfinding_service_address=pathfinding_service_address,
)
database_path = os.path.join(
datadir,
f"node_{pex(address)}",
f"netid_{network_id}",
f"network_{pex(proxies.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(network_id, network_id), database_path
)
)
# FIXME mmartinez this must be checksummed or compared on a standard way
# running_network = {"network_id": network_id,
# "token_network_registry": encode_hex(tokennetwork_registry_contract_address),
# "secret_registry": encode_hex(secret_registry_contract_address),
# "endpoint_registry": encode_hex(endpoint_registry_contract_address)}
# check_network_params(running_network)
discovery = None
if transport == "udp":
transport, discovery = setup_udp_or_exit(
config, blockchain_service, address, contracts, endpoint_registry_contract_address
)
elif transport == "matrix":
transport = _setup_matrix(config)
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
try:
start_block = 0
if "TokenNetworkRegistry" in contracts:
start_block = contracts["TokenNetworkRegistry"]["block_number"]
raiden_app = App(
config=config,
chain=blockchain_service,
query_start_block=BlockNumber(start_block),
default_one_to_n_address=one_to_n_contract_address,
default_registry=proxies.token_network_registry,
default_secret_registry=proxies.secret_registry,
default_service_registry=proxies.service_registry,
transport=transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=discovery,
user_deposit=proxies.user_deposit,
)
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 "
f"{to_normalized_address(address)} on network id {name_or_id}",
fg="red",
)
sys.exit(1)
return raiden_app
def run_app(
address: Address,
keystore_path: str,
gas_price: Callable,
eth_rpc_endpoint: str,
tokennetwork_registry_contract_address: TokenNetworkRegistryAddress,
one_to_n_contract_address: Address,
secret_registry_contract_address: Address,
service_registry_contract_address: Address,
user_deposit_contract_address: Address,
monitoring_service_contract_address: Address,
api_address: Endpoint,
rpc: bool,
sync_check: bool,
console: bool,
password_file: TextIO,
web_ui: bool,
datadir: str,
transport: str,
matrix_server: str,
network_id: ChainID,
environment_type: Environment,
unrecoverable_error_should_crash: bool,
pathfinding_service_address: str,
pathfinding_max_paths: int,
enable_monitoring: bool,
resolver_endpoint: str,
routing_mode: RoutingMode,
config: Dict[str, Any],
flat_fee: Tuple[Tuple[TokenAddress, FeeAmount], ...],
proportional_fee: Tuple[Tuple[TokenAddress, ProportionalFeeAmount],
...],
proportional_imbalance_fee: Tuple[Tuple[TokenAddress,
ProportionalFeeAmount], ...],
blockchain_query_interval: float,
cap_mediation_fees: bool,
**
kwargs: Any, # FIXME: not used here, but still receives stuff in smoketest
) -> App:
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
token_network_registry_deployed_at: Optional[BlockNumber]
smart_contracts_start_at: BlockNumber
if datadir is None:
datadir = os.path.join(os.path.expanduser("~"), ".raiden")
account_manager = AccountManager(keystore_path)
web3 = Web3(HTTPProvider(rpc_normalized_endpoint(eth_rpc_endpoint)))
check_sql_version()
check_ethereum_has_accounts(account_manager)
check_ethereum_client_is_supported(web3)
check_ethereum_network_id(network_id, web3)
address, privatekey = get_account_and_private_key(account_manager, address,
password_file)
api_host, api_port = split_endpoint(api_address)
if not api_port:
api_port = Port(DEFAULT_HTTP_SERVER_PORT)
fee_config = prepare_mediation_fee_config(
cli_token_to_flat_fee=flat_fee,
cli_token_to_proportional_fee=proportional_fee,
cli_token_to_proportional_imbalance_fee=proportional_imbalance_fee,
cli_cap_mediation_fees=cap_mediation_fees,
)
config["console"] = console
config["rpc"] = rpc
config["web_ui"] = rpc and web_ui
config["api_host"] = api_host
config["api_port"] = api_port
config["resolver_endpoint"] = resolver_endpoint
config["transport_type"] = transport
config["transport"]["matrix"]["server"] = matrix_server
config[
"unrecoverable_error_should_crash"] = unrecoverable_error_should_crash
config["services"]["pathfinding_max_paths"] = pathfinding_max_paths
config["services"]["monitoring_enabled"] = enable_monitoring
config["chain_id"] = network_id
config["mediation_fees"] = fee_config
config["blockchain"]["query_interval"] = blockchain_query_interval
setup_environment(config, environment_type)
contracts = setup_contracts_or_exit(config, network_id)
rpc_client = JSONRPCClient(
web3=web3,
privkey=privatekey,
gas_price_strategy=gas_price,
block_num_confirmations=DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
)
token_network_registry_deployed_at = None
if "TokenNetworkRegistry" in contracts:
token_network_registry_deployed_at = BlockNumber(
contracts["TokenNetworkRegistry"]["block_number"])
if token_network_registry_deployed_at is None:
smart_contracts_start_at = get_smart_contracts_start_at(network_id)
else:
smart_contracts_start_at = token_network_registry_deployed_at
proxy_manager = ProxyManager(
rpc_client=rpc_client,
contract_manager=ContractManager(config["contracts_path"]),
metadata=ProxyManagerMetadata(
token_network_registry_deployed_at=
token_network_registry_deployed_at,
filters_start_at=smart_contracts_start_at,
),
)
if sync_check:
check_synced(proxy_manager)
proxies = setup_proxies_or_exit(
config=config,
tokennetwork_registry_contract_address=
tokennetwork_registry_contract_address,
secret_registry_contract_address=secret_registry_contract_address,
user_deposit_contract_address=user_deposit_contract_address,
service_registry_contract_address=service_registry_contract_address,
proxy_manager=proxy_manager,
contracts=contracts,
routing_mode=routing_mode,
pathfinding_service_address=pathfinding_service_address,
)
check_ethereum_confirmed_block_is_not_pruned(
jsonrpc_client=rpc_client,
secret_registry=proxies.secret_registry,
confirmation_blocks=config["blockchain"]["confirmation_blocks"],
)
database_path = os.path.join(
datadir,
f"node_{pex(address)}",
f"netid_{network_id}",
f"network_{pex(proxies.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(network_id, network_id), database_path))
if transport == "matrix":
matrix_transport = _setup_matrix(config, routing_mode)
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
event_handler: EventHandler = RaidenEventHandler()
# User should be told how to set fees, if using default fee settings
log.debug("Fee Settings", fee_settings=fee_config)
has_default_fees = (len(fee_config.token_to_flat_fee) == 0
and len(fee_config.token_to_proportional_fee) == 0
and len(fee_config.token_to_proportional_imbalance_fee)
== 0)
if has_default_fees:
click.secho(
"Default fee settings are used. "
"If you want use Raiden with mediation fees - flat, proportional and imbalance fees - "
"see https://raiden-network.readthedocs.io/en/latest/overview_and_guide.html#firing-it-up", # noqa: E501
fg="yellow",
)
monitoring_contract_required = (enable_monitoring
and CONTRACT_MONITORING_SERVICE
not in contracts)
if monitoring_contract_required:
click.secho(
"Monitoring is enabled but the contract for this ethereum network was not found. "
"Please provide monitoring service contract address using "
"--monitoring-service-address.",
fg="red",
)
sys.exit(1)
# Only send feedback when PFS is used
if routing_mode == RoutingMode.PFS:
event_handler = PFSFeedbackEventHandler(event_handler)
message_handler = MessageHandler()
try:
raiden_app = App(
config=config,
rpc_client=rpc_client,
proxy_manager=proxy_manager,
query_start_block=smart_contracts_start_at,
default_one_to_n_address=(one_to_n_contract_address or
contracts[CONTRACT_ONE_TO_N]["address"]),
default_registry=proxies.token_network_registry,
default_secret_registry=proxies.secret_registry,
default_service_registry=proxies.service_registry,
default_msc_address=(
monitoring_service_contract_address
or contracts[CONTRACT_MONITORING_SERVICE]["address"]),
transport=matrix_transport,
raiden_event_handler=event_handler,
message_handler=message_handler,
routing_mode=routing_mode,
user_deposit=proxies.user_deposit,
)
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 "
f"{to_checksum_address(address)} on network id {name_or_id}",
fg="red",
)
sys.exit(1)
return raiden_app
def setup_proxies_or_exit(
config: Dict[str, Any],
tokennetwork_registry_contract_address: str,
secret_registry_contract_address: str,
endpoint_registry_contract_address: str,
user_deposit_contract_address: str,
service_registry_contract_address: str,
contract_addresses_known: bool,
blockchain_service: BlockChainService,
contracts: Dict[str, Any],
routing_mode: RoutingMode,
pathfinding_service_address: str,
pathfinding_eth_address: str,
) -> Proxies:
"""
Initialize and setup the contract proxies.
Depending on the provided contract addresses via the CLI, the routing mode,
the environment type and the network id try to initialize the proxies.
Returns the initialized proxies or exits the application with an error if
there is a problem.
Also depending on the given arguments populate config with PFS related settings
"""
node_network_id = config['chain_id']
environment_type = config['environment_type']
contract_addresses_given = (
tokennetwork_registry_contract_address is not None
and secret_registry_contract_address is not None
and endpoint_registry_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 '{node_network_id}'. and "
f"environment type {environment_type}. Please provide them on the command line or "
f"in the configuration file.",
fg='red',
)
sys.exit(1)
try:
token_network_registry = blockchain_service.token_network_registry(
tokennetwork_registry_contract_address or to_canonical_address(
contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]['address'], ), )
except ContractVersionMismatch as e:
handle_contract_version_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code('token network registry',
tokennetwork_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address(
'token network registry',
tokennetwork_registry_contract_address,
)
try:
secret_registry = blockchain_service.secret_registry(
secret_registry_contract_address or to_canonical_address(
contracts[CONTRACT_SECRET_REGISTRY]['address'], ), )
except ContractVersionMismatch as e:
handle_contract_version_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code('secret registry',
secret_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address('secret registry',
secret_registry_contract_address)
# If services contracts are provided via the CLI use them instead
if user_deposit_contract_address is not None:
contracts[CONTRACT_USER_DEPOSIT] = user_deposit_contract_address
if service_registry_contract_address is not None:
contracts[CONTRACT_SERVICE_REGISTRY] = (
service_registry_contract_address)
user_deposit = None
should_use_user_deposit = (
environment_type == Environment.DEVELOPMENT
and ID_TO_NETWORKNAME.get(node_network_id) != 'smoketest'
and CONTRACT_USER_DEPOSIT in contracts)
if should_use_user_deposit:
try:
user_deposit = blockchain_service.user_deposit(
user_deposit_contract_address or to_canonical_address(
contracts[CONTRACT_USER_DEPOSIT]['address'], ), )
except ContractVersionMismatch as e:
handle_contract_version_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code('user deposit',
user_deposit_contract_address)
except AddressWrongContract:
handle_contract_wrong_address('user_deposit',
user_deposit_contract_address)
service_registry = None
if CONTRACT_SERVICE_REGISTRY in contracts or service_registry_contract_address:
try:
service_registry = blockchain_service.service_registry(
service_registry_contract_address or to_canonical_address(
contracts[CONTRACT_SERVICE_REGISTRY]['address'], ), )
except ContractVersionMismatch as e:
handle_contract_version_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code('service registry',
service_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address('secret registry',
service_registry_contract_address)
if routing_mode == RoutingMode.PFS:
if environment_type == Environment.PRODUCTION:
click.secho(
'Requested production mode and PFS routing mode. This is not supported',
fg='red',
)
sys.exit(1)
if not service_registry and not pathfinding_service_address:
click.secho(
'Requested PFS routing mode but no service registry or no specific pathfinding '
' service address is provided. Please provide it via either the '
'--service-registry-contract-address or the --pathfinding-service-address '
'argument',
fg='red',
)
sys.exit(1)
pfs_config = configure_pfs(
pfs_address=pathfinding_service_address,
pfs_eth_address=pathfinding_eth_address,
routing_mode=routing_mode,
service_registry=service_registry,
)
msg = 'Eth address of selected pathfinding service is unknown.'
assert pfs_config.eth_address is not None, msg
config['services']['pathfinding_service_address'] = pfs_config.url
config['services']['pathfinding_eth_address'] = pfs_config.eth_address
config['services']['pathfinding_fee'] = pfs_config.fee
else:
config['services']['pathfinding_service_address'] = None
config['services']['pathfinding_eth_address'] = None
proxies = Proxies(
token_network_registry=token_network_registry,
secret_registry=secret_registry,
user_deposit=user_deposit,
service_registry=service_registry,
)
return proxies
def _network_name(self) -> str:
netid = self._raiden_service.chain.network_id
return ID_TO_NETWORKNAME.get(netid, str(netid))
def setup_proxies_or_exit(
config: Dict[str, Any],
tokennetwork_registry_contract_address: TokenNetworkRegistryAddress,
secret_registry_contract_address: Address,
user_deposit_contract_address: Address,
service_registry_contract_address: Address,
proxy_manager: ProxyManager,
contracts: Dict[str, Any],
routing_mode: RoutingMode,
pathfinding_service_address: str,
) -> Proxies:
"""
Initialize and setup the contract proxies.
Depending on the provided contract addresses via the CLI, the routing mode,
the environment type and the network id try to initialize the proxies.
Returns the initialized proxies or exits the application with an error if
there is a problem.
Also depending on the given arguments populate config with PFS related settings
"""
node_network_id = config["chain_id"]
environment_type = config["environment_type"]
check_smart_contract_addresses(
environment_type=environment_type,
node_network_id=node_network_id,
tokennetwork_registry_contract_address=
tokennetwork_registry_contract_address,
secret_registry_contract_address=secret_registry_contract_address,
contracts=contracts,
)
token_network_registry = None
try:
if tokennetwork_registry_contract_address is not None:
registered_address = tokennetwork_registry_contract_address
else:
registered_address = to_canonical_address(
contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]["address"])
token_network_registry = proxy_manager.token_network_registry(
registered_address)
except ContractCodeMismatch as e:
handle_contract_code_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code(
"token network registry",
Address(tokennetwork_registry_contract_address))
except AddressWrongContract:
handle_contract_wrong_address(
"token network registry",
Address(tokennetwork_registry_contract_address))
secret_registry = None
try:
secret_registry = proxy_manager.secret_registry(
secret_registry_contract_address or to_canonical_address(
contracts[CONTRACT_SECRET_REGISTRY]["address"]))
except ContractCodeMismatch as e:
handle_contract_code_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code("secret registry",
secret_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address("secret registry",
secret_registry_contract_address)
# If services contracts are provided via the CLI use them instead
if user_deposit_contract_address is not None:
contracts[CONTRACT_USER_DEPOSIT] = user_deposit_contract_address
if service_registry_contract_address is not None:
contracts[
CONTRACT_SERVICE_REGISTRY] = service_registry_contract_address
user_deposit = None
should_use_user_deposit = (
environment_type == Environment.DEVELOPMENT
and ID_TO_NETWORKNAME.get(node_network_id) != "smoketest"
and CONTRACT_USER_DEPOSIT in contracts)
if should_use_user_deposit:
try:
user_deposit = proxy_manager.user_deposit(
user_deposit_contract_address or to_canonical_address(
contracts[CONTRACT_USER_DEPOSIT]["address"]))
except ContractCodeMismatch as e:
handle_contract_code_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code("user deposit",
user_deposit_contract_address)
except AddressWrongContract:
handle_contract_wrong_address("user_deposit",
user_deposit_contract_address)
service_registry = None
if CONTRACT_SERVICE_REGISTRY in contracts or service_registry_contract_address:
try:
service_registry = proxy_manager.service_registry(
service_registry_contract_address or to_canonical_address(
contracts[CONTRACT_SERVICE_REGISTRY]["address"]))
except ContractCodeMismatch as e:
handle_contract_code_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code("service registry",
service_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address("secret registry",
service_registry_contract_address)
# By now these should be set or Raiden aborted
assert token_network_registry, "TokenNetworkRegistry needs to be set"
assert secret_registry, "SecretRegistry needs to be set"
if routing_mode == RoutingMode.PFS:
check_pfs_configuration(
service_registry=service_registry,
pathfinding_service_address=pathfinding_service_address,
)
pfs_info = configure_pfs_or_exit(
pfs_url=pathfinding_service_address,
routing_mode=routing_mode,
service_registry=service_registry,
node_network_id=node_network_id,
token_network_registry_address=token_network_registry.address,
pathfinding_max_fee=config["services"]["pathfinding_max_fee"],
)
msg = "Eth address of selected pathfinding service is unknown."
assert pfs_info.payment_address is not None, msg
# Only check that PFS is registered in production mode
if environment_type == Environment.PRODUCTION:
check_pfs_for_production(service_registry=service_registry,
pfs_info=pfs_info)
config["pfs_config"] = PFSConfig(
info=pfs_info,
maximum_fee=config["services"]["pathfinding_max_fee"],
iou_timeout=config["services"]["pathfinding_iou_timeout"],
max_paths=config["services"]["pathfinding_max_paths"],
)
else:
config["pfs_config"] = None
proxies = Proxies(
token_network_registry=token_network_registry,
secret_registry=secret_registry,
user_deposit=user_deposit,
service_registry=service_registry,
)
return proxies
def run_app(
address: Address,
keystore_path: str,
gas_price: Callable,
eth_rpc_endpoint: str,
user_deposit_contract_address: Optional[UserDepositAddress],
api_address: Endpoint,
rpc: bool,
sync_check: bool,
console: bool,
password_file: TextIO,
web_ui: bool,
datadir: str,
transport: str,
matrix_server: str,
network_id: ChainID,
environment_type: Environment,
unrecoverable_error_should_crash: bool,
pathfinding_service_address: str,
pathfinding_max_paths: int,
enable_monitoring: bool,
resolver_endpoint: str,
default_reveal_timeout: BlockTimeout,
default_settle_timeout: BlockTimeout,
routing_mode: RoutingMode,
flat_fee: Tuple[Tuple[TokenAddress, FeeAmount], ...],
proportional_fee: Tuple[Tuple[TokenAddress, ProportionalFeeAmount],
...],
proportional_imbalance_fee: Tuple[Tuple[TokenAddress,
ProportionalFeeAmount], ...],
blockchain_query_interval: float,
cap_mediation_fees: bool,
**
kwargs: Any, # FIXME: not used here, but still receives stuff in smoketest
) -> App:
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
token_network_registry_deployed_at: Optional[BlockNumber]
smart_contracts_start_at: BlockNumber
if datadir is None:
datadir = os.path.join(os.path.expanduser("~"), ".raiden")
account_manager = AccountManager(keystore_path)
web3 = Web3(HTTPProvider(rpc_normalized_endpoint(eth_rpc_endpoint)))
check_sql_version()
check_ethereum_has_accounts(account_manager)
check_ethereum_client_is_supported(web3)
check_ethereum_network_id(network_id, web3)
address, privatekey = get_account_and_private_key(account_manager, address,
password_file)
api_host, api_port = split_endpoint(api_address)
if not api_port:
api_port = Port(DEFAULT_HTTP_SERVER_PORT)
fee_config = prepare_mediation_fee_config(
cli_token_to_flat_fee=flat_fee,
cli_token_to_proportional_fee=proportional_fee,
cli_token_to_proportional_imbalance_fee=proportional_imbalance_fee,
cli_cap_mediation_fees=cap_mediation_fees,
)
config = RaidenConfig(chain_id=network_id,
environment_type=environment_type)
config.console = console
config.rpc = rpc
config.web_ui = rpc and web_ui
config.blockchain.query_interval = blockchain_query_interval
config.mediation_fees = fee_config
config.services.monitoring_enabled = enable_monitoring
config.services.pathfinding_max_paths = pathfinding_max_paths
config.transport_type = transport
config.transport.server = matrix_server
config.unrecoverable_error_should_crash = unrecoverable_error_should_crash
config.api_host = api_host
config.api_port = api_port
config.resolver_endpoint = resolver_endpoint
config.reveal_timeout = default_reveal_timeout
config.settle_timeout = default_settle_timeout
contracts = load_deployed_contracts_data(config, network_id)
rpc_client = JSONRPCClient(
web3=web3,
privkey=privatekey,
gas_price_strategy=gas_price,
block_num_confirmations=DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
)
token_network_registry_deployed_at = None
if "TokenNetworkRegistry" in contracts:
token_network_registry_deployed_at = BlockNumber(
contracts["TokenNetworkRegistry"]["block_number"])
if token_network_registry_deployed_at is None:
smart_contracts_start_at = get_smart_contracts_start_at(network_id)
else:
smart_contracts_start_at = token_network_registry_deployed_at
proxy_manager = ProxyManager(
rpc_client=rpc_client,
contract_manager=ContractManager(config.contracts_path),
metadata=ProxyManagerMetadata(
token_network_registry_deployed_at=
token_network_registry_deployed_at,
filters_start_at=smart_contracts_start_at,
),
)
if sync_check:
check_synced(rpc_client)
# The user has the option to launch Raiden with a custom
# user deposit contract address. This can be used to load
# the addresses for the rest of the deployed contracts.
# The steps done here make sure that if a UDC address is provided,
# the address has to be valid and all the connected contracts
# are configured properly.
# If a UDC address was not provided, Raiden would fall back
# to using the ones deployed and provided by the raiden-contracts package.
if user_deposit_contract_address is not None:
if not is_address(user_deposit_contract_address):
raise RaidenError("The user deposit address is invalid")
deployed_addresses = load_deployment_addresses_from_udc(
proxy_manager=proxy_manager,
user_deposit_address=user_deposit_contract_address,
block_identifier="latest",
)
else:
deployed_addresses = load_deployment_addresses_from_contracts(
contracts=contracts)
raiden_bundle = raiden_bundle_from_contracts_deployment(
proxy_manager=proxy_manager,
token_network_registry_address=deployed_addresses.
token_network_registry_address,
secret_registry_address=deployed_addresses.secret_registry_address,
)
services_bundle = services_bundle_from_contracts_deployment(
config=config,
deployed_addresses=deployed_addresses,
proxy_manager=proxy_manager,
routing_mode=routing_mode,
pathfinding_service_address=pathfinding_service_address,
enable_monitoring=enable_monitoring,
)
check_ethereum_confirmed_block_is_not_pruned(
jsonrpc_client=rpc_client,
secret_registry=raiden_bundle.secret_registry,
confirmation_blocks=config.blockchain.confirmation_blocks,
)
database_path = Path(
os.path.join(
datadir,
f"node_{pex(address)}",
f"netid_{network_id}",
f"network_{pex(raiden_bundle.token_network_registry.address)}",
f"v{RAIDEN_DB_VERSION}_log.db",
))
config.database_path = database_path
print(f"Raiden is running in {environment_type.value.lower()} mode")
print("\nYou are connected to the '{}' network and the DB path is: {}".
format(ID_TO_NETWORKNAME.get(network_id, network_id), database_path))
if transport == "matrix":
matrix_transport = setup_matrix(config.transport, config.services,
environment_type, routing_mode)
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
event_handler: EventHandler = RaidenEventHandler()
# User should be told how to set fees, if using default fee settings
log.debug("Fee Settings", fee_settings=fee_config)
has_default_fees = (len(fee_config.token_to_flat_fee) == 0
and len(fee_config.token_to_proportional_fee) == 0
and len(fee_config.token_to_proportional_imbalance_fee)
== 0)
if has_default_fees:
click.secho(
"Default fee settings are used. "
"If you want use Raiden with mediation fees - flat, proportional and imbalance fees - "
"see https://raiden-network.readthedocs.io/en/latest/overview_and_guide.html#firing-it-up", # noqa: E501
fg="yellow",
)
# Only send feedback when PFS is used
if routing_mode == RoutingMode.PFS:
event_handler = PFSFeedbackEventHandler(event_handler)
message_handler = MessageHandler()
one_to_n_address = (services_bundle.one_to_n.address
if services_bundle.one_to_n is not None else None)
monitoring_service_address = (services_bundle.monitoring_service.address
if services_bundle.monitoring_service
is not None else None)
raiden_app = App(
config=config,
rpc_client=rpc_client,
proxy_manager=proxy_manager,
query_start_block=smart_contracts_start_at,
default_registry=raiden_bundle.token_network_registry,
default_secret_registry=raiden_bundle.secret_registry,
default_one_to_n_address=one_to_n_address,
default_service_registry=services_bundle.service_registry,
default_msc_address=monitoring_service_address,
transport=matrix_transport,
raiden_event_handler=event_handler,
message_handler=message_handler,
routing_mode=routing_mode,
user_deposit=services_bundle.user_deposit,
)
raiden_app.start()
return raiden_app
def run(ctx: Context, **kwargs: Any) -> None:
# pylint: disable=too-many-locals,too-many-branches,too-many-statements
flamegraph = kwargs.pop("flamegraph", None)
switch_tracing = kwargs.pop("switch_tracing", None)
profiler = None
switch_monitor = None
enable_gevent_monitoring_signal()
if flamegraph:
os.makedirs(flamegraph, exist_ok=True)
now = datetime.datetime.now().isoformat()
address = to_checksum_address(kwargs["address"])
stack_path = os.path.join(flamegraph, f"{address}_{now}_stack.data")
stack_stream = open(stack_path, "w")
flame = FlameGraphCollector(stack_stream)
profiler = TraceSampler(flame)
if switch_tracing is True:
switch_monitor = SwitchMonitoring()
memory_logger = None
log_memory_usage_interval = kwargs.pop("log_memory_usage_interval", 0)
if log_memory_usage_interval > 0:
memory_logger = MemoryLogger(log_memory_usage_interval)
memory_logger.start()
if kwargs.pop("version", False):
click.echo(
click.style("Hint: Use ", fg="green")
+ click.style(f"'{os.path.basename(sys.argv[0])} version'", fg="yellow")
+ click.style(" instead", fg="green")
)
ctx.invoke(version, short=True)
return
if kwargs["config_file"]:
apply_config_file(run, kwargs, ctx)
validate_option_dependencies(run, ctx, kwargs, OPTION_DEPENDENCIES)
if ctx.invoked_subcommand is not None:
# Pass parsed args on to subcommands.
ctx.obj = kwargs
return
if kwargs["transport"] == "matrix":
runner = MatrixRunner(kwargs, ctx)
else:
# Shouldn't happen
raise RuntimeError(f"Invalid transport type '{kwargs['transport']}'")
click.secho(runner.welcome_string, fg="green")
click.secho(
textwrap.dedent(
"""\
----------------------------------------------------------------------
| This is an Alpha version of experimental open source software |
| released as a test version under an MIT license and may contain |
| errors and/or bugs. No guarantee or representations whatsoever is |
| made regarding its suitability (or its use) for any purpose or |
| regarding its compliance with any applicable laws and regulations. |
| Use of the software is at your own risk and discretion and by |
| using the software you acknowledge that you have read this |
| disclaimer, understand its contents, assume all risk related |
| thereto and hereby release, waive, discharge and covenant not to |
| sue Brainbot Labs Establishment or any officers, employees or |
| affiliates from and for any direct or indirect liability resulting |
| from the use of the software as permissible by applicable laws and |
| regulations. |
| |
| Privacy Warning: Please be aware, that by using the Raiden Client, |
| among others, your Ethereum address, channels, channel deposits, |
| settlements and the Ethereum address of your channel counterparty |
| will be stored on the Ethereum chain, i.e. on servers of Ethereum |
| node operators and ergo are to a certain extent publicly available.|
| The same might also be stored on systems of parties running Raiden |
| nodes connected to the same token network. Data present in the |
| Ethereum chain is very unlikely to be able to be changed, removed |
| or deleted from the public arena. |
| |
| Also be aware, that data on individual Raiden token transfers will |
| be made available via the Matrix protocol to the recipient, |
| intermediating nodes of a specific transfer as well as to the |
| Matrix server operators. |
----------------------------------------------------------------------"""
),
fg="yellow",
)
if not kwargs["accept_disclaimer"]:
click.confirm(
"\nHave you read, understood and hereby accept the above "
"disclaimer and privacy warning?",
abort=True,
)
# TODO:
# - Ask for confirmation to quit if there are any locked transfers that did
# not timeout.
try:
runner.run()
except (ReplacementTransactionUnderpriced, EthereumNonceTooLow) as ex:
click.secho(
f"{ex}. Please make sure that this Raiden node is the "
f"only user of the selected account",
fg="red",
)
sys.exit(ReturnCode.ETH_ACCOUNT_ERROR)
except (ConnectionError, ConnectTimeout, RequestsConnectionError, ReadTimeoutError):
print(COMMUNICATION_ERROR.format(kwargs["eth_rpc_endpoint"]))
sys.exit(ReturnCode.GENERIC_COMMUNICATION_ERROR)
except EthNodeInterfaceError as e:
click.secho(str(e), fg="red")
sys.exit(ReturnCode.ETH_INTERFACE_ERROR)
except RaidenUnrecoverableError as ex:
click.secho(f"FATAL: An un-recoverable error happen, Raiden is bailing {ex}", fg="red")
write_stack_trace(ex)
sys.exit(ReturnCode.FATAL)
except APIServerPortInUseError as ex:
click.secho(
f"ERROR: API Address {ex} is in use. Use --api-address <host:port> "
f"to specify a different port.",
fg="red",
)
sys.exit(ReturnCode.PORT_ALREADY_IN_USE)
except (KeystoreAuthenticationError, KeystoreFileNotFound) as e:
click.secho(str(e), fg="red")
sys.exit(ReturnCode.ETH_ACCOUNT_ERROR)
except ConfigurationError as e:
click.secho(str(e), fg="red")
sys.exit(ReturnCode.CONFIGURATION_ERROR)
except filelock.Timeout:
name_or_id = ID_TO_NETWORKNAME.get(kwargs["network_id"], kwargs["network_id"])
click.secho(
f"FATAL: Another Raiden instance already running for account "
f"{to_checksum_address(address)} on network id {name_or_id}",
fg="red",
)
sys.exit(ReturnCode.CONFIGURATION_ERROR)
except Exception as ex:
write_stack_trace(ex)
sys.exit(ReturnCode.FATAL)
finally:
# teardown order is important because of side-effects, both the
# switch_monitor and profiler could use the tracing api, for the
# teardown code to work correctly the teardown has to be done in the
# reverse order of the initialization.
if switch_monitor is not None:
switch_monitor.stop()
if memory_logger is not None:
memory_logger.stop()
if profiler is not None:
profiler.stop()
def run_app(
address,
keystore_path,
gas_price,
eth_rpc_endpoint,
tokennetwork_registry_contract_address,
secret_registry_contract_address,
service_registry_contract_address,
endpoint_registry_contract_address,
user_deposit_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,
environment_type,
unrecoverable_error_should_crash,
pathfinding_service_address,
pathfinding_eth_address,
pathfinding_max_paths,
enable_monitoring,
resolver_endpoint,
routing_mode,
config=None,
extra_config=None,
**kwargs,
):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
check_sql_version()
if transport == "udp" and not mapped_socket:
raise RuntimeError("Missing socket")
if datadir is None:
datadir = os.path.join(os.path.expanduser("~"), ".raiden")
account_manager = AccountManager(keystore_path)
check_has_accounts(account_manager)
if not address:
address_hex = prompt_account(account_manager)
else:
address_hex = to_normalized_address(address)
if password_file:
privatekey_bin = unlock_account_with_passwordfile(
account_manager=account_manager,
address_hex=address_hex,
password_file=password_file)
else:
privatekey_bin = unlock_account_with_passwordprompt(
account_manager=account_manager, address_hex=address_hex)
address = to_canonical_address(address_hex)
(listen_host, listen_port) = split_endpoint(listen_address)
(api_host, api_port) = split_endpoint(api_address)
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
config["resolver_endpoint"] = resolver_endpoint
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
config[
"unrecoverable_error_should_crash"] = unrecoverable_error_should_crash
config["services"]["pathfinding_max_paths"] = pathfinding_max_paths
config["services"]["monitoring_enabled"] = enable_monitoring
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))
check_ethereum_version(web3)
check_network_id(network_id, web3)
config["chain_id"] = network_id
setup_environment(config, environment_type)
contracts = setup_contracts_or_exit(config, network_id)
rpc_client = JSONRPCClient(
web3,
privatekey_bin,
gas_price_strategy=gas_price,
block_num_confirmations=DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
uses_infura="infura.io" in eth_rpc_endpoint,
)
blockchain_service = BlockChainService(jsonrpc_client=rpc_client,
contract_manager=ContractManager(
config["contracts_path"]))
if sync_check:
check_synced(blockchain_service)
proxies = setup_proxies_or_exit(
config=config,
tokennetwork_registry_contract_address=
tokennetwork_registry_contract_address,
secret_registry_contract_address=secret_registry_contract_address,
endpoint_registry_contract_address=endpoint_registry_contract_address,
user_deposit_contract_address=user_deposit_contract_address,
service_registry_contract_address=service_registry_contract_address,
blockchain_service=blockchain_service,
contracts=contracts,
routing_mode=routing_mode,
pathfinding_service_address=pathfinding_service_address,
pathfinding_eth_address=pathfinding_eth_address,
)
database_path = os.path.join(
datadir,
f"node_{pex(address)}",
f"netid_{network_id}",
f"network_{pex(proxies.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(network_id, network_id), database_path))
discovery = None
if transport == "udp":
transport, discovery = setup_udp_or_exit(
config, blockchain_service, address, contracts,
endpoint_registry_contract_address)
elif transport == "matrix":
transport = _setup_matrix(config)
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
try:
start_block = 0
if "TokenNetworkRegistry" in contracts:
start_block = contracts["TokenNetworkRegistry"]["block_number"]
raiden_app = App(
config=config,
chain=blockchain_service,
query_start_block=start_block,
default_registry=proxies.token_network_registry,
default_secret_registry=proxies.secret_registry,
default_service_registry=proxies.service_registry,
transport=transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=discovery,
user_deposit=proxies.user_deposit,
)
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 run_app(
address,
keystore_path,
gas_price,
eth_rpc_endpoint,
tokennetwork_registry_contract_address,
secret_registry_contract_address,
endpoint_registry_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,
environment_type,
unrecoverable_error_should_crash,
pathfinding_service_address,
pathfinding_max_paths,
config=None,
extra_config=None,
**kwargs,
):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
_assert_sql_version()
if transport == 'udp' and not mapped_socket:
raise RuntimeError('Missing socket')
if datadir is None:
datadir = os.path.join(os.path.expanduser('~'), '.raiden')
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)
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
config['privatekey_hex'] = encode_hex(privatekey_bin)
config['unrecoverable_error_should_crash'] = unrecoverable_error_should_crash
config['services']['pathfinding_service_address'] = pathfinding_service_address
config['services']['pathfinding_max_paths'] = pathfinding_max_paths
parsed_eth_rpc_endpoint = urlparse(eth_rpc_endpoint)
if not parsed_eth_rpc_endpoint.scheme:
eth_rpc_endpoint = f'http://{eth_rpc_endpoint}'
web3 = _setup_web3(eth_rpc_endpoint)
rpc_client = JSONRPCClient(
web3,
privatekey_bin,
gas_price_strategy=gas_price,
block_num_confirmations=DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
uses_infura='infura.io' in eth_rpc_endpoint,
)
blockchain_service = BlockChainService(
privatekey_bin=privatekey_bin,
jsonrpc_client=rpc_client,
# Not giving the contract manager here, but injecting it later
# since we first need blockchain service to calculate the network id
)
given_network_id = network_id
node_network_id = blockchain_service.network_id
known_given_network_id = given_network_id in ID_TO_NETWORKNAME
known_node_network_id = node_network_id in ID_TO_NETWORKNAME
if node_network_id != given_network_id:
if known_given_network_id and known_node_network_id:
click.secho(
f"The chosen ethereum network '{ID_TO_NETWORKNAME[given_network_id]}' "
f"differs from the ethereum client '{ID_TO_NETWORKNAME[node_network_id]}'. "
"Please update your settings.",
fg='red',
)
else:
click.secho(
f"The chosen ethereum network id '{given_network_id}' differs "
f"from the ethereum client '{node_network_id}'. "
"Please update your settings.",
fg='red',
)
sys.exit(1)
config['chain_id'] = given_network_id
# interpret the provided string argument
if environment_type == Environment.PRODUCTION:
# Safe configuration: restrictions for mainnet apply and matrix rooms have to be private
config['environment_type'] = Environment.PRODUCTION
config['transport']['matrix']['private_rooms'] = True
else:
config['environment_type'] = Environment.DEVELOPMENT
environment_type = config['environment_type']
print(f'Raiden is running in {environment_type.value.lower()} mode')
chain_config = {}
contract_addresses_known = False
contracts = dict()
contracts_version = 'pre_limits' if environment_type == Environment.DEVELOPMENT else None
config['contracts_path'] = contracts_precompiled_path(contracts_version)
if node_network_id in ID_TO_NETWORKNAME and ID_TO_NETWORKNAME[node_network_id] != 'smoketest':
deployment_data = get_contracts_deployed(node_network_id, contracts_version)
not_allowed = ( # for now we only disallow mainnet with test configuration
network_id == 1 and
environment_type == Environment.DEVELOPMENT
)
if not_allowed:
click.secho(
f'The chosen network ({ID_TO_NETWORKNAME[node_network_id]}) is not a testnet, '
'but the "development" environment was selected.\n'
'This is not allowed. Please start again with a safe environment setting '
'(--environment production).',
fg='red',
)
sys.exit(1)
contracts = deployment_data['contracts']
contract_addresses_known = True
blockchain_service.inject_contract_manager(ContractManager(config['contracts_path']))
if sync_check:
check_synced(blockchain_service, known_node_network_id)
contract_addresses_given = (
tokennetwork_registry_contract_address is not None and
secret_registry_contract_address is not None and
endpoint_registry_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 '{given_network_id}'. "
"Please provide them on the command line or in the configuration file.",
fg='red',
)
sys.exit(1)
try:
token_network_registry = blockchain_service.token_network_registry(
tokennetwork_registry_contract_address or to_canonical_address(
contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]['address'],
),
)
except ContractVersionMismatch as e:
handle_contract_version_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code('token network registry', tokennetwork_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address(
'token network registry',
tokennetwork_registry_contract_address,
)
try:
secret_registry = blockchain_service.secret_registry(
secret_registry_contract_address or to_canonical_address(
contracts[CONTRACT_SECRET_REGISTRY]['address'],
),
)
except ContractVersionMismatch as e:
handle_contract_version_mismatch(e)
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_{given_network_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(given_network_id, given_network_id),
database_path,
),
)
discovery = None
if transport == 'udp':
transport, discovery = _setup_udp(
config,
blockchain_service,
address,
contracts,
endpoint_registry_contract_address,
)
elif transport == 'matrix':
transport = _setup_matrix(config)
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
try:
if 'contracts' in chain_config:
start_block = chain_config['contracts']['TokenNetworkRegistry']['block_number']
else:
start_block = 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,
message_handler=message_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(given_network_id, given_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
