lightningd: always tell openingd/dualopend what channel type we want.

Prior to it being compulsory, these daemons would need a default value.  Now it's
always required, it's clearer if it's always told.

There's no "default_channel_type" now everyone has to specify channel_type either,
so rename it to "desired_channel_type" and put it in lightningd specifically.

Note that the channel_type can have options added: either
option_scid_alias or option_zeroconf.

Signed-off-by: Rusty Russell <[email protected]>

Author: rustyrussell

common/channel_type.c

@@ -72,26 +72,6 @@ struct channel_type *channel_type_anchors_zero_fee_htlc(const tal_t *ctx)
 	return type;
 }
 
-struct channel_type *default_channel_type(const tal_t *ctx,
-					  const struct feature_set *our_features,
-					  const u8 *their_features)
-{
-	/* BOLT #2:
-	 * Both peers:
-	 *   - if `channel_type` was present in both `open_channel` and `accept_channel`:
-	 *     - This is the `channel_type` (they must be equal, required above)
-	 *   - otherwise:
-	 *     - if `option_anchors` was negotiated:
-	 *       - the `channel_type` is `option_anchors` and `option_static_remotekey` (bits 22 and 12)
-	 * - otherwise:
-	 *   - the `channel_type` is `option_static_remotekey` (bit 12)
-	 */
-	if (feature_negotiated(our_features, their_features,
-			       OPT_ANCHORS_ZERO_FEE_HTLC_TX))
-		return channel_type_anchors_zero_fee_htlc(ctx);
-	return channel_type_static_remotekey(ctx);
-}
-
 bool channel_type_has(const struct channel_type *type, int feature)
 {
 	return feature_offered(type->features, feature);

common/channel_type.h

@@ -21,11 +21,6 @@ struct channel_type *channel_type_dup(const tal_t *ctx,
 struct channel_type *channel_type_from(const tal_t *ctx,
 				       const u8 *features TAKES);
 
-/* Derive channel type from feature negotiation */
-struct channel_type *default_channel_type(const tal_t *ctx,
-					  const struct feature_set *our_features,
-					  const u8 *their_features);
-
 /* Does this type include this feature? */
 bool channel_type_has(const struct channel_type *type, int feature);
 

lightningd/channel.c

@@ -242,6 +242,16 @@ struct open_attempt *new_channel_open_attempt(struct channel *channel)
 	return oa;
 }
 
+struct channel_type *desired_channel_type(const tal_t *ctx,
+					  const struct feature_set *our_features,
+					  const u8 *their_features)
+{
+	if (feature_negotiated(our_features, their_features,
+			       OPT_ANCHORS_ZERO_FEE_HTLC_TX))
+		return channel_type_anchors_zero_fee_htlc(ctx);
+	return channel_type_static_remotekey(ctx);
+}
+
 struct channel *new_unsaved_channel(struct peer *peer,
 				    u32 feerate_base,
 				    u32 feerate_ppm)
@@ -305,7 +315,7 @@ struct channel *new_unsaved_channel(struct peer *peer,
 	channel->close_blockheight = NULL;
 	/* In case someone looks at channels before open negotiation,
 	 * initialize this with default */
-	channel->type = default_channel_type(channel,
+	channel->type = desired_channel_type(channel,
 					     ld->our_features,
 					     peer->their_features);
 

lightningd/channel.h

@@ -899,5 +899,9 @@ const u8 *channel_update_for_error(const tal_t *ctx,
 
 struct amount_msat htlc_max_possible_send(const struct channel *channel);
 
+/* Given features, what channel_type do we want? */
+struct channel_type *desired_channel_type(const tal_t *ctx,
+					  const struct feature_set *our_features,
+					  const u8 *their_features);
 
 #endif /* LIGHTNING_LIGHTNINGD_CHANNEL_H */

lightningd/dual_open_control.c

@@ -3249,8 +3249,11 @@ static struct command_result *json_openchannel_init(struct command *cmd,
 				    "by peer");
 	}
 
-	if (info->ctype &&
-	    !cmd->ld->dev_any_channel_type &&
+	if (!info->ctype)
+		info->ctype = desired_channel_type(info, cmd->ld->our_features,
+						   peer->their_features);
+
+	if (!cmd->ld->dev_any_channel_type &&
 	    !channel_type_accept(tmpctx,
 				 info->ctype->features,
 				 cmd->ld->our_features)) {

lightningd/opening_control.c

@@ -47,8 +47,7 @@ void json_add_uncommitted_channel(struct command *cmd,
 	json_object_start(response, NULL);
 	json_add_node_id(response, "peer_id", &peer->id);
 	json_add_bool(response, "peer_connected", peer->connected == PEER_CONNECTED);
-	if (uc->fc->channel_type)
-			json_add_channel_type(response, "channel_type", uc->fc->channel_type);
+	json_add_channel_type(response, "channel_type", uc->fc->channel_type);
 	json_add_string(response, "state", "OPENINGD");
 	json_add_string(response, "owner", "lightning_openingd");
 	json_add_string(response, "opener", "local");
@@ -1297,7 +1296,7 @@ static struct command_result *json_fundchannel_start(struct command *cmd,
 			}
 		}
 	} else {
-		fc->channel_type = NULL;
+		fc->channel_type = NULL; /* set later */
 	}
 
 	if (!mindepth)
@@ -1389,6 +1388,11 @@ static struct command_result *json_fundchannel_start(struct command *cmd,
 	if (command_check_only(cmd))
 		return command_check_done(cmd);
 
+	/* Now we know the peer, we can derive the channel type to ask for */
+	if (!fc->channel_type)
+		fc->channel_type = desired_channel_type(fc, cmd->ld->our_features,
+							peer->their_features);
+
 	fc->push = push_msat ? *push_msat : AMOUNT_MSAT(0);
 	fc->channel_flags = OUR_CHANNEL_FLAGS;
 	if (!*announce_channel) {
@@ -1426,7 +1430,7 @@ static struct command_result *json_fundchannel_start(struct command *cmd,
 			&tmp_channel_id,
 			fc->channel_flags,
 			reserve,
-			ctype);
+			fc->channel_type);
 
 	if (!topology_synced(cmd->ld->topology)) {
 		struct fundchannel_start_info *info

openingd/dualopend.c

@@ -2961,7 +2961,6 @@ static void opener_start(struct state *state, u8 *msg)
 	struct amount_sat *requested_lease;
 	size_t locktime;
 	u32 nonanchor_feerate, anchor_feerate;
-	struct channel_type *ctype;
 
 	if (!fromwire_dualopend_opener_init(state, msg,
 					    &tx_state->psbt,
@@ -2975,30 +2974,14 @@ static void opener_start(struct state *state, u8 *msg)
 					    &requested_lease,
 					    &tx_state->blockheight,
 					    &dry_run,
-					    &ctype,
+					    &state->channel_type,
 					    &expected_rates))
 		master_badmsg(WIRE_DUALOPEND_OPENER_INIT, msg);
 
 	state->our_role = TX_INITIATOR;
 	wally_psbt_get_locktime(tx_state->psbt, &locktime);
 	tx_state->tx_locktime = locktime;
 	open_tlv = tlv_opening_tlvs_new(tmpctx);
-
-	/* BOLT #2:
-	 *  - if it includes `channel_type`:
-	 *     - MUST set it to a defined type representing the type it wants.
-	 *     - MUST use the smallest bitmap possible to represent the channel
-	 *       type.
-	 *     - SHOULD NOT set it to a type containing a feature which was not
-	 *       negotiated.
-	 */
-	if (ctype) {
-		state->channel_type = ctype;
-	} else {
-		state->channel_type = default_channel_type(state,
-							   state->our_features,
-							   state->their_features);
-	}
 	open_tlv->channel_type = state->channel_type->features;
 
 	/* Given channel type, which feerate do we use? */

openingd/dualopend_wire.csv

@@ -211,7 +211,7 @@ msgdata,dualopend_opener_init,channel_flags,u8,
 msgdata,dualopend_opener_init,requested_sats,?amount_sat,
 msgdata,dualopend_opener_init,blockheight,u32,
 msgdata,dualopend_opener_init,dry_run,bool,
-msgdata,dualopend_opener_init,channel_type,?channel_type,
+msgdata,dualopend_opener_init,channel_type,channel_type,
 # must go last because embedded tu32
 msgdata,dualopend_opener_init,expected_rates,?lease_rates,
 

openingd/openingd.c

@@ -294,7 +294,7 @@ static bool intuit_scid_alias_type(struct state *state, u8 channel_flags)
  * stop when we get to the part where we need the funding txid */
 static u8 *funder_channel_start(struct state *state, u8 channel_flags,
 				u32 nonanchor_feerate, u32 anchor_feerate,
-				const struct channel_type *ctype)
+				const struct channel_type *ctype TAKES)
 {
 	u8 *msg;
 	u8 *funding_output_script;
@@ -323,28 +323,12 @@ static u8 *funder_channel_start(struct state *state, u8 channel_flags,
 						     state->our_features,
 						     state->their_features);
 
-	if (ctype) {
-		state->channel_type = channel_type_dup(state, ctype);
-	} else {
-		state->channel_type = default_channel_type(state,
-							   state->our_features,
-							   state->their_features);
-
-		/* Spec says we should use the option_scid_alias variation if we
-		 * want them to *only* use the scid_alias (which we do for unannounced
-		 * channels!).
-		 *
-		 * But:
-		 * 1. We didn't accept this in CLN prior to v23.05.
-		 * 2. LND won't accept that without OPT_ANCHORS_ZERO_FEE_HTLC_TX.
-		 * 3. LND <= 18 won't accept OPT_SCID_ALIAS unless it advertizes it,
-		 *    which it does not by default.
-		 */
-		if (channel_type_has(state->channel_type, OPT_ANCHORS_ZERO_FEE_HTLC_TX)
-		    && feature_offered(state->their_features, OPT_SCID_ALIAS)) {
-			if (!(channel_flags & CHANNEL_FLAGS_ANNOUNCE_CHANNEL))
-				channel_type_set_scid_alias(state->channel_type);
-		}
+	state->channel_type = channel_type_dup(state, ctype);
+	/* We set scid alias if we're not announcing */
+	if (feature_negotiated(state->our_features, state->their_features,
+			       OPT_SCID_ALIAS)
+	    && !(channel_flags & CHANNEL_FLAGS_ANNOUNCE_CHANNEL)) {
+		channel_type_set_scid_alias(state->channel_type);
 	}
 
 	/* Which feerate do we use?  (We can lowball fees if using anchors!) */
@@ -569,7 +553,7 @@ static u8 *funder_channel_start(struct state *state, u8 channel_flags,
 		    "We negotiated option_zeroconf, using our minimum_depth=%d",
 		    state->minimum_depth);
 		/* We set this now to show we're zeroconf */
-		if (their_mindepth == 0 && !ctype)
+		if (their_mindepth == 0)
 			channel_type_set_zeroconf(state->channel_type);
 	} else {
 		state->minimum_depth = their_mindepth;

openingd/openingd_wire.csv

@@ -88,7 +88,7 @@ msgdata,openingd_funder_start,anchor_feerate_per_kw,u32,
 msgdata,openingd_funder_start,temporary_channel_id,channel_id,
 msgdata,openingd_funder_start,channel_flags,u8,
 msgdata,openingd_funder_start,reserve,?amount_sat,
-msgdata,openingd_funder_start,channel_type,?channel_type,
+msgdata,openingd_funder_start,channel_type,channel_type,
 
 # openingd->master: send back output script for 2-of-2 funding output
 msgtype,openingd_funder_start_reply,6102