splice: Bulk channel stfu and abort RPC

The ability to stfu channels in bulk is required to do complex multi channel operations. When stfu’ing in this manner, the available funds at the moment of stfu is returned to the user.

In order to cancel the stfu we also add a bulk tx_abort command.

Changelog-Added: `stfu_channels` and `abort_channels` are added for bulk multi-channel splice commands. These allow the user to pause (and resume) multiple channels in place.

Author: ddustin

channeld/channeld.c

@@ -59,7 +59,8 @@
 
 #define VALID_STFU_MESSAGE(msg) \
 	((msg) == WIRE_SPLICE || \
-	(msg) == WIRE_SPLICE_ACK)
+	(msg) == WIRE_SPLICE_ACK || \
+	(msg) == WIRE_TX_ABORT)
 
 #define SAT_MIN(a, b) (amount_sat_less((a), (b)) ? (a) : (b))
 
@@ -4419,6 +4420,7 @@ static void handle_splice_stfu_success(struct peer *peer)
 static void handle_splice_init(struct peer *peer, const u8 *inmsg)
 {
 	u8 *msg;
+	bool skip_stfu;
 
 	/* Can't start a splice with another splice still active */
 	if (peer->splicing) {
@@ -4435,23 +4437,32 @@ static void handle_splice_init(struct peer *peer, const u8 *inmsg)
 					   &peer->splicing->current_psbt,
 					   &peer->splicing->opener_relative,
 					   &peer->splicing->feerate_per_kw,
-					   &peer->splicing->force_feerate))
+					   &peer->splicing->force_feerate,
+					   &skip_stfu))
 		master_badmsg(WIRE_CHANNELD_SPLICE_INIT, inmsg);
 
-	if (peer->want_stfu) {
+	if (!skip_stfu && peer->want_stfu) {
 		msg = towire_channeld_splice_state_error(NULL, "Can't begin a"
 							 " splice while waiting"
 							 " for STFU.");
 		wire_sync_write(MASTER_FD, take(msg));
 		return;
 	}
-	if (is_stfu_active(peer)) {
+	if (!skip_stfu && is_stfu_active(peer)) {
 		msg = towire_channeld_splice_state_error(NULL, "Can't begin a"
 							 " splice while"
 							 " currently in STFU");
 		wire_sync_write(MASTER_FD, take(msg));
 		return;
 	}
+	if (skip_stfu && !is_stfu_active(peer)) {
+		msg = towire_channeld_splice_state_error(NULL, "Can't begin a"
+							 " splice with"
+							 " skip_stfu if not"
+							 " already in STFU");
+		wire_sync_write(MASTER_FD, take(msg));
+		return;
+	}
 	if (peer->splicing->mode) {
 		msg = towire_channeld_splice_state_error(NULL, "Can't begin a"
 							 " splice while already"
@@ -4471,16 +4482,77 @@ static void handle_splice_init(struct peer *peer, const u8 *inmsg)
 		return;
 	}
 
-	status_debug("Getting handle_splice_init psbt version %d", peer->splicing->current_psbt->version);
+	status_debug("Getting handle_splice_init psbt version %d",
+		     peer->splicing->current_psbt->version);
+
+	if (skip_stfu) {
+		handle_splice_stfu_success(peer);
+	} else {
+		peer->on_stfu_success = handle_splice_stfu_success;
+
+		/* First things first we must STFU the channel */
+		peer->stfu_initiator = LOCAL;
+		peer->want_stfu = true;
+		maybe_send_stfu(peer);
+	}
+}
+
+static void handle_stfu_req_success(struct peer *peer)
+{
+	struct amount_msat available_funds = peer->channel->view->owed[LOCAL];
+	/* DTODO: Subtract reserve requirment from available_funds? */
+	wire_sync_write(MASTER_FD,
+			take(towire_channeld_confirmed_stfu(NULL,
+		   					    available_funds)));
+}
+
+static void handle_stfu_req(struct peer *peer, const u8 *inmsg)
+{
+	u8 *msg;
 
-	peer->on_stfu_success = handle_splice_stfu_success;
+	if (!fromwire_channeld_stfu(inmsg))
+		master_badmsg(WIRE_CHANNELD_STFU, inmsg);
+
+	if (peer->splicing) {
+		msg = towire_channeld_splice_state_error(NULL, "Can't start"
+							 " stfu when a splice"
+							 " is active");
+		wire_sync_write(MASTER_FD, take(msg));
+		return;
+	}
+	if (peer->want_stfu) {
+		msg = towire_channeld_splice_state_error(NULL, "Can't stfu"
+							 " splice while waiting"
+							 " for STFU.");
+		wire_sync_write(MASTER_FD, take(msg));
+		return;
+	}
+	if (is_stfu_active(peer)) {
+		msg = towire_channeld_splice_state_error(NULL, "Can't stfu"
+							 " splice while"
+							 " currently in STFU");
+		wire_sync_write(MASTER_FD, take(msg));
+		return;
+	}
+
+	peer->on_stfu_success = handle_stfu_req_success;
 
-	/* First things first we must STFU the channel */
 	peer->stfu_initiator = LOCAL;
 	peer->want_stfu = true;
 	maybe_send_stfu(peer);
 }
 
+static void handle_abort_req(struct peer *peer, const u8 *inmsg)
+{
+	if (!fromwire_channeld_abort(inmsg))
+		master_badmsg(WIRE_CHANNELD_ABORT, inmsg);
+
+	peer_write(peer->pps,
+		   take(towire_tx_abort(NULL,
+		   			&peer->channel_id,
+		   			NULL)));
+}
+
 static void peer_in(struct peer *peer, const u8 *msg)
 {
 	enum peer_wire type = fromwire_peektype(msg);
@@ -4561,6 +4633,9 @@ static void peer_in(struct peer *peer, const u8 *msg)
 	case WIRE_SPLICE_LOCKED:
 		handle_peer_splice_locked(peer, msg);
 		return;
+	case WIRE_TX_ABORT:
+		check_tx_abort(peer, msg);
+		return;
 	case WIRE_INIT:
 	case WIRE_OPEN_CHANNEL:
 	case WIRE_ACCEPT_CHANNEL:
@@ -4572,7 +4647,6 @@ static void peer_in(struct peer *peer, const u8 *msg)
 	case WIRE_TX_ADD_OUTPUT:
 	case WIRE_TX_REMOVE_OUTPUT:
 	case WIRE_TX_COMPLETE:
-	case WIRE_TX_ABORT:
 	case WIRE_OPEN_CHANNEL2:
 	case WIRE_ACCEPT_CHANNEL2:
 	case WIRE_TX_SIGNATURES:
@@ -6048,6 +6122,12 @@ static void req_in(struct peer *peer, const u8 *msg)
 	case WIRE_CHANNELD_SPLICE_SIGNED:
 		splice_initiator_user_signed(peer, msg);
 		return;
+	case WIRE_CHANNELD_STFU:
+		handle_stfu_req(peer, msg);
+		return;
+	case WIRE_CHANNELD_ABORT:
+		handle_abort_req(peer, msg);
+		return;
 	case WIRE_CHANNELD_SPLICE_CONFIRMED_INIT:
 	case WIRE_CHANNELD_SPLICE_CONFIRMED_SIGNED:
 	case WIRE_CHANNELD_SPLICE_SENDING_SIGS:
@@ -6056,6 +6136,7 @@ static void req_in(struct peer *peer, const u8 *msg)
 	case WIRE_CHANNELD_SPLICE_LOOKUP_TX_RESULT:
 	case WIRE_CHANNELD_SPLICE_FEERATE_ERROR:
 	case WIRE_CHANNELD_SPLICE_FUNDING_ERROR:
+	case WIRE_CHANNELD_CONFIRMED_STFU:
 		break;
  	case WIRE_CHANNELD_DEV_REENABLE_COMMIT:
 		if (peer->developer) {

channeld/channeld_wire.csv

@@ -211,6 +211,7 @@ msgdata,channeld_splice_init,psbt,wally_psbt,
 msgdata,channeld_splice_init,relative_amount,s64,
 msgdata,channeld_splice_init,feerate_per_kw,u32,
 msgdata,channeld_splice_init,force_feerate,bool,
+msgdata,channeld_splice_init,skip_stfu,bool,
 
 # channeld->master: hello, I started a channel splice open
 msgtype,channeld_splice_confirmed_init,7205
@@ -224,6 +225,7 @@ msgdata,channeld_splice_update,psbt,wally_psbt,
 msgtype,channeld_splice_confirmed_update,7207
 msgdata,channeld_splice_confirmed_update,psbt,wally_psbt,
 msgdata,channeld_splice_confirmed_update,commitments_secured,bool,
+msgdata,channeld_splice_confirmed_update,signatures_secured,bool,
 
 # channeld->master: Lookup a transaction
 msgtype,channeld_splice_lookup_tx,7208
@@ -282,6 +284,16 @@ msgdata,channeld_splice_funding_error,opener_error,bool,
 msgtype,channeld_splice_state_error,7221
 msgdata,channeld_splice_state_error,state_error,wirestring,
 
+# master->channeld: Please enter stfu mode
+msgtype,channeld_stfu,7222
+
+# channeld->master: Entered stfu result
+msgtype,channeld_confirmed_stfu,7223
+msgdata,channeld_confirmed_stfu,available_funds,amount_msat,
+
+# master->channeld: Please enter perform tx_abort
+msgtype,channeld_abort,7224
+
 # Tell peer to shut down channel.
 msgtype,channeld_send_shutdown,1023
 msgdata,channeld_send_shutdown,final_index,?u32,