renepay: use rpcActions to unreserve routes

Calling askrene-unreserve using rpcActions.
Either:
- after geting a fail notification,
- or success notification,
- or if the route destructor is called.

Changelog-None

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

Author: Lagrang3

plugins/renepay/json.c

@@ -67,6 +67,7 @@ struct route *tal_route_from_json(const tal_t *ctx, const char *buf,
 	route->final_msg = NULL;
 	route->final_error = LIGHTNINGD;
 	route->shared_secrets = NULL;
+	route->unreserve_action = NULL;
 
 	return route;
 fail:

plugins/renepay/mods.c

@@ -594,42 +594,55 @@ REGISTER_PAYMENT_MODIFIER(getroutes, getroutes_cb);
  * Use askrene API to reserve liquidity on the computed routes.
  */
 
-static struct command_result *unreserve_done(struct command *aux_cmd,
-					     const char *method UNUSED,
-					     const char *buf UNUSED,
-					     const jsmntok_t *result UNUSED,
-					     struct route *route UNUSED)
+static struct command_result *
+unreserve_done(struct command *cmd, const char *method, const char *buf,
+	       const jsmntok_t *result, struct route *route UNUSED)
 {
-	return aux_command_done(aux_cmd);
+	route->unreserve_action = tal_free(route->unreserve_action);
+	return command_still_pending(cmd);
 }
 
 static struct command_result *
-unreserve_fail(struct command *aux_cmd, const char *method, const char *buf,
+unreserve_fail(struct command *cmd, const char *method, const char *buf,
 	       const jsmntok_t *result, struct route *route UNUSED)
 {
-	plugin_log(aux_cmd->plugin, LOG_UNUSUAL, "%s failed: %.*s", method,
+	plugin_log(cmd->plugin, LOG_UNUSUAL, "%s failed: %.*s", method,
 		   json_tok_full_len(result), json_tok_full(buf, result));
-	return aux_command_done(aux_cmd);
+	return command_still_pending(cmd);
 }
 
-static void unreserve_route(struct route *route, struct command *aux_cmd)
+static void json_unreserve(struct json_stream *js, struct route *route)
 {
-	struct out_req *req =
-	    jsonrpc_request_start(aux_cmd, "askrene-unreserve", unreserve_done,
-				  unreserve_fail, route);
-	json_array_start(req->js, "path");
+	json_array_start(js, "path");
 	for (size_t i = 0; i < tal_count(route->hops); i++) {
 		const struct route_hop *hop = &route->hops[i];
 		struct short_channel_id_dir scidd = {.scid = hop->scid,
 						     .dir = hop->direction};
-		json_object_start(req->js, NULL);
-		json_add_short_channel_id_dir(req->js, "short_channel_id_dir",
+		json_object_start(js, NULL);
+		json_add_short_channel_id_dir(js, "short_channel_id_dir",
 					      scidd);
-		json_add_amount_msat(req->js, "amount_msat", hop->amount);
-		json_object_end(req->js);
+		json_add_amount_msat(js, "amount_msat", hop->amount);
+		json_object_end(js);
 	}
-	json_array_end(req->js);
-	send_outreq(req);
+	json_array_end(js);
+}
+
+static struct command_result *unreserve_aux_final(struct command *aux_cmd,
+						  struct route *route)
+{
+	return aux_command_done(aux_cmd);
+}
+
+static void unreserve_route(struct route *route, struct command *aux_cmd)
+{
+	struct rpcbatch *batch =
+	    rpcbatch_new(aux_cmd, unreserve_aux_final, route);
+	if (route->unreserve_action) {
+		struct out_req *req =
+		    rpcbatch_append_action(batch, route->unreserve_action);
+		send_outreq(req);
+	}
+	rpcbatch_done(batch);
 }
 
 static struct command_result *reserve_done(struct command *cmd,
@@ -639,8 +652,15 @@ static struct command_result *reserve_done(struct command *cmd,
 					   struct route *route)
 {
 	/* A new command is issued to handle the destruction of this route.
-	 * I hope aux_cmd outlives the current payment session cmd. */
+	 * I hope aux_cmd outlives the current payment session cmd.
+	 * We encode this action as an entity of its own "struct rpcaction".
+	 * We can attach the unreserve action to the route destructor but also
+	 * if we need to unreserve after a notification we can do that as well
+	 * without repeating the same code again, just re-use the action. */
 	struct command *aux_cmd = aux_command(cmd);
+	route->unreserve_action =
+	    rpcaction_new(aux_cmd, "askrene-unreserve", unreserve_done,
+			  unreserve_fail, json_unreserve, route);
 	tal_add_destructor2(route, unreserve_route, aux_cmd);
 	return command_still_pending(cmd);
 }
@@ -664,6 +684,7 @@ static struct command_result *reserve_routes_done(struct command *cmd,
 
 static void add_reserve_request(struct rpcbatch *batch, struct route *route)
 {
+	assert(route->unreserve_action == NULL);
 	struct out_req *req = add_to_rpcbatch(
 	    batch, "askrene-reserve", reserve_done, reserve_fail, route);
 	json_array_start(req->js, "path");

plugins/renepay/route.c

@@ -21,6 +21,7 @@ struct route *new_route(const tal_t *ctx, u64 groupid,
 	route->amount_sent = amount_sent;
 	route->path_num = -1;
 	route->shared_secrets = NULL;
+	route->unreserve_action = NULL;
 	return route;
 }
 

plugins/renepay/route.h

@@ -75,6 +75,9 @@ struct route {
 
 	/* blinded path index if any */
 	int path_num;
+
+	/* An rpcaction that calls askrene-unreserve. */
+	struct rpcaction *unreserve_action;
 };
 
 static inline struct routekey routekey(const struct sha256 *hash, u64 groupid,

plugins/renepay/routefail.c

@@ -60,14 +60,24 @@ static struct command_result *routefail_done(struct command *cmd,
 	return notification_handled(cmd);
 }
 
-struct command_result *routefail_start(struct command *cmd,
-				       struct payment *payment,
-				       struct route *route)
+struct command_result *routesuccess_start(struct command *cmd,
+					  struct route *route)
 {
+	// FIXME: call askrene-inform-channel with inform=succeeded for this
+	// route
+	struct renepay *renepay = get_renepay(cmd->plugin);
+	struct payment *payment = route_get_payment_verify(renepay, route);
+	routetracker_add_to_final(payment, payment->routetracker, route);
+	return notification_handled(cmd);
+}
+
+struct command_result *routefail_start(struct command *cmd, struct route *route)
+{
+	struct renepay *renepay = get_renepay(cmd->plugin);
 	struct routefail *r = tal(cmd, struct routefail);
 	r->batch = rpcbatch_new(cmd, routefail_done, r);
 	r->route = route;
-	r->payment = payment;
+	r->payment = route_get_payment_verify(renepay, route);
 	update_gossip(r);
 	handle_failure(r);
 	return rpcbatch_done(r->batch);

plugins/renepay/routefail.h

@@ -7,7 +7,9 @@
 #include <plugins/renepay/route.h>
 
 struct command_result *routefail_start(struct command *cmd,
-				       struct payment *payment,
 				       struct route *route);
 
+struct command_result *routesuccess_start(struct command *cmd,
+					  struct route *route);
+
 #endif /* LIGHTNING_PLUGINS_RENEPAY_ROUTEFAIL_H */

plugins/renepay/routetracker.c

@@ -291,9 +291,15 @@ struct command_result *notification_sendpay_failure(struct command *cmd,
 		route->result->status = SENDPAY_FAILED;
 	}
 	get_erring_scidd_from_index(route);
-	/* we do some error processing steps before calling
-	 * route_failure_register. */
-	return routefail_start(cmd, payment, route);
+
+	/* Unreserve first and then call routefail_start */
+	struct rpcbatch *batch = rpcbatch_new(cmd, routefail_start, route);
+	if (route->unreserve_action) {
+		struct out_req *req =
+		    rpcbatch_append_action(batch, route->unreserve_action);
+		send_outreq(req);
+	}
+	return rpcbatch_done(batch);
 }
 
 struct command_result *notification_sendpay_success(struct command *cmd,
@@ -345,8 +351,12 @@ struct command_result *notification_sendpay_success(struct command *cmd,
 			   json_tok_full_len(sub), json_tok_full(buf, sub));
 
 	assert(route->result->status == SENDPAY_COMPLETE);
-	// FIXME: call askrene-inform-channel with inform=succeeded for this
-	// route
-	routetracker_add_to_final(payment, payment->routetracker, route);
-	return notification_handled(cmd);
+	/* Unreserve first and then call routesuccess_start */
+	struct rpcbatch *batch = rpcbatch_new(cmd, routesuccess_start, route);
+	if (route->unreserve_action) {
+		struct out_req *req =
+		    rpcbatch_append_action(batch, route->unreserve_action);
+		send_outreq(req);
+	}
+	return rpcbatch_done(batch);
 }