Support negotiating anchors throughout channel open

Author: wpaulino

lightning/src/ln/channel.rs

@@ -880,6 +880,9 @@ impl<Signer: Sign> Channel<Signer> {
 		if !config.channel_handshake_config.announced_channel && config.channel_handshake_config.negotiate_scid_privacy {
 			ret.set_scid_privacy_required();
 		}
+		if config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx {
+			ret.set_anchors_zero_fee_htlc_tx_required();
+		}
 		ret
 	}
 
@@ -905,7 +908,8 @@ impl<Signer: Sign> Channel<Signer> {
 	where K::Target: KeysInterface<Signer = Signer>,
 	      F::Target: FeeEstimator,
 	{
-		let opt_anchors = false; // TODO - should be based on features
+		let opt_anchors = config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx &&
+			their_features.supports_anchors_zero_fee_htlc_tx();
 
 		let holder_selected_contest_delay = config.channel_handshake_config.our_to_self_delay;
 		let holder_signer = keys_provider.get_channel_signer(false, channel_value_satoshis);
@@ -1104,7 +1108,6 @@ impl<Signer: Sign> Channel<Signer> {
 		      F::Target: FeeEstimator,
 		      L::Target: Logger,
 	{
-		let opt_anchors = false; // TODO - should be based on features
 		let announced_channel = if (msg.channel_flags & 1) == 1 { true } else { false };
 
 		// First check the channel type is known, failing before we do anything else if we don't
@@ -1118,13 +1121,24 @@ impl<Signer: Sign> Channel<Signer> {
 				return Err(ChannelError::Close("Channel Type field contains unknown bits".to_owned()));
 			}
 
-			// We currently only allow four channel types, so write it all out here - we allow
-			// `only_static_remote_key` or `static_remote_key | zero_conf` in all contexts, and
-			// further allow `static_remote_key | scid_privacy` or
-			// `static_remote_key | scid_privacy | zero_conf`, if the channel is not
-			// publicly announced.
+			// We currently only allow 8 channel types, and all must support `static_remote_key`, so
+			// write it all out here - we allow
+			// - `only_static_remote_key`
+			// - `static_remote_key | zero_conf`
+			// - `static_remote_key | scid_privacy`
+			// - `static_remote_key | scid_privacy | zero_conf`
+			// - `static_remote_key | anchors_zero_fee_htlc_tx`
+			// - `static_remote_key | anchors_zero_fee_htlc_tx | zero_conf`
+			// - `static_remote_key | anchors_zero_fee_htlc_tx | scid_privacy`
+			// - `static_remote_key | anchors_zero_fee_htlc_tx | scid_privacy | zero_conf`
+			if !channel_type.requires_static_remote_key() {
+				return Err(ChannelError::Close("Channel Type was not understood - we require static remote key".to_owned()));
+			}
 			if *channel_type != ChannelTypeFeatures::only_static_remote_key() {
-				if !channel_type.requires_scid_privacy() && !channel_type.requires_zero_conf() {
+				// If we have more features than just `static_remote_key`, make sure we only allow
+				// those we support.
+				if !channel_type.requires_scid_privacy() && !channel_type.requires_zero_conf() &&
+					!channel_type.requires_anchors_zero_fee_htlc_tx() {
 					return Err(ChannelError::Close("Channel Type was not understood".to_owned()));
 				}
 
@@ -1136,9 +1150,7 @@ impl<Signer: Sign> Channel<Signer> {
 		} else {
 			ChannelTypeFeatures::from_counterparty_init(&their_features)
 		};
-		if !channel_type.supports_static_remote_key() {
-			return Err(ChannelError::Close("Channel Type was not understood - we require static remote key".to_owned()));
-		}
+		let opt_anchors = channel_type.supports_anchors_zero_fee_htlc_tx();
 
 		let holder_signer = keys_provider.get_channel_signer(true, msg.funding_satoshis);
 		let pubkeys = holder_signer.pubkeys().clone();
@@ -2081,7 +2093,12 @@ impl<Signer: Sign> Channel<Signer> {
 		} else if their_features.supports_channel_type() {
 			// Assume they've accepted the channel type as they said they understand it.
 		} else {
-			self.channel_type = ChannelTypeFeatures::from_counterparty_init(&their_features)
+			self.channel_type = ChannelTypeFeatures::from_counterparty_init(&their_features);
+			self.channel_transaction_parameters.opt_anchors = if self.channel_type.supports_anchors_zero_fee_htlc_tx() {
+					Some(())
+			} else {
+					None
+			};
 		}
 
 		let counterparty_shutdown_scriptpubkey = if their_features.supports_upfront_shutdown_script() {
@@ -6554,11 +6571,6 @@ impl<'a, Signer: Sign, K: Deref> ReadableArgs<(&'a K, u32)> for Channel<Signer>
 			return Err(DecodeError::UnknownRequiredFeature);
 		}
 
-		if channel_parameters.opt_anchors.is_some() {
-			// Relax this check when ChannelTypeFeatures supports anchors.
-			return Err(DecodeError::InvalidValue);
-		}
-
 		let mut secp_ctx = Secp256k1::new();
 		secp_ctx.seeded_randomize(&keys_source.get_secure_random_bytes());
 

lightning/src/ln/features.rs

@@ -763,6 +763,7 @@ mod tests {
 		init_features.set_channel_type_optional();
 		init_features.set_scid_privacy_optional();
 		init_features.set_zero_conf_optional();
+		init_features.set_anchors_zero_fee_htlc_tx_optional();
 
 		assert!(init_features.initial_routing_sync());
 		assert!(!init_features.supports_upfront_shutdown_script());

lightning/src/util/config.rs

@@ -126,7 +126,6 @@ pub struct ChannelHandshakeConfig {
 	///
 	/// [`KeysInterface::get_shutdown_scriptpubkey`]: crate::chain::keysinterface::KeysInterface::get_shutdown_scriptpubkey
 	pub commit_upfront_shutdown_pubkey: bool,
-
 	/// The Proportion of the channel value to configure as counterparty's channel reserve,
 	/// i.e., `their_channel_reserve_satoshis` for both outbound and inbound channels.
 	///
@@ -149,7 +148,22 @@ pub struct ChannelHandshakeConfig {
 	///                as 1000 sats instead, which is a safe implementation-specific lower bound.
 	/// Maximum value: 1,000,000, any values larger than 1 Million will be treated as 1 Million (or 100%)
 	///                instead, although channel negotiations will fail in that case.
-	pub their_channel_reserve_proportional_millionths: u32
+	pub their_channel_reserve_proportional_millionths: u32,
+	/// If set, we attempt to negotiate the `anchors_zero_fee_htlc_tx`option for outbound channels.
+	///
+	/// If this option is set, channels may be created that will not be readable by LDK versions
+	/// prior to 0.0.110, 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 `anchors_zero_fee_htlc_tx` option; we will simply
+	/// fall back to a `static_remote_key` channel.
+	///
+	/// Default value: false. This value is likely to change to true in the future.
+	///
+	/// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+	/// [`DecodeError::InvalidValue`]: crate::ln::msgs::DecodeError::InvalidValue
+	pub negotiate_anchors_zero_fee_htlc_tx: bool,
 }
 
 impl Default for ChannelHandshakeConfig {
@@ -163,6 +177,7 @@ impl Default for ChannelHandshakeConfig {
 			announced_channel: false,
 			commit_upfront_shutdown_pubkey: true,
 			their_channel_reserve_proportional_millionths: 10_000,
+			negotiate_anchors_zero_fee_htlc_tx: false,
 		}
 	}
 }