def test_setup_proxies_no_service_registry_and_no_pfs_address_but_requesting_pfs(environment_type):
"""
Test that if pfs routing mode is requested and no address or service registry is given
then the client exits with an error message
"""
network_id = 42
config = {
"environment_type": environment_type,
"chain_id": network_id,
"services": dict(
pathfinding_max_fee=100, pathfinding_iou_timeout=500, pathfinding_max_paths=5
),
}
contracts = {}
proxy_manager = MockProxyManager(node_address=make_address())
with pytest.raises(SystemExit):
with patch.object(pathfinding, "get_pfs_info", return_value=PFS_INFO):
setup_proxies_or_exit(
config=config,
tokennetwork_registry_contract_address=make_token_network_registry_address(),
secret_registry_contract_address=make_address(),
user_deposit_contract_address=make_address(),
service_registry_contract_address=None,
proxy_manager=proxy_manager,
contracts=contracts,
routing_mode=RoutingMode.PFS,
pathfinding_service_address=None,
)
def test_setup_proxies_no_service_registry_and_no_pfs_address_but_requesting_pfs(
):
"""
Test that if pfs routing mode is requested and no address or service registry is given
then the client exits with an error message
"""
network_id = 42
config = {
"environment_type": Environment.DEVELOPMENT,
"chain_id": network_id,
"services": {}
}
contracts = {}
blockchain_service = MockChain(network_id=network_id,
node_address=make_address())
with pytest.raises(SystemExit):
with patched_get_for_succesful_pfs_info():
setup_proxies_or_exit(
config=config,
tokennetwork_registry_contract_address=make_address(),
secret_registry_contract_address=make_address(),
endpoint_registry_contract_address=make_address(),
user_deposit_contract_address=make_address(),
service_registry_contract_address=None,
blockchain_service=blockchain_service,
contracts=contracts,
routing_mode=RoutingMode.PFS,
pathfinding_service_address=None,
)
def test_setup_proxies_no_service_registry_but_pfs():
"""
Test that if no service registry is provided but a manual pfs address is given then startup
still works
Regression test for https://github.com/raiden-network/raiden/issues/3740
"""
network_id = 42
config = {
"environment_type": Environment.DEVELOPMENT,
"chain_id": network_id,
"services": {}
}
contracts = {}
blockchain_service = MockChain(network_id=network_id,
node_address=make_address())
with patched_get_for_succesful_pfs_info():
proxies = setup_proxies_or_exit(
config=config,
tokennetwork_registry_contract_address=make_address(),
secret_registry_contract_address=make_address(),
endpoint_registry_contract_address=make_address(),
user_deposit_contract_address=make_address(),
service_registry_contract_address=None,
blockchain_service=blockchain_service,
contracts=contracts,
routing_mode=RoutingMode.PFS,
pathfinding_service_address="my-pfs",
)
assert proxies
def test_setup_proxies_all_addresses_are_known(routing_mode):
"""
Test that startup for proxies works fine if all addresses are given and routing is basic
"""
network_id = 42
config = {
"environment_type": Environment.DEVELOPMENT,
"chain_id": network_id,
"services": {}
}
contracts = setup_contracts_or_exit(config, network_id)
blockchain_service = MockChain(network_id=network_id,
node_address=make_address())
with patched_get_for_succesful_pfs_info():
proxies = setup_proxies_or_exit(
config=config,
tokennetwork_registry_contract_address=None,
secret_registry_contract_address=None,
endpoint_registry_contract_address=None,
user_deposit_contract_address=None,
service_registry_contract_address=None,
blockchain_service=blockchain_service,
contracts=contracts,
routing_mode=routing_mode,
pathfinding_service_address="my-pfs",
)
assert proxies
assert proxies.token_network_registry
assert proxies.secret_registry
assert proxies.user_deposit
assert proxies.service_registry
def test_setup_proxies_raiden_addresses_are_given():
"""
Test that startup for proxies works fine if only raiden addresses only are given
"""
network_id = 42
config = {
"environment_type": Environment.DEVELOPMENT,
"chain_id": network_id,
"services": {}
}
contracts = {}
blockchain_service = MockChain(network_id=network_id,
node_address=make_address())
proxies = setup_proxies_or_exit(
config=config,
tokennetwork_registry_contract_address=make_address(),
secret_registry_contract_address=make_address(),
endpoint_registry_contract_address=make_address(),
user_deposit_contract_address=None,
service_registry_contract_address=None,
blockchain_service=blockchain_service,
contracts=contracts,
routing_mode=RoutingMode.BASIC,
pathfinding_service_address=None,
)
assert proxies
assert proxies.token_network_registry
assert proxies.secret_registry
assert not proxies.user_deposit
assert not proxies.service_registry
def test_setup_proxies_all_addresses_are_given(routing_mode):
"""
Test that startup for proxies works fine if all addresses are given and routing is basic
"""
network_id = 42
config = {
'environment_type': Environment.DEVELOPMENT,
'chain_id': network_id,
'services': {},
}
contracts = {}
blockchain_service = MockChain(network_id=network_id,
node_address=make_address())
with patched_get_for_succesful_pfs_info():
proxies = setup_proxies_or_exit(
config=config,
tokennetwork_registry_contract_address=make_address(),
secret_registry_contract_address=make_address(),
endpoint_registry_contract_address=make_address(),
user_deposit_contract_address=make_address(),
service_registry_contract_address=make_address(),
contract_addresses_known=False,
blockchain_service=blockchain_service,
contracts=contracts,
routing_mode=routing_mode,
pathfinding_service_address='my-pfs',
pathfinding_eth_address=make_checksum_address(),
)
assert proxies
assert proxies.token_network_registry
assert proxies.secret_registry
assert proxies.user_deposit
assert proxies.service_registry
def test_setup_proxies_no_service_registry_but_pfs():
"""
Test that if no service registry is provided but a manual pfs address is given then startup
still works
Regression test for https://github.com/raiden-network/raiden/issues/3740
"""
network_id = 42
config = {
"environment_type": Environment.DEVELOPMENT,
"chain_id": network_id,
"services": dict(
pathfinding_max_fee=100, pathfinding_iou_timeout=500, pathfinding_max_paths=5
),
}
contracts = {}
proxy_manager = MockProxyManager(node_address=make_address())
with patch.object(pathfinding, "get_pfs_info", return_value=PFS_INFO):
proxies = setup_proxies_or_exit(
config=config,
tokennetwork_registry_contract_address=token_network_registry_address_test_default,
secret_registry_contract_address=make_address(),
user_deposit_contract_address=make_address(),
service_registry_contract_address=None,
proxy_manager=proxy_manager,
contracts=contracts,
routing_mode=RoutingMode.PFS,
pathfinding_service_address="my-pfs",
)
assert proxies
def test_setup_proxies_all_addresses_are_known():
"""
Test that startup for proxies works fine if all addresses are given and routing is basic
"""
network_id = 42
config = {"environment_type": Environment.DEVELOPMENT, "chain_id": network_id, "services": {}}
contracts = setup_contracts_or_exit(config, network_id)
proxy_manager = MockProxyManager(node_address=make_address())
with patch.object(pathfinding, "get_pfs_info", return_value=PFS_INFO):
proxies = setup_proxies_or_exit(
config=config,
tokennetwork_registry_contract_address=None,
secret_registry_contract_address=None,
user_deposit_contract_address=None,
service_registry_contract_address=None,
proxy_manager=proxy_manager,
contracts=contracts,
routing_mode=RoutingMode.LOCAL,
pathfinding_service_address="my-pfs",
)
assert proxies
assert proxies.token_network_registry
assert proxies.secret_registry
assert proxies.user_deposit
assert proxies.service_registry
def test_setup_proxies_raiden_addresses_are_given():
"""
Test that startup for proxies works fine if only raiden addresses are given
"""
network_id = 42
config = {"environment_type": Environment.DEVELOPMENT, "chain_id": network_id, "services": {}}
contracts = {}
proxy_manager = MockProxyManager(node_address=make_address())
proxies = setup_proxies_or_exit(
config=config,
tokennetwork_registry_contract_address=token_network_registry_address_test_default,
secret_registry_contract_address=make_address(),
user_deposit_contract_address=None,
service_registry_contract_address=None,
proxy_manager=proxy_manager,
contracts=contracts,
routing_mode=RoutingMode.LOCAL,
pathfinding_service_address=None,
)
assert proxies
assert proxies.token_network_registry
assert proxies.secret_registry
assert not proxies.user_deposit
assert not proxies.service_registry
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,
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 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
