Removed the class App.

App was an umbrella class which used to contian a list of services,
slowly the class was dehidrated to a proxy class, which only instantiate
the RaidenService. This commit removes that one level of indirection
which simplifies a lot of code.

Author: hackaugusto

CONTRIBUTING.md

@@ -536,7 +536,7 @@ actually expect the crash of a `RaidenService` instance within the test
 and want to ignore it.
 
 Sometimes a test using `@raise_on_failure` needs to restart nodes or start
-new ones during the test. Simply calling `App.start` to achieve this will
+new ones during the test. Simply calling `Raiden.start` to achieve this will
 make `@raise_on_failure` lose track of the app. Therefore, such tests should
 always use the `restart_node` fixture and call `restart_node(app)` instead.
 

raiden/app.py

@@ -356,7 +356,6 @@ def __init__(self, config: MatrixTransportConfig, environment: Environment) -> N
             )
 
         def _http_retry_delay() -> Iterable[float]:
-            # below constants are defined in raiden.app.App.DEFAULT_CONFIG
             return timeout_exponential_backoff(
                 self._config.retries_before_backoff,
                 self._config.retry_interval_initial,

raiden/network/transport/matrix/transport.py

@@ -44,6 +44,7 @@
     InvalidDBData,
     InvalidSecret,
     InvalidSecretHash,
+    InvalidSettleTimeout,
     PaymentConflict,
     RaidenRecoverableError,
     RaidenUnrecoverableError,
@@ -316,6 +317,32 @@ def __init__(
         api_server: Optional[APIServer] = None,
     ) -> None:
         super().__init__()
+
+        # check that the settlement timeout fits the limits of the contract
+        settlement_timeout_min = raiden_bundle.token_network_registry.settlement_timeout_min(
+            BLOCK_ID_LATEST
+        )
+        settlement_timeout_max = raiden_bundle.token_network_registry.settlement_timeout_max(
+            BLOCK_ID_LATEST
+        )
+        invalid_settle_timeout = (
+            config.settle_timeout < settlement_timeout_min
+            or config.settle_timeout > settlement_timeout_max
+            or config.settle_timeout < config.reveal_timeout * 2
+        )
+        if invalid_settle_timeout:
+            raise InvalidSettleTimeout(
+                (
+                    "Settlement timeout for Registry contract {} must "
+                    "be in range [{}, {}], is {}"
+                ).format(
+                    to_checksum_address(raiden_bundle.token_network_registry.address),
+                    settlement_timeout_min,
+                    settlement_timeout_max,
+                    config.settle_timeout,
+                )
+            )
+
         self.tokennetworkaddrs_to_connectionmanagers: ConnectionManagerDict = dict()
         self.targets_to_identifiers_to_statuses: StatusesDict = defaultdict(dict)
 

raiden/raiden_service.py

@@ -1,7 +1,7 @@
 import pytest
 
 from raiden.api.rest import APIServer
-from raiden.app import App
+from raiden.raiden_service import RaidenService
 from raiden.tests.integration.api.utils import prepare_api_server
 from raiden.utils.typing import List
 
@@ -11,7 +11,7 @@
 #       the server is no longer running even though the teardown has not
 #       been invoked.
 @pytest.fixture
-def api_server_test_instance(raiden_network: List[App]) -> APIServer:
+def api_server_test_instance(raiden_network: List[RaidenService]) -> APIServer:
     api_server = prepare_api_server(raiden_network[0])
 
     return api_server

raiden/tests/integration/api/fixtures.py

@@ -7,6 +7,7 @@
 
 from raiden.api.rest import APIServer
 from raiden.constants import BLOCK_ID_LATEST, NULL_ADDRESS_HEX
+from raiden.raiden_service import RaidenService
 from raiden.tests.integration.api.rest.test_rest import DEPOSIT_FOR_TEST_API_DEPOSIT_LIMIT
 from raiden.tests.integration.api.rest.utils import (
     api_url_for,
@@ -21,7 +22,7 @@
 from raiden.tests.utils.events import check_dict_nested_attrs
 from raiden.transfer import views
 from raiden.transfer.state import ChannelState
-from raiden.utils.typing import TokenAmount
+from raiden.utils.typing import List, TokenAmount
 from raiden.waiting import wait_for_participant_deposit
 from raiden_contracts.constants import TEST_SETTLE_TIMEOUT_MAX, TEST_SETTLE_TIMEOUT_MIN
 
@@ -242,7 +243,7 @@ def test_api_channel_open_and_deposit(
 @pytest.mark.parametrize("enable_rest_api", [True])
 def test_api_channel_open_and_deposit_race(
     api_server_test_instance: APIServer,
-    raiden_network,
+    raiden_network: List[RaidenService],
     token_addresses,
     reveal_timeout,
     token_network_registry_address,
@@ -319,11 +320,11 @@ def test_api_channel_open_and_deposit_race(
     exception = Exception(f"Expected deposit not seen within {timeout_seconds}")
     with gevent.Timeout(seconds=timeout_seconds, exception=exception):
         wait_for_participant_deposit(
-            raiden=app0.raiden,
+            raiden=app0,
             token_network_registry_address=token_network_registry_address,
             token_address=token_address,
             partner_address=to_canonical_address(first_partner_address),
-            target_address=app0.raiden.address,
+            target_address=app0.address,
             target_balance=deposit_amount,
             retry_timeout=retry_timeout,
         )
@@ -688,11 +689,11 @@ def test_api_channel_state_change_errors(
 @pytest.mark.parametrize("deposit", [1000])
 @pytest.mark.parametrize("enable_rest_api", [True])
 def test_api_channel_withdraw(
-    api_server_test_instance: APIServer, raiden_network, token_addresses
+    api_server_test_instance: APIServer, raiden_network: List[RaidenService], token_addresses
 ):
     _, app1 = raiden_network
     token_address = token_addresses[0]
-    partner_address = app1.raiden.address
+    partner_address = app1.address
 
     # Withdraw a 0 amount
     request = grequests.patch(
@@ -752,11 +753,14 @@ def test_api_channel_withdraw(
 @pytest.mark.parametrize("deposit", [0])
 @pytest.mark.parametrize("enable_rest_api", [True])
 def test_api_channel_set_reveal_timeout(
-    api_server_test_instance: APIServer, raiden_network, token_addresses, settle_timeout
+    api_server_test_instance: APIServer,
+    raiden_network: List[RaidenService],
+    token_addresses,
+    settle_timeout,
 ):
     app0, app1 = raiden_network
     token_address = token_addresses[0]
-    partner_address = app1.raiden.address
+    partner_address = app1.address
 
     request = grequests.patch(
         api_url_for(
@@ -796,13 +800,13 @@ def test_api_channel_set_reveal_timeout(
     assert_response_with_code(response, HTTPStatus.OK)
 
     token_network_address = views.get_token_network_address_by_token_address(
-        views.state_from_app(app0), app0.raiden.default_registry.address, token_address
+        views.state_from_raiden(app0), app0.default_registry.address, token_address
     )
     assert token_network_address
     channel_state = views.get_channelstate_by_token_network_and_partner(
-        chain_state=views.state_from_raiden(app0.raiden),
+        chain_state=views.state_from_raiden(app0),
         token_network_address=token_network_address,
-        partner_address=app1.raiden.address,
+        partner_address=app1.address,
     )
     assert channel_state