onion_message: pathfinding: ignore amount contraints

Ignore channel amount constraints when doing pathfinding for an
onion message. Onion messages don't need to move funds so pathfinding
shouldn't penalize channels based on fake payment amounts.

Author: f321x

electrum/lnrouter.py

@@ -452,6 +452,7 @@ def _edge_cost(
             end_node: bytes,
             payment_amt_msat: int,
             ignore_costs=False,
+            ignore_amount_constraints: bool = False,
             is_mine=False,
             my_channels: Dict[ShortChannelID, 'Channel'] = None,
             private_route_edges: Dict[ShortChannelID, RouteEdge] = None,
@@ -481,14 +482,15 @@ def _edge_cost(
             return float('inf'), 0
         if channel_policy.is_disabled():
             return float('inf'), 0
-        if payment_amt_msat < channel_policy.htlc_minimum_msat:
-            return float('inf'), 0  # payment amount too little
-        if channel_info.capacity_sat is not None and \
-                payment_amt_msat // 1000 > channel_info.capacity_sat:
-            return float('inf'), 0  # payment amount too large
-        if channel_policy.htlc_maximum_msat is not None and \
-                payment_amt_msat > channel_policy.htlc_maximum_msat:
-            return float('inf'), 0  # payment amount too large
+        if not ignore_amount_constraints:
+            if payment_amt_msat < channel_policy.htlc_minimum_msat:
+                return float('inf'), 0  # payment amount too little
+            if channel_info.capacity_sat is not None and \
+                    payment_amt_msat // 1000 > channel_info.capacity_sat:
+                return float('inf'), 0  # payment amount too large
+            if channel_policy.htlc_maximum_msat is not None and \
+                    payment_amt_msat > channel_policy.htlc_maximum_msat:
+                return float('inf'), 0  # payment amount too large
         route_edge = private_route_edges.get(short_channel_id, None)
         if route_edge is None:
             node_info = self.channel_db.get_node_info_for_node_id(node_id=end_node)
@@ -513,7 +515,7 @@ def _edge_cost(
         # - The larger the payment amount, and the longer the CLTV,
         #   the more irritating it is if the HTLC gets stuck.
         # - Paying lower fees is better. :)
-        if ignore_costs:
+        if ignore_costs or ignore_amount_constraints:
             return DEFAULT_PENALTY_BASE_MSAT, 0
         fee_msat = route_edge.fee_for_edge(payment_amt_msat)
         cltv_cost = route_edge.cltv_delta * payment_amt_msat * 15 / 1_000_000_000
@@ -528,10 +530,10 @@ def get_shortest_path_hops(
             *,
             nodeA: bytes, # nodeA is expected to be our node id if channels are passed in my_sending_channels
             nodeB: bytes,
-            invoice_amount_msat: int,
+            invoice_amount_msat: Optional[int],
             my_sending_channels: Dict[ShortChannelID, 'Channel'] = None,
             private_route_edges: Dict[ShortChannelID, RouteEdge] = None,
-            node_filter: Optional[Callable[[bytes, NodeInfo], bool]] = None
+            node_filter: Optional[Callable[[bytes, Optional[NodeInfo]], bool]] = None,
     ) -> Dict[bytes, PathEdge]:
         # note: we don't lock self.channel_db, so while the path finding runs,
         #       the underlying graph could potentially change... (not good but maybe ~OK?)
@@ -545,11 +547,12 @@ def get_shortest_path_hops(
         # run Dijkstra
         # The search is run in the REVERSE direction, from nodeB to nodeA,
         # to properly calculate compound routing fees.
+        ignore_amount_constraints = invoice_amount_msat is None  # e.g. onion messages
         distance_from_start = defaultdict(lambda: float('inf'))
         distance_from_start[nodeB] = 0
         previous_hops = {}  # type: Dict[bytes, PathEdge]
         nodes_to_explore = queue.PriorityQueue()
-        nodes_to_explore.put((0, invoice_amount_msat, nodeB))  # order of fields (in tuple) matters!
+        nodes_to_explore.put((0, invoice_amount_msat or 0, nodeB))  # order of fields (in tuple) matters!
         now = int(time.time())
 
         # main loop of search
@@ -592,14 +595,16 @@ def get_shortest_path_hops(
                 if edge_startnode == nodeA and my_sending_channels:  # payment outgoing, on our channel
                     if edge_channel_id not in my_sending_channels:
                         continue
-                    if not my_sending_channels[edge_channel_id].can_pay(amount_msat, check_frozen=True):
+                    if not ignore_amount_constraints \
+                            and not my_sending_channels[edge_channel_id].can_pay(amount_msat, check_frozen=True):
                         continue
                 edge_cost, fee_for_edge_msat = self._edge_cost(
                     short_channel_id=edge_channel_id,
                     start_node=edge_startnode,
                     end_node=edge_endnode,
                     payment_amt_msat=amount_msat,
                     ignore_costs=(edge_startnode == nodeA),
+                    ignore_amount_constraints=ignore_amount_constraints,
                     is_mine=is_mine,
                     my_channels=my_sending_channels,
                     private_route_edges=private_route_edges,
@@ -626,15 +631,15 @@ def find_path_for_payment(
             *,
             nodeA: bytes,
             nodeB: bytes,
-            invoice_amount_msat: int,
+            invoice_amount_msat: Optional[int],
             my_sending_channels: Dict[ShortChannelID, 'Channel'] = None,
             private_route_edges: Dict[ShortChannelID, RouteEdge] = None,
-            node_filter: Optional[Callable[[bytes, NodeInfo], bool]] = None
+            node_filter: Optional[Callable[[bytes, Optional[NodeInfo]], bool]] = None
     ) -> Optional[LNPaymentPath]:
         """Return a path from nodeA to nodeB."""
         assert type(nodeA) is bytes
         assert type(nodeB) is bytes
-        assert type(invoice_amount_msat) is int
+        assert type(invoice_amount_msat) is int or invoice_amount_msat is None
         if my_sending_channels is None:
             my_sending_channels = {}
 
@@ -659,6 +664,28 @@ def find_path_for_payment(
             edge_startnode = edge.node_id
         return path
 
+    def find_path_for_onion_message(
+            self,
+            *,
+            nodeA: bytes,
+            nodeB: bytes,
+            my_sending_channels: Dict[ShortChannelID, 'Channel'] = None,
+            private_route_edges: Dict[ShortChannelID, RouteEdge] = None,
+    ) -> Optional[LNPaymentPath]:
+        from .onion_message import is_onion_message_node
+        def _node_filter(edge_startnode, node_info):
+            if edge_startnode == nodeA:
+                return True  # assume the sending node does support onion messages
+            return is_onion_message_node(edge_startnode, node_info)
+        return self.find_path_for_payment(
+            nodeA=nodeA,
+            nodeB=nodeB,
+            my_sending_channels=my_sending_channels,
+            private_route_edges=private_route_edges,
+            node_filter=_node_filter,
+            invoice_amount_msat=None,
+        )
+
     def create_route_from_path(
             self,
             path: Optional[LNPaymentPath],

electrum/onion_message.py

@@ -173,11 +173,10 @@ def create_onion_message_route_to(lnwallet: 'LNWallet', node_id: bytes) -> Seque
             if chan.short_channel_id is not None
         }
 
-        if path := lnwallet.network.path_finder.find_path_for_payment(
+        # TODO: if this blocks the event loop too long it might needs to go on a thread
+        if path := lnwallet.network.path_finder.find_path_for_onion_message(
             nodeA=lnwallet.node_keypair.pubkey,
             nodeB=node_id,
-            invoice_amount_msat=10000,  # TODO: do this without amount constraints
-            node_filter=lambda x, y: True if x == lnwallet.node_keypair.pubkey else is_onion_message_node(x, y),
             my_sending_channels=my_sending_channels
         ):
             # first edge must be to our peer

tests/test_lnrouter.py

@@ -523,33 +523,40 @@ def test_decode_onion_error(self):
 
     async def test_find_path_for_onion_message(self):
         self.prepare_graph()
-        amount_to_send = 1000  # we route along channels, and we use find_path_for_payment, so dummy this.
 
-        path = self.path_finder.find_path_for_payment(
-            nodeA=node('a'),
-            nodeB=node('c'),
-            invoice_amount_msat=amount_to_send,
-            node_filter=is_onion_message_node)
+        path = self.path_finder.find_path_for_onion_message(nodeA=node('a'), nodeB=node('c'))
         self.assertEqual([
             PathEdge(start_node=node('a'), end_node=node('d'), short_channel_id=channel(6)),
             PathEdge(start_node=node('d'), end_node=node('c'), short_channel_id=channel(4)),
         ], path)
 
-        # impossible routes
-        path = self.path_finder.find_path_for_payment(
-            nodeA=node('e'),
-            nodeB=node('a'),
-            invoice_amount_msat=amount_to_send,
-            node_filter=is_onion_message_node)
+        # node e doesn't support onion messages
+        path = self.path_finder.find_path_for_onion_message(nodeA=node('a'), nodeB=node('e'))
         self.assertIsNone(path)
 
+    async def test_find_path_for_onion_message_ignores_amount_constraints(self):
+        self.prepare_graph()
+
+        # bump htlc_minimum_msat on channel(4) d->c direction
+        key = (node('d'), channel(4))
+        self.cdb._policies[key] = self.cdb._policies[key]._replace(htlc_minimum_msat=10_000_000)
+
+        # a small payment can no longer be routed
         path = self.path_finder.find_path_for_payment(
             nodeA=node('a'),
-            nodeB=node('e'),
-            invoice_amount_msat=amount_to_send,
-            node_filter=is_onion_message_node)
+            nodeB=node('c'),
+            invoice_amount_msat=1000,
+            node_filter=is_onion_message_node,
+        )
         self.assertIsNone(path)
 
+        # but an onion message still routes through the same hop
+        path = self.path_finder.find_path_for_onion_message(nodeA=node('a'), nodeB=node('c'))
+        self.assertEqual([
+            PathEdge(start_node=node('a'), end_node=node('d'), short_channel_id=channel(6)),
+            PathEdge(start_node=node('d'), end_node=node('c'), short_channel_id=channel(4)),
+        ], path)
+
 
 def _tramp_edge(start: str, end: str, *, fee_base=PLACEHOLDER_FEE, fee_prop=PLACEHOLDER_FEE, cltv=576) -> TrampolineEdge:
     return TrampolineEdge(