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