[WIP] askrene: add a single path solver

Changelog-Added: askrene: add a routing algorithm for payments that do not support MPP

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

@@ -949,6 +949,46 @@ get_flow_paths(const tal_t *ctx,
 	return flows;
 }
 
+/* Given a single path build a flow set. */
+static struct flow **
+get_flow_singlepath(const tal_t *ctx, const tal_t *working_ctx,
+		    const struct graph *graph, const struct gossmap *gossmap,
+		    const struct node source, const struct node destination,
+		    const u64 pay_amount, const struct arc *prev)
+{
+	struct flow **flows = tal_arr(ctx, struct flow *, 0);
+
+	size_t length = 0;
+
+	for (u32 cur_idx = destination.idx; cur_idx != source.idx;) {
+		assert(cur_idx != INVALID_INDEX);
+		length++;
+		struct arc arc = prev[cur_idx];
+		struct node next = arc_tail(graph, arc);
+		cur_idx = next.idx;
+	}
+	struct flow *f = tal(ctx, struct flow);
+	f->path = tal_arr(f, const struct gossmap_chan *, length);
+	f->dirs = tal_arr(f, int, length);
+
+	for (u32 cur_idx = destination.idx; cur_idx != source.idx;) {
+		int chandir;
+		u32 chanidx;
+		struct arc arc = prev[cur_idx];
+		arc_to_parts(arc, &chanidx, &chandir, NULL, NULL);
+
+		length--;
+		f->path[length] = gossmap_chan_byidx(gossmap, chanidx);
+		f->dirs[length] = chandir;
+
+		struct node next = arc_tail(graph, arc);
+		cur_idx = next.idx;
+	}
+
+	tal_arr_expand(&flows, f);
+	return flows;
+}
+
 // TODO(eduardo): choose some default values for the minflow parameters
 /* eduardo: I think it should be clear that this module deals with linear
  * flows, ie. base fees are not considered. Hence a flow along a path is
@@ -967,8 +1007,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,
@@ -1051,31 +1090,105 @@ struct flow **minflow(const tal_t *ctx,
 		goto fail;
 	}
 	tal_free(working_ctx);
+	return flow_paths;
 
-	/* 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);
+fail:
+	tal_free(working_ctx);
+	return NULL;
+}
+
+static struct flow **single_path_flow(const tal_t *ctx,
+				      const struct route_query *rq,
+				      const struct gossmap_node *source,
+				      const struct gossmap_node *target,
+				      struct amount_msat amount, u32 mu,
+				      double delay_feefactor)
+{
+	struct flow **flow_paths;
+	/* We allocate everything off this, and free it at the end,
+	 * as we can be called multiple times without cleaning tmpctx! */
+	tal_t *working_ctx = tal(NULL, char);
+	struct pay_parameters *params = tal(working_ctx, struct pay_parameters);
+
+	params->rq = rq;
+	params->source = source;
+	params->target = target;
+	params->amount = amount;
+	/* for the single-path solver the accuracy does not detriment
+	 * performance */
+	params->accuracy = AMOUNT_MSAT(1000);
+	params->delay_feefactor = delay_feefactor;
+	params->base_fee_penalty = base_fee_penalty_estimate(amount);
+
+	// build the uncertainty network with linearization and residual arcs
+	struct linear_network *linear_network =
+	    init_linear_network(working_ctx, params);
+
+	const size_t max_num_chans = gossmap_max_chan_idx(rq->gossmap);
+	const size_t max_num_arcs = max_num_chans * ARCS_PER_CHANNEL;
+	const size_t max_num_nodes = gossmap_max_node_idx(rq->gossmap);
+
+	struct graph *graph = graph_new(working_ctx, max_num_nodes,
+					max_num_arcs, ARC_DUAL_BITOFF);
+	double *arc_prob_cost = tal_arr(working_ctx, double, max_num_arcs);
+	for (size_t i = 0; i < max_num_arcs; ++i)
+		arc_prob_cost[i] = DBL_MAX;
+	s64 *arc_fee_cost = tal_arr(working_ctx, s64, max_num_arcs);
+	for (size_t i = 0; i < max_num_arcs; ++i)
+		arc_fee_cost[i] = INT64_MAX;
+	s64 *capacity = tal_arrz(working_ctx, s64, max_num_arcs);
+
+	// FIXME: compute costs for arcs
+
+	const struct node dst = {.idx = gossmap_node_idx(rq->gossmap, target)};
+	const struct node src = {.idx = gossmap_node_idx(rq->gossmap, source)};
+
+	/* Since we have constraint accuracy, ask to find a payment solution
+	 * that can pay a bit more than the actual value rather than undershoot
+	 * it. That's why we use the ceil function here. */
+	const u64 pay_amount =
+	    amount_msat_ratio_ceil(params->amount, params->accuracy);
+
+	// FIXME: combine cost functions
+	combine_cost_function(working_ctx, linear_network, residual_network,
+			      rq->biases, mu);
+
+	s64 *potential = tal_arrz(working_ctx, s64, max_num_nodes);
+	s64 *distance = tal_arrz(working_ctx, s64, max_num_nodes);
+	struct arc *prev = tal_arrz(working_ctx, struct arc, max_num_nodes);
+
+	/* We solve a linear cost flow problem. */
+	if (!dijkstra_path(working_ctx, linear_network->graph, src, dst,
+			   /* prune = */ true, residual_network->cap,
+			   pay_amount, residual_network->cost, potential, prev,
+			   distance)) {
+		rq_log(tmpctx, rq, LOG_BROKEN,
+		       "%s: could not find a feasible single path", __func__);
+		goto fail;
 	}
+
+	/* We dissect the flow into payment routes.
+	 * Actual amounts considering fees are computed for every
+	 * channel in the routes. */
+	flow_paths =
+	    get_flow_singlepath(ctx, working_ctx, linear_network->graph,
+				rq->gossmap, src, dst, pay_amount, prev);
+	if (!flow_paths) {
+		rq_log(tmpctx, rq, LOG_BROKEN,
+		       "%s: failed to extract flow paths from the single-path "
+		       "solution",
+		       __func__);
+		goto fail;
+	}
+	if (tal_count(flow_paths) != 1) {
+		rq_log(
+		    tmpctx, rq, LOG_BROKEN,
+		    "%s: single-path solution returned a multi route solution",
+		    __func__);
+		goto fail;
+	}
+	tal_free(working_ctx);
+
 	return flow_paths;
 
 fail:
@@ -1099,22 +1212,22 @@ static struct amount_msat linear_flows_cost(struct flow **flows,
 	return total;
 }
 
-
-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_cb)(const tal_t *, const struct route_query *,
+			       const struct gossmap_node *,
+			       const struct gossmap_node *, struct amount_msat,
+			       u32, double))
 {
 	const char *ret;
 	double delay_feefactor = 1.0 / 1000000;
 
 	/* First up, don't care about fees (well, just enough to tiebreak!) */
 	u32 mu = 1;
-	*flows = minflow(ctx, rq, srcnode, dstnode, amount, mu, delay_feefactor,
-			single_path);
+	*flows = solver_cb(ctx, rq, srcnode, dstnode, amount, mu, delay_feefactor);
 	if (!*flows) {
 		ret = explain_failure(ctx, rq, srcnode, dstnode, amount);
 		goto fail;
@@ -1128,8 +1241,8 @@ const char *default_routes(const tal_t *ctx, struct route_query *rq,
 		       " (> %i), retrying with delay_feefactor %f...",
 		       flows_worst_delay(*flows), maxdelay - finalcltv,
 		       delay_feefactor);
-		*flows = minflow(ctx, rq, srcnode, dstnode, amount, mu,
-				delay_feefactor, single_path);
+		*flows = solver_cb(ctx, rq, srcnode, dstnode, amount, mu,
+				   delay_feefactor);
 		if (!*flows || delay_feefactor > 10) {
 			ret = rq_log(
 			    ctx, rq, LOG_UNUSUAL,
@@ -1152,9 +1265,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_cb(ctx, rq, srcnode, dstnode, amount,
+				      mu > 100 ? 100 : mu, delay_feefactor);
 		if (!*flows || mu >= 100) {
 			ret = rq_log(
 			    ctx, rq, LOG_UNUSUAL,
@@ -1235,3 +1347,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);
 
 /* To sanity check: this is the approximation mcf uses for the cost
  * of each channel. */
@@ -45,9 +44,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 */