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-types/src/features.rs

@@ -1024,6 +1024,15 @@ impl ChannelTypeFeatures {
 		<sealed::ChannelTypeContext as sealed::AnchorsZeroFeeHtlcTx>::set_required_bit(&mut ret);
 		ret
 	}
+
+	/// Constructs a ChannelTypeFeatures with zero fee commitment anchors support.
+	pub fn anchors_zero_fee_commitments() -> Self {
+		let mut ret = Self::empty();
+		<sealed::ChannelTypeContext as sealed::AnchorZeroFeeCommitments>::set_required_bit(
+			&mut ret,
+		);
+		ret
+	}
 }
 
 impl<T: sealed::Context> Features<T> {

lightning/src/ln/channel.rs

@@ -4903,15 +4903,27 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 		// it in our order of preference, allowing us to negotiate the "next best" based on the
 		// counterparty's remaining features per our ranking in `get_initial_channel_type`.
 		let mut eligible_features = their_features.clone();
-		if channel_type.supports_anchors_zero_fee_htlc_tx() {
+		if channel_type.supports_anchor_zero_fee_commitments() {
+			eligible_features.clear_anchor_zero_fee_commitments();
+		} else if channel_type.supports_anchors_zero_fee_htlc_tx() {
+			eligible_features.clear_anchor_zero_fee_commitments();
 			eligible_features.clear_anchors_zero_fee_htlc_tx();
 		} else if channel_type.supports_scid_privacy() {
 			eligible_features.clear_scid_privacy();
 			eligible_features.clear_anchors_zero_fee_htlc_tx();
+			eligible_features.clear_anchor_zero_fee_commitments();
 		}
 
 		let next_channel_type = get_initial_channel_type(user_config, &eligible_features);
 
+		// Note that we can't get `anchor_zero_fee_commitments` type here, which requires zero
+		// fees, because we downgrade from this channel type first. If there were a superior
+		// channel type that downgrades to `anchor_zero_fee_commitments`, we'd need to handle
+		// fee setting differently here. If we proceeded to open a `anchor_zero_fee_commitments`
+		// channel with non-zero fees, we could produce a non-standard commitment transaction that
+		// puts us at risk of losing funds. We would expect our peer to reject such a channel
+		// open, but we don't want to rely on their validation.
+		assert!(!next_channel_type.supports_anchor_zero_fee_commitments());
 		let conf_target = if next_channel_type.supports_anchors_zero_fee_htlc_tx() {
 			ConfirmationTarget::AnchorChannelFee
 		} else {
@@ -10097,8 +10109,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`, either implicitly with `option_zero_fee_commitments`
+		// or explicitly.
+		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.
@@ -10685,10 +10698,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

@@ -13005,6 +13005,12 @@ 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
 }
 
@@ -16371,29 +16377,71 @@ mod tests {
 
 	#[test]
 	fn test_scid_privacy_downgrade() {
-		// Tests downgrade from `anchors_zero_fee_htlc_tx` with `option_scid_alias` when the
+		// Tests downgrade from `anchors_zero_fee_commitments` with `option_scid_alias` when the
 		// remote node advertises the features but does not accept the channel, asserting that
 		// `option_scid_alias` is the last feature to be downgraded.
 		let mut initiator_cfg = test_default_channel_config();
+		initiator_cfg.channel_handshake_config.negotiate_anchor_zero_fee_commitments = true;
 		initiator_cfg.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
 		initiator_cfg.channel_handshake_config.negotiate_scid_privacy = true;
 		initiator_cfg.channel_handshake_config.announce_for_forwarding = false;
 
 		let mut receiver_cfg = test_default_channel_config();
+		receiver_cfg.channel_handshake_config.negotiate_anchor_zero_fee_commitments = true;
 		receiver_cfg.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
 		receiver_cfg.channel_handshake_config.negotiate_scid_privacy = true;
 		receiver_cfg.manually_accept_inbound_channels = true;
 
-		let mut start_type = ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();
+		let mut start_type = ChannelTypeFeatures::anchors_zero_fee_commitments();
 		start_type.set_scid_privacy_required();
+		let mut with_anchors = ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();
+		with_anchors.set_scid_privacy_required();
 		let mut with_scid_privacy = ChannelTypeFeatures::only_static_remote_key();
 		with_scid_privacy.set_scid_privacy_required();
 		let static_remote = ChannelTypeFeatures::only_static_remote_key();
-		let downgrade_types = vec![with_scid_privacy, static_remote];
+		let downgrade_types = vec![with_anchors, with_scid_privacy, static_remote];
+
+		do_test_channel_type_downgrade(initiator_cfg, receiver_cfg, start_type, downgrade_types);
+	}
+
+	#[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 initiator_cfg = test_default_channel_config();
+		initiator_cfg.channel_handshake_config.negotiate_anchor_zero_fee_commitments = true;
+		initiator_cfg.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
+
+		let mut receiver_cfg = test_default_channel_config();
+		receiver_cfg.channel_handshake_config.negotiate_anchor_zero_fee_commitments = true;
+		receiver_cfg.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
+		receiver_cfg.manually_accept_inbound_channels = true;
 
+		let start_type = ChannelTypeFeatures::anchors_zero_fee_commitments();
+		let downgrade_types = vec![
+			ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies(),
+			ChannelTypeFeatures::only_static_remote_key(),
+		];
 		do_test_channel_type_downgrade(initiator_cfg, receiver_cfg, start_type, downgrade_types);
 	}
 
+	#[test]
+	fn test_zero_fee_commitments_downgrade_to_static_remote() {
+		// Tests that the local node will retry with static remote key when zero fee commitments
+		// are supported (but not accepted), but not legacy anchors.
+		let mut initiator_cfg = test_default_channel_config();
+		initiator_cfg.channel_handshake_config.negotiate_anchor_zero_fee_commitments = true;
+		initiator_cfg.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
+
+		let mut receiver_cfg = test_default_channel_config();
+		receiver_cfg.channel_handshake_config.negotiate_anchor_zero_fee_commitments = true;
+		receiver_cfg.manually_accept_inbound_channels = true;
+
+		let start_type = ChannelTypeFeatures::anchors_zero_fee_commitments();
+		let end_type = ChannelTypeFeatures::only_static_remote_key();
+		do_test_channel_type_downgrade(initiator_cfg, receiver_cfg, start_type, vec![end_type]);
+	}
+
 	#[rustfmt::skip]
 	fn do_test_channel_type_downgrade(initiator_cfg: UserConfig, acceptor_cfg: UserConfig,
 		start_type: ChannelTypeFeatures, downgrade_types: Vec<ChannelTypeFeatures>) {

lightning/src/util/config.rs

@@ -183,6 +183,41 @@ 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.
+	///
+	/// 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 +247,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 +270,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)?,
 		})
 	}