askrene: fixed routing in high capacity channels

We may introduce high capacity channels in askrene to represent problems
with multiple destinations (eg. multiple blinded paths) or to solve
self-payments. The integer computation of the deliverable amount through
these channels (I tested this with a channel with 21M bitcoin) would
fail due to an integer overflow in the function `amount_msat_sub_fee`,
21M BTC = 21 x 10^17 msat, which overflows u64 integers when multiplied
by 10^6. We have fixed `amount_msat_sub_fee` operations, so that it
doesn't overflow.

Changelog-Fixed: askrene: fixed routing in high capacity channels.

Signed-off-by: Lagrang3 <[email protected]>

Author: Lagrang3

common/amount.c

@@ -554,6 +554,20 @@ bool amount_msat_mul(struct amount_msat *res, struct amount_msat msat, u64 mul)
 	return true;
 }
 
+static bool amount_msat_mul_div(struct amount_msat *res,
+				struct amount_msat msat, u64 mul, u64 div)
+{
+	/* We avoid overflow in the operation (a/b)*x noticing that we can
+	 * decompose x = q_x * b + r_x, where q_x = floor(x/b) and
+	 * r_x = x mod b, then: x*(a/b) = a*q_x + a*r_x/b, which does not
+	 * overflow if a*b does not. */
+	if (mul_overflows_u64(mul, div))
+		return false;
+	u64 x = msat.millisatoshis;
+	res->millisatoshis = mul * (x / div) + (mul * (x % div)) / div;
+	return true;
+}
+
 bool amount_msat_fee(struct amount_msat *fee,
 		     struct amount_msat amt,
 		     u32 fee_base_msat,
@@ -606,9 +620,9 @@ struct amount_msat amount_msat_sub_fee(struct amount_msat in,
 	 */
 	if (!amount_msat_sub(&out, in, amount_msat(fee_base_msat)))
 		return AMOUNT_MSAT(0);
-	if (!amount_msat_mul(&out, out, 1000000))
+	if (!amount_msat_mul_div(&out, out, 1000000,
+				 1000000 + fee_proportional_millionths))
 		return AMOUNT_MSAT(0);
-	out = amount_msat_div(out, 1000000ULL + fee_proportional_millionths);
 
 	/* If we calc reverse, it must work! */
 	assert(within_fee(in, out, fee_base_msat, fee_proportional_millionths));

tests/test_askrene.py

@@ -1437,3 +1437,39 @@ def test_askrene_fake_channeld(node_factory, bitcoind):
                                                       'constrained')
                     else:
                         raise err
+
+
+def test_simple_dummy_channel(node_factory):
+    """Test if askrene can resolve a route with dummy channels, ie. channels
+    that we might set artificially to resolve blinded paths and self payments,
+    they have unlimited capacities and possibly zero fees."""
+    ALOT = "2100000000000000sat"
+    node1 = "020000000000000000000000000000000000000000000000000000000000000001"
+    node2 = "020000000000000000000000000000000000000000000000000000000000000002"
+    l1 = node_factory.get_node()
+    l1.rpc.askrene_create_layer("mylayer")
+    l1.rpc.askrene_create_channel(
+        layer="mylayer",
+        source=node1,
+        destination=node2,
+        short_channel_id="0x0x0",
+        capacity_msat=ALOT,
+    )
+    l1.rpc.askrene_update_channel(
+        layer="mylayer",
+        short_channel_id_dir="0x0x0/0",
+        enabled=True,
+        htlc_minimum_msat=0,
+        htlc_maximum_msat=ALOT,
+        fee_base_msat=0,
+        fee_proportional_millionths=0,
+        cltv_expiry_delta=5,
+    )
+    l1.rpc.getroutes(
+        source=node1,
+        destination=node2,
+        amount_msat=100,
+        maxfee_msat=5000,
+        final_cltv=5,
+        layers=["mylayer"],
+    )