ln+util: add test option to enable negotiation of zero fee channels

To allow testing along the way in this PR, turn on negotiation of
zero fee channels.

Co-authored-by: Matt Corallo <[email protected]>

Author: carlaKC

lightning/src/ln/channel.rs

@@ -4860,7 +4860,16 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 		// counterparty is advertising the feature, but rejecting channels proposing the feature for
 		// whatever reason.
 		let channel_type = &mut funding.channel_transaction_parameters.channel_type_features;
-		if channel_type.supports_anchors_zero_fee_htlc_tx() {
+		if channel_type.supports_anchor_zero_fee_commitments() {
+			channel_type.clear_anchor_zero_fee_commitments();
+			channel_type.set_anchors_zero_fee_htlc_tx_required();
+			channel_type.set_static_remote_key_required();
+
+			self.feerate_per_kw = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::AnchorChannelFee);
+			assert!(!channel_type.supports_anchor_zero_fee_commitments());
+			assert!(channel_type.supports_anchors_zero_fee_htlc_tx());
+			assert!(channel_type.supports_static_remote_key());
+		} else if channel_type.supports_anchors_zero_fee_htlc_tx() {
 			channel_type.clear_anchors_zero_fee_htlc_tx();
 			self.feerate_per_kw = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::NonAnchorChannelFee);
 			assert!(!channel_type.supports_anchors_nonzero_fee_htlc_tx());
@@ -9906,8 +9915,9 @@ pub(super) fn channel_type_from_open_channel(
 
 		// We only support the channel types defined by the `ChannelManager` in
 		// `provided_channel_type_features`. The channel type must always support
-		// `static_remote_key`.
-		if !channel_type.requires_static_remote_key() {
+		// `static_remote_key`, except for `option_zero_fee_commitments` which
+		// assumes this feature.
+		if !channel_type.requires_static_remote_key() && !channel_type.requires_anchor_zero_fee_commitments(){
 			return Err(ChannelError::close("Channel Type was not understood - we require static remote key".to_owned()));
 		}
 		// Make sure we support all of the features behind the channel type.
@@ -10492,10 +10502,21 @@ fn get_initial_channel_type(config: &UserConfig, their_features: &InitFeatures)
 		ret.set_scid_privacy_required();
 	}
 
-	// Optionally, if the user would like to negotiate the `anchors_zero_fee_htlc_tx` option, we
-	// set it now. If they don't understand it, we'll fall back to our default of
-	// `only_static_remotekey`.
-	if config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx &&
+	// Optionally, if the user would like to negotiate `option_zero_fee_commitments` we set it now.
+	// If they don't understand it (or we don't want it), we check the same conditions for
+	// `option_anchors_zero_fee_htlc_tx`. The counterparty can still refuse the channel and we'll
+	// try to fall back (all the way to `only_static_remotekey`).
+	#[cfg(not(test))]
+	let negotiate_zero_fee_commitments = false;
+
+	#[cfg(test)]
+	let negotiate_zero_fee_commitments = config.channel_handshake_config.negotiate_anchor_zero_fee_commitments;
+
+	if negotiate_zero_fee_commitments && their_features.supports_anchor_zero_fee_commitments() {
+		ret.set_anchor_zero_fee_commitments_required();
+		// `option_static_remote_key` is assumed by `option_zero_fee_commitments`.
+		ret.clear_static_remote_key();
+	} else if config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx &&
 		their_features.supports_anchors_zero_fee_htlc_tx() {
 		ret.set_anchors_zero_fee_htlc_tx_required();
 	}

lightning/src/ln/channelmanager.rs

@@ -12931,6 +12931,14 @@ pub fn provided_init_features(config: &UserConfig) -> InitFeatures {
 	// quiescent-dependent protocols (e.g., splicing).
 	#[cfg(any(test, fuzzing))]
 	features.set_quiescence_optional();
+
+	#[cfg(test)]
+	{
+		if config.channel_handshake_config.negotiate_anchor_zero_fee_commitments {
+			features.set_anchor_zero_fee_commitments_optional();
+		}
+	}
+
 	features
 }
 
@@ -16165,6 +16173,18 @@ mod tests {
 		do_test_channel_type_downgrade(anchors_config, |features| features.supports_anchors_zero_fee_htlc_tx())
 	}
 
+	#[test]
+	fn test_zero_fee_commitments_downgrade() {
+		// Tests that the local node will retry without zero fee commitments in the case where the
+		// remote node supports the feature but does not accept it.
+		let mut zero_fee_config = test_default_channel_config();
+		zero_fee_config.channel_handshake_config.negotiate_anchor_zero_fee_commitments = true;
+		zero_fee_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
+		zero_fee_config.manually_accept_inbound_channels = true;
+
+		do_test_channel_type_downgrade(zero_fee_config, |features| features.supports_anchor_zero_fee_commitments())
+	}
+
 	fn do_test_channel_type_downgrade<F>(user_cfg: UserConfig, start_type_set: F)
 		where F: Fn(&ChannelTypeFeatures) -> bool {
 		let chanmon_cfgs = create_chanmon_cfgs(2);

lightning/src/util/config.rs

@@ -183,6 +183,43 @@ pub struct ChannelHandshakeConfig {
 	/// [`DecodeError::InvalidValue`]: crate::ln::msgs::DecodeError::InvalidValue
 	pub negotiate_anchors_zero_fee_htlc_tx: bool,
 
+	/// If set, we attempt to negotiate the `zero_fee_commitments` option for all future channels.
+	///
+	/// These channels operate very similarly to the `anchors_zero_fee_htlc` channels but rely on
+	/// [TRUC] to assign zero fee to the commitment transactions themselves, avoiding many protocol
+	/// edge-cases involving fee updates and greatly simplifying the concept of your "balance" in
+	/// lightning.
+	///
+	/// Like `anchors_zero_fee_htlc` channels, this feature requires having a reserve of onchain
+	/// funds readily available to bump transactions in the event of a channel force close to avoid
+	/// the possibility of losing funds.
+	///
+	/// Note that if you wish accept inbound channels with anchor outputs, you must enable
+	/// [`UserConfig::manually_accept_inbound_channels`] and manually accept them with
+	/// [`ChannelManager::accept_inbound_channel`]. This is done to give you the chance to check
+	/// whether your reserve of onchain funds is enough to cover the fees for all existing and new
+	/// channels featuring anchor outputs in the event of a force close.
+	///
+	/// If this option is set, channels may be created that will not be readable by LDK versions
+	/// prior to 0.2, causing [`ChannelManager`]'s read method to return a
+	/// [`DecodeError::InvalidValue`].
+	///
+	/// Note that setting this to true does *not* prevent us from opening channels with
+	/// counterparties that do not support the `zero_fee_commitments` option; we will simply fall
+	/// back to a `anchors_zero_fee_htlc` (if [`Self::negotiate_anchors_zero_fee_htlc_tx`]
+	/// is set) or `static_remote_key` channel.
+	///
+	/// *Implies [`Self::negotiate_anchors_zero_fee_htlc_tx`].*
+	///
+	/// Default value: `false` (This value is likely to change to `true` in the future.)
+	///
+	/// [TRUC]: (https://bitcoinops.org/en/topics/version-3-transaction-relay/)
+	/// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+	/// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
+	/// [`DecodeError::InvalidValue`]: crate::ln::msgs::DecodeError::InvalidValue
+	#[cfg(test)]
+	pub negotiate_anchor_zero_fee_commitments: bool,
+
 	/// The maximum number of HTLCs in-flight from our counterparty towards us at the same time.
 	///
 	/// Increasing the value can help improve liquidity and stability in
@@ -212,6 +249,8 @@ impl Default for ChannelHandshakeConfig {
 			commit_upfront_shutdown_pubkey: true,
 			their_channel_reserve_proportional_millionths: 10_000,
 			negotiate_anchors_zero_fee_htlc_tx: false,
+			#[cfg(test)]
+			negotiate_anchor_zero_fee_commitments: false,
 			our_max_accepted_htlcs: 50,
 		}
 	}
@@ -233,6 +272,8 @@ impl Readable for ChannelHandshakeConfig {
 			commit_upfront_shutdown_pubkey: Readable::read(reader)?,
 			their_channel_reserve_proportional_millionths: Readable::read(reader)?,
 			negotiate_anchors_zero_fee_htlc_tx: Readable::read(reader)?,
+			#[cfg(test)]
+			negotiate_anchor_zero_fee_commitments: Readable::read(reader)?,
 			our_max_accepted_htlcs: Readable::read(reader)?,
 		})
 	}