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
"""
chain_id = ChainID(5)
config = RaidenConfig(
chain_id=chain_id,
environment_type=environment_type,
services=ServiceConfig(pathfinding_max_fee=100,
pathfinding_iou_timeout=500,
pathfinding_max_paths=5),
)
contracts = load_deployed_contracts_data(config, chain_id)
proxy_manager = MockProxyManager(node_address=make_address())
with pytest.raises(RaidenError):
deployed_addresses = load_deployment_addresses_from_contracts(
contracts)
with patch.object(pathfinding, "get_pfs_info", return_value=PFS_INFO):
services_bundle_from_contracts_deployment(
config=config,
proxy_manager=proxy_manager,
deployed_addresses=deployed_addresses,
routing_mode=RoutingMode.PFS,
pathfinding_service_address=None,
enable_monitoring=False,
)
def test_setup_proxies_no_service_registry_but_pfs() -> None:
"""
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
"""
chain_id = ChainID(5)
config = RaidenConfig(
chain_id=chain_id,
environment_type=Environment.DEVELOPMENT,
services=ServiceConfig(
pathfinding_max_fee=TokenAmount(100),
pathfinding_iou_timeout=BlockTimeout(500),
pathfinding_max_paths=5,
),
)
config.transport.available_servers = ["http://matrix.example.com"]
contracts = load_deployed_contracts_data(config, chain_id)
proxy_manager = MockProxyManager(node_address=make_address())
PFS_INFO = PFSInfo(
url="my-pfs",
price=TokenAmount(12),
chain_id=ChainID(5),
token_network_registry_address=TokenNetworkRegistryAddress(
to_canonical_address(contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]["address"])
),
user_deposit_address=user_deposit_address_test_default,
confirmed_block_number=BlockNumber(1),
payment_address=pfs_payment_address_default,
message="This is your favorite pathfinding service",
operator="John Doe",
version="0.0.3",
matrix_server="http://matrix.example.com",
matrix_room_id="!room-id:matrix.example.com",
)
deployed_addresses = load_deployment_addresses_from_contracts(contracts)
with patch.object(pathfinding, "get_pfs_info", return_value=PFS_INFO):
services_bundle = services_bundle_from_contracts_deployment(
config=config,
proxy_manager=proxy_manager, # type: ignore
deployed_addresses=deployed_addresses,
routing_mode=RoutingMode.PFS,
pathfinding_service_address="my-pfs",
enable_monitoring=True,
)
assert services_bundle
def test_monitoring_broadcast_messages(
local_matrix_servers,
retry_interval_initial,
retry_interval_max,
retries_before_backoff,
monkeypatch,
broadcast_rooms,
):
"""
Test that RaidenService broadcast RequestMonitoring messages to
MONITORING_BROADCASTING_ROOM room on newly received balance proofs.
"""
transport = MatrixTransport(
config=MatrixTransportConfig(
broadcast_rooms=broadcast_rooms + [MONITORING_BROADCASTING_ROOM],
retries_before_backoff=retries_before_backoff,
retry_interval_initial=retry_interval_initial,
retry_interval_max=retry_interval_max,
server=local_matrix_servers[0],
available_servers=[local_matrix_servers[0]],
),
environment=Environment.DEVELOPMENT,
)
transport._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
raiden_service.config = RaidenConfig(
chain_id=1234,
environment_type=Environment.DEVELOPMENT,
services=ServiceConfig(monitoring_enabled=True),
)
transport.start(raiden_service, [], None)
ms_room_name = make_room_alias(transport.chain_id, MONITORING_BROADCASTING_ROOM)
ms_room = transport._broadcast_rooms.get(ms_room_name)
assert isinstance(ms_room, Room)
ms_room.send_text = MagicMock(spec=ms_room.send_text)
raiden_service.transport = transport
transport.log = MagicMock()
balance_proof = factories.create(HOP1_BALANCE_PROOF)
channel_state = factories.create(factories.NettingChannelStateProperties())
channel_state.our_state.balance_proof = balance_proof
channel_state.partner_state.balance_proof = balance_proof
monkeypatch.setattr(
raiden.transfer.views,
"get_channelstate_by_canonical_identifier",
lambda *a, **kw: channel_state,
)
monkeypatch.setattr(raiden.transfer.channel, "get_balance", lambda *a, **kw: 123)
raiden_service.user_deposit.effective_balance.return_value = MONITORING_REWARD
update_monitoring_service_from_balance_proof(
raiden=raiden_service,
chain_state=None,
new_balance_proof=balance_proof,
non_closing_participant=HOP1,
)
gevent.idle()
with gevent.Timeout(2):
while ms_room.send_text.call_count < 1:
gevent.idle()
assert ms_room.send_text.call_count == 1
transport.stop()
transport.greenlet.get()
def create_apps(
chain_id: ChainID,
contracts_path: Path,
blockchain_services: BlockchainServices,
token_network_registry_address: TokenNetworkRegistryAddress,
one_to_n_address: Optional[OneToNAddress],
secret_registry_address: SecretRegistryAddress,
service_registry_address: Optional[ServiceRegistryAddress],
user_deposit_address: Optional[UserDepositAddress],
monitoring_service_contract_address: MonitoringServiceAddress,
reveal_timeout: BlockTimeout,
settle_timeout: BlockTimeout,
database_basedir: str,
retry_interval_initial: float,
retry_interval_max: float,
retries_before_backoff: int,
environment_type: Environment,
unrecoverable_error_should_crash: bool,
local_matrix_url: Optional[ParsedURL],
broadcast_rooms: List[str],
routing_mode: RoutingMode,
blockchain_query_interval: float,
resolver_ports: List[Optional[int]],
enable_rest_api: bool,
port_generator: Iterator[Port],
capabilities_config: CapabilitiesConfig,
) -> List[App]:
""" Create the apps."""
# pylint: disable=too-many-locals
services = blockchain_services
apps = []
for idx, proxy_manager in enumerate(services):
database_path = database_from_privatekey(base_dir=database_basedir,
app_number=idx)
assert len(resolver_ports) > idx
resolver_port = resolver_ports[idx]
config = RaidenConfig(
chain_id=chain_id,
environment_type=environment_type,
unrecoverable_error_should_crash=unrecoverable_error_should_crash,
reveal_timeout=reveal_timeout,
settle_timeout=settle_timeout,
contracts_path=contracts_path,
database_path=database_path,
blockchain=BlockchainConfig(
confirmation_blocks=DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
query_interval=blockchain_query_interval,
),
mediation_fees=MediationFeeConfig(),
services=ServiceConfig(monitoring_enabled=False),
rest_api=RestApiConfig(rest_api_enabled=enable_rest_api,
host=Host("localhost"),
port=next(port_generator)),
console=False,
transport_type="matrix",
)
config.transport.capabilities_config = capabilities_config
if local_matrix_url is not None:
config.transport = MatrixTransportConfig(
broadcast_rooms=broadcast_rooms,
retries_before_backoff=retries_before_backoff,
retry_interval_initial=retry_interval_initial,
retry_interval_max=retry_interval_max,
server=local_matrix_url,
available_servers=[],
capabilities_config=capabilities_config,
)
assert config.transport.capabilities_config is not None
if resolver_port is not None:
config.resolver_endpoint = f"http://localhost:{resolver_port}"
registry = proxy_manager.token_network_registry(
token_network_registry_address, block_identifier=BLOCK_ID_LATEST)
secret_registry = proxy_manager.secret_registry(
secret_registry_address, block_identifier=BLOCK_ID_LATEST)
service_registry = None
if service_registry_address:
service_registry = proxy_manager.service_registry(
service_registry_address, block_identifier=BLOCK_ID_LATEST)
user_deposit = None
if user_deposit_address:
user_deposit = proxy_manager.user_deposit(
user_deposit_address, block_identifier=BLOCK_ID_LATEST)
# Use `TestMatrixTransport` that saves sent messages for assertions in tests
assert config.transport.capabilities_config is not None
transport = TestMatrixTransport(config=config.transport,
environment=environment_type)
raiden_event_handler = RaidenEventHandler()
hold_handler = HoldRaidenEventHandler(raiden_event_handler)
message_handler = WaitForMessage()
api_server = None
if enable_rest_api:
api_server = start_api_server(rpc_client=proxy_manager.client,
config=config.rest_api,
eth_rpc_endpoint="bla")
app = App(
config=config,
rpc_client=proxy_manager.client,
proxy_manager=proxy_manager,
query_start_block=BlockNumber(0),
default_registry=registry,
default_secret_registry=secret_registry,
default_service_registry=service_registry,
default_user_deposit=user_deposit,
default_one_to_n_address=one_to_n_address,
default_msc_address=monitoring_service_contract_address,
transport=transport,
raiden_event_handler=hold_handler,
message_handler=message_handler,
routing_mode=routing_mode,
api_server=api_server,
)
apps.append(app)
return apps