askrene: add algorithm for single path routing

Changelog-Added: askrene: an optimal single-path solver has been added, it can be called using the developer option --dev_algorithm=single-path or by adding the layer "auto.no_mpp_support"

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

Author: Lagrang3

plugins/askrene/askrene.c

@@ -332,7 +332,11 @@ const char *fmt_flow_full(const tal_t *ctx,
 }
 
 enum algorithm {
+	/* Min. Cost Flow by successive shortests paths. */
 	ALGO_DEFAULT,
+	/* Algorithm that finds the optimal routing solution constrained to a
+	 * single path. */
+	ALGO_SINGLE_PATH,
 };
 
 static struct command_result *
@@ -343,6 +347,8 @@ param_algorithm(struct command *cmd, const char *name, const char *buffer,
 	*algo = tal(cmd, enum algorithm);
 	if (streq(algo_str, "default"))
 		**algo = ALGO_DEFAULT;
+	else if (streq(algo_str, "single-path"))
+		**algo = ALGO_SINGLE_PATH;
 	else
 		return command_fail_badparam(cmd, name, buffer, tok,
 					     "unknown algorithm");
@@ -581,15 +587,29 @@ static struct command_result *do_getroutes(struct command *cmd,
 		goto fail;
 	}
 
+	/* auto.no_mpp_support layer overrides any choice of algorithm. */
+	if (have_layer(info->layers, "auto.no_mpp_support") &&
+	    *info->dev_algo != ALGO_SINGLE_PATH) {
+		*info->dev_algo = ALGO_SINGLE_PATH;
+		rq_log(tmpctx, rq, LOG_DBG,
+		       "Layer no_mpp_support is active we switch to a "
+		       "single path algorithm.");
+	}
+
 	/* Compute the routes. At this point we might select between multiple
 	 * algorithms. Right now there is only one algorithm available. */
 	struct timemono time_start = time_mono();
-	assert(*info->dev_algo == ALGO_DEFAULT);
-	err = default_routes(rq, rq, srcnode, dstnode, *info->amount,
-			     /* only one path? = */
-			     have_layer(info->layers, "auto.no_mpp_support"),
-			     *info->maxfee, *info->finalcltv, *info->maxdelay,
-			     &flows, &probability);
+	if (*info->dev_algo == ALGO_SINGLE_PATH){
+		err = single_path_routes(
+		    rq, rq, srcnode, dstnode, *info->amount,
+		    *info->maxfee, *info->finalcltv, *info->maxdelay, &flows,
+		    &probability);
+	} else {
+		assert(*info->dev_algo == ALGO_DEFAULT);
+		err = default_routes(rq, rq, srcnode, dstnode, *info->amount,
+				     *info->maxfee, *info->finalcltv,
+				     *info->maxdelay, &flows, &probability);
+	}
 	struct timerel time_delta = timemono_between(time_mono(), time_start);
 
 	/* log the time of computation */

plugins/askrene/mcf.c

@@ -948,8 +948,7 @@ struct flow **minflow(const tal_t *ctx,
 		      const struct gossmap_node *target,
 		      struct amount_msat amount,
 		      u32 mu,
-		      double delay_feefactor,
-		      bool single_part)
+		      double delay_feefactor)
 {
 	struct flow **flow_paths;
 	/* We allocate everything off this, and free it at the end,
@@ -1040,31 +1039,6 @@ struct flow **minflow(const tal_t *ctx,
 		goto fail;
 	}
 	tal_free(working_ctx);
-
-	/* This is dumb, but if you don't support MPP you don't deserve any
-	 * better.  Pile it into the largest part if not already. */
-	if (single_part) {
-		struct flow *best = flow_paths[0];
-		for (size_t i = 1; i < tal_count(flow_paths); i++) {
-			if (amount_msat_greater(flow_paths[i]->delivers, best->delivers))
-				best = flow_paths[i];
-		}
-		for (size_t i = 0; i < tal_count(flow_paths); i++) {
-			if (flow_paths[i] == best)
-				continue;
-			if (!amount_msat_accumulate(&best->delivers,
-						    flow_paths[i]->delivers)) {
-				rq_log(tmpctx, rq, LOG_BROKEN,
-				       "%s: failed to extract accumulate flow paths %s+%s",
-				       __func__,
-				       fmt_amount_msat(tmpctx, best->delivers),
-				       fmt_amount_msat(tmpctx, flow_paths[i]->delivers));
-				goto fail;
-			}
-		}
-		flow_paths[0] = best;
-		tal_resize(&flow_paths, 1);
-	}
 	return flow_paths;
 
 fail:
@@ -1269,13 +1243,16 @@ struct flow **single_path_flow(const tal_t *ctx, const struct route_query *rq,
 	return NULL;
 }
 
-const char *default_routes(const tal_t *ctx, struct route_query *rq,
-			   const struct gossmap_node *srcnode,
-			   const struct gossmap_node *dstnode,
-			   struct amount_msat amount, bool single_path,
-			   struct amount_msat maxfee, u32 finalcltv,
-			   u32 maxdelay, struct flow ***flows,
-			   double *probability)
+static const char *
+linear_routes(const tal_t *ctx, struct route_query *rq,
+	      const struct gossmap_node *srcnode,
+	      const struct gossmap_node *dstnode, struct amount_msat amount,
+	      struct amount_msat maxfee, u32 finalcltv, u32 maxdelay,
+	      struct flow ***flows, double *probability,
+	      struct flow **(*solver)(const tal_t *, const struct route_query *,
+				      const struct gossmap_node *,
+				      const struct gossmap_node *,
+				      struct amount_msat, u32, double))
 {
 	*flows = NULL;
 	const char *ret;
@@ -1284,8 +1261,7 @@ const char *default_routes(const tal_t *ctx, struct route_query *rq,
 	/* First up, don't care about fees (well, just enough to tiebreak!) */
 	u32 mu = 1;
 	tal_free(*flows);
-	*flows = minflow(ctx, rq, srcnode, dstnode, amount, mu, delay_feefactor,
-			single_path);
+	*flows = solver(ctx, rq, srcnode, dstnode, amount, mu, delay_feefactor);
 	if (!*flows) {
 		ret = explain_failure(ctx, rq, srcnode, dstnode, amount);
 		goto fail;
@@ -1300,8 +1276,8 @@ const char *default_routes(const tal_t *ctx, struct route_query *rq,
 		       flows_worst_delay(*flows), maxdelay - finalcltv,
 		       delay_feefactor);
 		tal_free(*flows);
-		*flows = minflow(ctx, rq, srcnode, dstnode, amount, mu,
-				delay_feefactor, single_path);
+		*flows = solver(ctx, rq, srcnode, dstnode, amount, mu,
+				delay_feefactor);
 		if (!*flows || delay_feefactor > 10) {
 			ret = rq_log(
 			    ctx, rq, LOG_UNUSUAL,
@@ -1324,9 +1300,8 @@ const char *default_routes(const tal_t *ctx, struct route_query *rq,
 		       "retrying with mu of %u%%...",
 		       fmt_amount_msat(tmpctx, flowset_fee(rq->plugin, *flows)),
 		       fmt_amount_msat(tmpctx, maxfee), mu);
-		new_flows =
-		    minflow(ctx, rq, srcnode, dstnode, amount,
-			    mu > 100 ? 100 : mu, delay_feefactor, single_path);
+		new_flows = solver(ctx, rq, srcnode, dstnode, amount,
+				   mu > 100 ? 100 : mu, delay_feefactor);
 		if (!*flows || mu >= 100) {
 			ret = rq_log(
 			    ctx, rq, LOG_UNUSUAL,
@@ -1407,3 +1382,27 @@ const char *default_routes(const tal_t *ctx, struct route_query *rq,
 	assert(ret != NULL);
 	return ret;
 }
+
+const char *default_routes(const tal_t *ctx, struct route_query *rq,
+			   const struct gossmap_node *srcnode,
+			   const struct gossmap_node *dstnode,
+			   struct amount_msat amount, struct amount_msat maxfee,
+			   u32 finalcltv, u32 maxdelay, struct flow ***flows,
+			   double *probability)
+{
+	return linear_routes(ctx, rq, srcnode, dstnode, amount, maxfee,
+			     finalcltv, maxdelay, flows, probability, minflow);
+}
+
+const char *single_path_routes(const tal_t *ctx, struct route_query *rq,
+			       const struct gossmap_node *srcnode,
+			       const struct gossmap_node *dstnode,
+			       struct amount_msat amount,
+			       struct amount_msat maxfee, u32 finalcltv,
+			       u32 maxdelay, struct flow ***flows,
+			       double *probability)
+{
+	return linear_routes(ctx, rq, srcnode, dstnode, amount, maxfee,
+			     finalcltv, maxdelay, flows, probability,
+			     single_path_flow);
+}

plugins/askrene/mcf.h

@@ -31,8 +31,7 @@ struct flow **minflow(const tal_t *ctx,
 		      const struct gossmap_node *target,
 		      struct amount_msat amount,
 		      u32 mu,
-		      double delay_feefactor,
-		      bool single_part);
+		      double delay_feefactor);
 
 /**
  * API for min cost single path.
@@ -67,9 +66,18 @@ struct amount_msat linear_flow_cost(const struct flow *flow,
 const char *default_routes(const tal_t *ctx, struct route_query *rq,
 			   const struct gossmap_node *srcnode,
 			   const struct gossmap_node *dstnode,
-			   struct amount_msat amount, bool single_path,
+			   struct amount_msat amount,
 			   struct amount_msat maxfee, u32 finalcltv,
 			   u32 maxdelay, struct flow ***flows,
 			   double *probability);
 
+/* A wrapper to the single-path constrained solver. */
+const char *single_path_routes(const tal_t *ctx, struct route_query *rq,
+			       const struct gossmap_node *srcnode,
+			       const struct gossmap_node *dstnode,
+			       struct amount_msat amount,
+			       struct amount_msat maxfee, u32 finalcltv,
+			       u32 maxdelay, struct flow ***flows,
+			       double *probability);
+
 #endif /* LIGHTNING_PLUGINS_ASKRENE_MCF_H */

tests/test_askrene.py

@@ -568,25 +568,88 @@ def test_getroutes(node_factory):
                             'amount_msat': 5500005,
                             'delay': 99 + 6}]])
 
-    # We realize that this is impossible in a single path:
-    with pytest.raises(RpcError, match="The shortest path is 0x2x1, but 0x2x1/1 marked disabled by layer auto.no_mpp_support."):
-        l1.rpc.getroutes(source=nodemap[0],
-                         destination=nodemap[2],
-                         amount_msat=10000000,
-                         layers=['auto.no_mpp_support'],
-                         maxfee_msat=1000,
-                         final_cltv=99)
 
-    # But this will work.
-    check_getroute_paths(l1,
-                         nodemap[0],
-                         nodemap[2],
-                         9000000,
-                         [[{'short_channel_id_dir': '0x2x3/1',
-                            'next_node_id': nodemap[2],
-                            'amount_msat': 9000009,
-                            'delay': 99 + 6}]],
-                         layers=['auto.no_mpp_support'])
+def test_getroutes_single_path(node_factory):
+    """Test getroutes generating single path payments"""
+    gsfile, nodemap = generate_gossip_store(
+        [
+            GenChannel(0, 1),
+            GenChannel(1, 2, capacity_sats=9000),
+            GenChannel(1, 2, capacity_sats=10000),
+        ]
+    )
+    # Set up l1 with this as the gossip_store
+    l1 = node_factory.get_node(gossip_store_file=gsfile.name)
+
+    # To be able to route this amount two parts are needed, therefore a single
+    # pay search will fail.
+    # FIXME: the explanation for the failure is wrong
+    with pytest.raises(RpcError):
+        l1.rpc.getroutes(
+            source=nodemap[1],
+            destination=nodemap[2],
+            amount_msat=10000001,
+            layers=["auto.no_mpp_support"],
+            maxfee_msat=1000,
+            final_cltv=99,
+        )
+
+    # For this amount, only one solution is possible
+    check_getroute_paths(
+        l1,
+        nodemap[1],
+        nodemap[2],
+        10000000,
+        [
+            [
+                {
+                    "short_channel_id_dir": "1x2x2/1",
+                    "next_node_id": nodemap[2],
+                    "amount_msat": 10000010,
+                    "delay": 99 + 6,
+                }
+            ]
+        ],
+        layers=["auto.no_mpp_support"],
+    )
+
+    # To be able to route this amount two parts are needed, therefore a single
+    # pay search will fail.
+    # FIXME: the explanation for the failure is wrong
+    with pytest.raises(RpcError):
+        l1.rpc.getroutes(
+            source=nodemap[0],
+            destination=nodemap[2],
+            amount_msat=10000001,
+            layers=["auto.no_mpp_support"],
+            maxfee_msat=1000,
+            final_cltv=99,
+        )
+
+    # For this amount, only one solution is possible
+    check_getroute_paths(
+        l1,
+        nodemap[0],
+        nodemap[2],
+        10000000,
+        [
+            [
+                {
+                    "short_channel_id_dir": "0x1x0/1",
+                    "next_node_id": nodemap[1],
+                    "amount_msat": 10000020,
+                    "delay": 99 + 6 + 6,
+                },
+                {
+                    "short_channel_id_dir": "1x2x2/1",
+                    "next_node_id": nodemap[2],
+                    "amount_msat": 10000010,
+                    "delay": 99 + 6,
+                },
+            ]
+        ],
+        layers=["auto.no_mpp_support"],
+    )
 
 
 def test_getroutes_fee_fallback(node_factory):