Handle out of bounds errors for FeeSchedule

src/pathfinding_service/exceptions.py

@@ -5,6 +5,12 @@ class InvalidCapacityUpdate(Exception):
     """Exception for incoming messages"""
 
 
+class UndefinedFee(Exception):
+    """The fee schedule is not applicable resulting in undefined fees
+
+    This should be handled by excluding the route from the results"""
+
+
 class ApiException(Exception):
     """An exception that can be returned via the REST API"""
 

src/pathfinding_service/model/channel_view.py

@@ -6,6 +6,7 @@
 from marshmallow_dataclass import add_schema
 
 from pathfinding_service.config import DEFAULT_REVEAL_TIMEOUT
+from pathfinding_service.exceptions import UndefinedFee
 from raiden.utils.typing import (
     Address,
     ChannelID,
@@ -58,7 +59,10 @@ def fee(self, amount: TokenAmount, capacity: TokenAmount) -> FeeAmount:
         if self.imbalance_penalty:
             # Total channel capacity - node capacity = balance (used as x-axis for the penalty)
             balance = self._penalty_func.x_list[-1] - capacity
-            imbalance_fee = self._penalty_func(balance + amount) - self._penalty_func(balance)
+            try:
+                imbalance_fee = self._penalty_func(balance + amount) - self._penalty_func(balance)
+            except ValueError:
+                raise UndefinedFee()
         else:
             imbalance_fee = 0
         return FeeAmount(round(self.flat + amount * self.proportional + imbalance_fee))

src/pathfinding_service/model/token_network.py

@@ -13,6 +13,7 @@
     DIVERSITY_PEN_DEFAULT,
     FEE_PEN_DEFAULT,
 )
+from pathfinding_service.exceptions import UndefinedFee
 from pathfinding_service.model.channel_view import ChannelView, FeeSchedule
 from raiden.messages import Message, UpdatePFS
 from raiden.network.transport.matrix import AddressReachability
@@ -53,12 +54,15 @@ def __init__(
 
     def _calc_fees(self) -> None:
         total = self.value
-        for prev_node, mediator, next_node in reversed(list(window(self.nodes, 3))):
-            fee_for_this_mediator = self.G[prev_node][mediator]["view"].fee_receiver(
-                total
-            ) + self.G[mediator][next_node]["view"].fee_sender(total)
-            total += fee_for_this_mediator
-            self.fees.append(fee_for_this_mediator)
+        try:
+            for prev_node, mediator, next_node in reversed(list(window(self.nodes, 3))):
+                fee_for_this_mediator = self.G[prev_node][mediator]["view"].fee_receiver(
+                    total
+                ) + self.G[mediator][next_node]["view"].fee_sender(total)
+                total += fee_for_this_mediator
+                self.fees.append(fee_for_this_mediator)
+        except UndefinedFee:
+            self._is_valid = False
 
     @property
     def edge_attrs(self) -> Iterable[dict]:
@@ -82,6 +86,8 @@ def is_valid(self) -> bool:
         should not use such routes. See
         https://github.com/raiden-network/raiden-services/issues/5.
         """
+        if hasattr(self, "_is_valid"):
+            return self._is_valid
         required_capacity = self.value
         edges = reversed(list(self.edge_attrs))
         fees = self.fees + [FeeAmount(0)]  # The hop to the target does not incur mediation fees
@@ -276,7 +282,10 @@ def edge_weight(
         # Fees for initiator and target are included here. This promotes routes
         # that are nice to the initiator's and target's capacities, but it's
         # inconsistent with the estimated total fee.
-        fee_weight = (view.fee_sender(amount) + view.fee_receiver(amount)) / 1e18 * fee_penalty
+        try:
+            fee_weight = (view.fee_sender(amount) + view.fee_receiver(amount)) / 1e18 * fee_penalty
+        except UndefinedFee:
+            return float("inf")
         no_refund_weight = 0
         if view_from_partner.capacity < int(float(amount) * 1.1):
             no_refund_weight = 1

tests/pathfinding/test_fee_schedule.py

@@ -95,6 +95,8 @@ def set_fee(self, node1, node2, fee_schedule: FeeSchedule):
 
     def estimate_fee(self, initator, target, value=TA(10), max_paths=1):
         result = self.get_paths(a(initator), a(target), value=value, max_paths=max_paths)
+        if not result:
+            return None
         return result[0]["estimated_fee"]
 
 
@@ -134,6 +136,11 @@ def test_fees_in_routing():
     assert tn.estimate_fee(1, 3) == 10
     assert tn.estimate_fee(3, 1) == -10
 
+    # When the range covered by the imbalance_penalty does include the
+    # necessary belance values, the route should be considered invalid.
+    tn.set_fee(2, 3, FeeSchedule(imbalance_penalty=[(TA(0), FA(0)), (TA(80), FA(200))]))
+    assert tn.estimate_fee(1, 3) is None
+
 
 def test_compounding_fees():
     """ The transferred amount needs to include the fees for all mediators.