askrene: flexible liquidity bounds

Liquidity bounds are estimated starting from the observations gathered
from askrene-inform-channel but are also evolved in time, so that older
entries have less weight in the outcome than recent ones. Also when
combined, these intel entries are relaxed base on the likelyhood of the
observation with the prior knowledge, eg. observing a channel failure
when Pickhardt-Richer probability of success is 99% indicates that it is
likely that our prior knowledge was wrong.

Changelog-Fixed: askrene-getroutes: liquidity bounds evolve with time and with the evidence gathered from askrene-inform-channel

Signed-off-by: Lagrang3 <lagrang3@protonmail.com>

Author: Lagrang3

plugins/askrene/child/mcf.c

@@ -357,9 +357,9 @@ static bool channel_is_available(const struct route_query *rq,
  * @low: the liquidity is known to be greater or equal than "low"
  * @high: the liquidity is known to be less than "high"
  * @amount: how much is required to forward */
-static double pickhardt_richter_probability(struct amount_msat low,
-					    struct amount_msat high,
-					    struct amount_msat amount)
+double pickhardt_richter_probability(struct amount_msat low,
+				     struct amount_msat high,
+				     struct amount_msat amount)
 {
 	struct amount_msat all_states, good_states;
 	if (amount_msat_greater_eq(amount, high))

plugins/askrene/child/mcf.h

@@ -9,6 +9,7 @@
 #include <common/jsonrpc_errors.h>
 
 struct route_query;
+struct flow;
 
 /* A wrapper to the min. cost flow solver that actually takes into consideration
  * the extra msats per channel needed to pay for fees. */
@@ -33,4 +34,13 @@ const char *single_path_routes(const tal_t *ctx, struct route_query *rq,
 			       double *probability,
 			       enum jsonrpc_errcode *ecode);
 
+/* The probability of forwarding a payment amount given a high and low liquidity
+ * bounds.
+ * @low: the liquidity is known to be greater or equal than "low"
+ * @high: the liquidity is known to be less than "high"
+ * @amount: how much is required to forward */
+double pickhardt_richter_probability(struct amount_msat low,
+				     struct amount_msat high,
+				     struct amount_msat amount);
+
 #endif /* LIGHTNING_PLUGINS_ASKRENE_CHILD_MCF_H */

plugins/askrene/child/route_query.c

@@ -1,10 +1,23 @@
 #include "config.h"
+#include <ccan/asort/asort.h>
 #include <common/gossmap.h>
+#include <math.h>
 #include <plugins/askrene/child/additional_costs.h>
+#include <plugins/askrene/child/mcf.h>
 #include <plugins/askrene/child/route_query.h>
 #include <plugins/askrene/layer.h>
 #include <plugins/askrene/reserve.h>
 
+/* Lifetime of liquidity bounds is one day. "Lifetime" in the sense of the
+ * exponential time decay: the time it takes for the liquidity lower bound to be
+ * reduced by half is "lifetime" times ln(2) ~ 16 hours. */
+#define ASKRENE_RELAX_TIME_SECS 86400
+
+/* It could be any number between 0 and 1. It represents the fraction of lower
+ * liquidity bound that we adjust when we find a failure. The smaller it is the
+ * more we trust previous knowledge. Similar to a "learning velocity" for AI. */
+#define ASKRENE_FAILURE_RELAX_FRACTION 0.5
+
 struct amount_msat get_additional_per_htlc_cost(const struct route_query *rq,
 						const struct short_channel_id_dir *scidd)
 {
@@ -16,6 +29,169 @@ struct amount_msat get_additional_per_htlc_cost(const struct route_query *rq,
 		return AMOUNT_MSAT(0);
 }
 
+static int constraint_cmp(const struct constraint *a,
+			  const struct constraint *b, void *unused)
+{
+	if (a->timestamp < b->timestamp)
+		return -1;
+	if (a->timestamp > b->timestamp)
+		return 1;
+	return 0;
+}
+
+/* Like a capacitor discharging, this is the physical process of information
+ * getting older and entropy increasing. It satisfies the semigroup property so
+ * it is a well defined Markovian time evolution operation. Same for the
+ * "charge" operation.
+ * 	Dicharge(x, t) = x * exp(-t/lifetime)
+ * 	Charge(x, t) = C - (C -x) * exp(-t/lifetime)
+ *
+ * 	Discharge(x, t1+t2) = Discharge(Discharge(x, t1), t2),
+ * 	Charge(x, t1+t2) = Charge(Charge(x, t1), t2),
+ *
+ * @min: apply discharge to it,
+ * @max: apply charge to it,
+ * @capacity: "capacitor"'s capacity,
+ * @time_delta: time interval in seconds, 0-> nothing changes, infinity->full
+ * charge/discharge
+ * @lifetime: characteristic time of the system in seconds, ie. min is reduced
+ * by half after ln(2)*lifetime seconds.
+ */
+// FIXME: unit test
+static void exponential_time_charge_discharge(struct amount_msat *min,
+					      struct amount_msat *max,
+					      const struct amount_msat capacity,
+					      const u64 time_delta,
+					      const u64 lifetime)
+{
+	double factor = exp((-1.0 * time_delta) / lifetime);
+	struct amount_msat residual;
+
+	if (!amount_msat_scale(min, *min, factor))
+		goto fail;
+
+	if (!amount_msat_sub(&residual, capacity, *max))
+		goto fail;
+	if (!amount_msat_scale(&residual, residual, factor))
+		goto fail;
+	if (!amount_msat_sub(max, capacity, residual))
+		goto fail;
+
+fail:
+	/* It should not fail, but if it does, we default to 0 knowledge. */
+	*min = AMOUNT_MSAT(0);
+	*max = capacity;
+}
+
+/* Computes min/max bounds based on known constraints. It self-adjusts for
+ * contradictory information giving precedence to more recent constraints. Time
+ * decay is considered.
+ * FIXME: this approach was completey cooked by hand because it is better than
+ * simply trusting all constraints as we have seen during tests (see CLN #9282).
+ * However it would be nice to have a theoretically sound adjustment, eg.
+ * Maximum Likelyhood, if applicable. */
+// FIXME: unit test
+static void constraints_get_bounds_selfadjust(struct constraint *constraints,
+					      const struct amount_msat capacity,
+					      struct amount_msat *min,
+					      struct amount_msat *max)
+{
+	assert(ASKRENE_FAILURE_RELAX_FRACTION >= 0.0 &&
+	       ASKRENE_FAILURE_RELAX_FRACTION <= 1.0);
+	u64 last_timestamp = 0, delta;
+	double prob_fail;
+	struct amount_msat x, amount, high;
+
+	*min = AMOUNT_MSAT(0);
+	*max = capacity;
+	asort(constraints, tal_count(constraints), constraint_cmp, NULL);
+	for (size_t i = 0; i < tal_count(constraints); i++) {
+		assert(constraints[i].timestamp >= last_timestamp);
+		delta = constraints[i].timestamp - last_timestamp;
+		last_timestamp = constraints[i].timestamp;
+
+		/* time relax the bound we carry */
+		exponential_time_charge_discharge(min, max, capacity, delta,
+						  ASKRENE_RELAX_TIME_SECS);
+
+		if (amount_msat_greater_eq(constraints[i].max,
+					   AMOUNT_MSAT(UINT64_MAX))) {
+			/* this is an "unconstrained" event, a min value bound
+			 */
+			x = constraints[i].min;
+			*min = amount_msat_max(*min, x);
+			*max = amount_msat_max(*max, x);
+		} else {
+			/* this is a "constrained" event, a max value bound */
+			x = constraints[i].max;
+			if (amount_msat_greater(x, *max)) {
+				/* Trivial case, we were expecting x to fail. */
+			} else if (amount_msat_less(x, *min)) {
+				/* This should have succeeded 100% of the times,
+				 * our knowledge was wrong. */
+				*min = amount_msat_min(*min, x);
+				*max = amount_msat_min(*max, x);
+				if (!amount_msat_scale(
+					min, *min,
+					1.0 - ASKRENE_FAILURE_RELAX_FRACTION)) {
+					*min = AMOUNT_MSAT(0);
+				}
+			} else {
+				/* We got failure for a quantity between min and
+				 * max bounds. We relax a little the lower bound
+				 * in relation to the probability of this event
+				 * taking place. If p~1 this was expected,
+				 * min/max reflected reality. On the other hand
+				 * if p~0, we were either unlucky or more likely
+				 * our lower bound was too high. */
+
+				/* off-by-one because the high bound in MCF
+				 * means "we know the liquidity is below this
+				 * value", which makes some equations take a
+				 * simpler form. */
+				if (!amount_msat_add(&high, *max,
+						     AMOUNT_MSAT(1)))
+					high = capacity;
+				/* off-by-one because
+				 * json_askrene_inform_channel already
+				 * substracted 1msat here, meaning we tried x+1
+				 * and it failed. */
+				if (!amount_msat_add(&amount, x,
+						     AMOUNT_MSAT(1)))
+					amount = capacity;
+				prob_fail = 1.0 - pickhardt_richter_probability(
+						      *min, high, amount);
+				assert(prob_fail >= 0 && prob_fail <= 1.0);
+
+				*max = amount_msat_min(*max, x);
+				if (!amount_msat_scale(
+					min, *min,
+					1.0 + ASKRENE_FAILURE_RELAX_FRACTION *
+						  (prob_fail - 1.0))) {
+					*min = AMOUNT_MSAT(0);
+				}
+			}
+		}
+	}
+}
+
+/* Constraints produced bounds this way since askrene was first written. We keep
+ * it around momentarily. */
+// static void constraints_get_bounds_legacy(const struct constraint *constraints,
+// 					  const struct amount_msat capacity,
+// 					  struct amount_msat *min,
+// 					  struct amount_msat *max)
+// {
+// 	*min = AMOUNT_MSAT(0);
+// 	*max = capacity;
+// 	for (size_t i = 0; i < tal_count(constraints); i++) {
+// 		*min = amount_msat_max(*min, constraints[i].min);
+// 		*max = amount_msat_min(*max, constraints[i].max);
+// 	}
+// 	if(amount_msat_greater(*min, *max))
+// 		*min = *max;
+// }
+
 void get_constraints(const struct route_query *rq,
 		     const struct gossmap_chan *chan,
 		     int dir,
@@ -24,28 +200,29 @@ void get_constraints(const struct route_query *rq,
 {
 	struct short_channel_id_dir scidd;
 	size_t idx = gossmap_chan_idx(rq->gossmap, chan);
-
-	*min = AMOUNT_MSAT(0);
+	struct constraint *constraints = tal_arr(rq, struct constraint, 0);
 
 	/* Fast path: no information known, no reserve. */
 	if (idx < tal_count(rq->capacities) && rq->capacities[idx] != 0) {
+		*min = AMOUNT_MSAT(0);
 		*max = amount_msat(fp16_to_u64(rq->capacities[idx]) * 1000);
 		return;
 	}
 
+	const struct amount_msat capacity =
+	    gossmap_chan_get_capacity(rq->gossmap, chan);
+
 	/* Naive implementation! */
 	scidd.scid = gossmap_chan_scid(rq->gossmap, chan);
 	scidd.dir = dir;
-	*max = AMOUNT_MSAT(-1ULL);
 
 	/* Look through layers for any constraints (might be dummy
 	 * ones, for created channels!) */
 	for (size_t i = 0; i < tal_count(rq->layers); i++)
-		layer_apply_constraints(rq->layers[i], &scidd, min, max);
+		constraints = layer_get_constraints(rq, rq->layers[i], &scidd,
+						    take(constraints));
 
-	/* Might be here because it's reserved, but capacity is normal. */
-	if (amount_msat_eq(*max, AMOUNT_MSAT(-1ULL)))
-		*max = gossmap_chan_get_capacity(rq->gossmap, chan);
+	constraints_get_bounds_selfadjust(constraints, capacity, min, max);
 
 	/* Finally, if any is in use, subtract that! */
 	reserve_sub(rq->reserved, &scidd, rq->layers, min);

plugins/askrene/layer.c

@@ -34,17 +34,6 @@ struct local_update {
 	const struct amount_msat *htlc_min, *htlc_max;
 };
 
-/* A constraint reflects something we learned about a channel */
-struct constraint {
-	struct short_channel_id_dir scidd;
-	/* Time this constraint was last updated */
-	u64 timestamp;
-	/* Non-zero means set */
-	struct amount_msat min;
-	/* Non-0xFFFFF.... means set */
-	struct amount_msat max;
-};
-
 /* A bias, for special-effects (user-controlled) */
 struct bias {
 	struct short_channel_id_dir scidd;
@@ -1010,6 +999,24 @@ void layer_apply_constraints(const struct layer *layer,
 	}
 }
 
+struct constraint *
+layer_get_constraints(const tal_t *ctx, const struct layer *layer,
+		      const struct short_channel_id_dir *scidd,
+		      struct constraint *in_constraints TAKES)
+{
+	struct constraint *c;
+	struct constraint_hash_iter cit;
+	struct constraint *constraints =
+	    tal_dup_talarr(ctx, struct constraint, in_constraints);
+
+	/* We can have more than one: apply them all! */
+	for (c = constraint_hash_getfirst(layer->constraints, scidd, &cit); c;
+	     c = constraint_hash_getnext(layer->constraints, scidd, &cit)) {
+		tal_arr_expand(&constraints, *c);
+	}
+	return constraints;
+}
+
 const struct constraint *layer_add_constraint(struct layer *layer,
 					      const struct short_channel_id_dir *scidd,
 					      u64 timestamp,

plugins/askrene/layer.h

@@ -18,6 +18,17 @@ struct command;
 struct layer;
 struct json_stream;
 
+/* A constraint reflects something we learned about a channel */
+struct constraint {
+	struct short_channel_id_dir scidd;
+	/* Time this constraint was last updated */
+	u64 timestamp;
+	/* Non-zero means set */
+	struct amount_msat min;
+	/* Non-0xFFFFF.... means set */
+	struct amount_msat max;
+};
+
 /* Create a layer hash table */
 struct layer_name_hash *new_layer_name_hash(const tal_t *ctx);
 
@@ -102,6 +113,13 @@ void layer_apply_constraints(const struct layer *layer,
 			     struct amount_msat *max)
 	NO_NULL_ARGS;
 
+/* Fetches from this layer all constraints entries that match the scidd
+ * provided. */
+struct constraint *
+layer_get_constraints(const tal_t *ctx, const struct layer *layer,
+		      const struct short_channel_id_dir *scidd,
+		      struct constraint *in_constraints TAKES);
+
 /* Apply biases from a layer. */
 void layer_apply_biases(const struct layer *layer,
 			const struct gossmap *gossmap,

plugins/xpay/xpay.c

@@ -31,6 +31,9 @@
 
 #define PREIMAGE_TLV_TYPE 5482373484
 
+/* Entries older than 1 week are thrown away. */
+#define XPAY_AGE_TIME_SECS 604800
+
 /* For the whole plugin */
 struct xpay {
 	/* This is me. */
@@ -2966,7 +2969,7 @@ static struct command_result *age_layer(struct command *cmd, struct payment *pay
 				    plugin_broken_cb,
 				    payment);
 	json_add_string(req->js, "layer", "xpay");
-	json_add_u64(req->js, "cutoff", clock_time().ts.tv_sec - 3600);
+	json_add_u64(req->js, "cutoff", clock_time().ts.tv_sec - XPAY_AGE_TIME_SECS);
 	return send_outreq(req);
 }
 

tests/test_xpay.py

@@ -228,7 +228,6 @@ def test_xpay_selfpay(node_factory):
 canned_gossmap_badnodes = [19, 53, 69, 72, 86]
 
 
-@pytest.mark.skip(reason="askrene-getroutes breaks after the fakenet upgrade")
 @pytest.mark.slow_test
 @unittest.skipIf(TEST_NETWORK != 'regtest', '29-way split for node 17 is too dusty on elements')
 @pytest.mark.parametrize("slow_mode", [False, True])