Move announced_channel to ChannelHandshakeConfig

In the near future, we plan to allow users to update their
`ChannelConfig` after the initial channel handshake. In order to reuse
the same struct and expose it to users, we opt to move out all static
fields that cannot be updated after the initial channel handshake.

`announced_channel` is one of these fields. We now store it within the
`Channel` struct, making sure we're backwards compatible to allow users
to downgrade if necessary.

Author: wpaulino

lightning-invoice/src/utils.rs

@@ -659,7 +659,7 @@ mod test {
 		// `msgs::ChannelUpdate` is never handled for the node(s). As the `msgs::ChannelUpdate`
 		// is never handled, the `channel.counterparty.forwarding_info` is never assigned.
 		let mut private_chan_cfg = UserConfig::default();
-		private_chan_cfg.channel_options.announced_channel = false;
+		private_chan_cfg.own_channel_config.announced_channel = false;
 		let temporary_channel_id = nodes[2].node.create_channel(nodes[0].node.get_our_node_id(), 1_000_000, 500_000_000, 42, Some(private_chan_cfg)).unwrap();
 		let open_channel = get_event_msg!(nodes[2], MessageSendEvent::SendOpenChannel, nodes[0].node.get_our_node_id());
 		nodes[0].node.handle_open_channel(&nodes[2].node.get_our_node_id(), InitFeatures::known(), &open_channel);
@@ -1046,7 +1046,7 @@ mod test {
 		// `msgs::ChannelUpdate` is never handled for the node(s). As the `msgs::ChannelUpdate`
 		// is never handled, the `channel.counterparty.forwarding_info` is never assigned.
 		let mut private_chan_cfg = UserConfig::default();
-		private_chan_cfg.channel_options.announced_channel = false;
+		private_chan_cfg.own_channel_config.announced_channel = false;
 		let temporary_channel_id = nodes[1].node.create_channel(nodes[3].node.get_our_node_id(), 1_000_000, 500_000_000, 42, Some(private_chan_cfg)).unwrap();
 		let open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[3].node.get_our_node_id());
 		nodes[3].node.handle_open_channel(&nodes[1].node.get_our_node_id(), InitFeatures::known(), &open_channel);

lightning/src/ln/channel.rs

@@ -495,6 +495,7 @@ pub(super) struct Channel<Signer: Sign> {
 	#[cfg(not(any(test, feature = "_test_utils")))]
 	config: ChannelConfig,
 
+	announced: bool,
 	inbound_handshake_limits_override: Option<ChannelHandshakeLimits>,
 
 	user_id: u64,
@@ -855,7 +856,7 @@ impl<Signer: Sign> Channel<Signer> {
 		// available. If it's private, we first try `scid_privacy` as it provides better privacy
 		// with no other changes, and fall back to `only_static_remotekey`
 		let mut ret = ChannelTypeFeatures::only_static_remote_key();
-		if !config.channel_options.announced_channel && config.own_channel_config.negotiate_scid_privacy {
+		if !config.own_channel_config.announced_channel && config.own_channel_config.negotiate_scid_privacy {
 			ret.set_scid_privacy_required();
 		}
 		ret
@@ -928,9 +929,17 @@ impl<Signer: Sign> Channel<Signer> {
 			}
 		}
 
+		// Also update `ChannelConfig::announced_channel` to make sure we still allow users to
+		// downgrade versions after the fact.
+		//
+		// TODO: This can be removed once we prevent downgrades to v0.0.107.
+		let mut channel_options = config.channel_options.clone();
+		channel_options.announced_channel = config.own_channel_config.announced_channel;
+
 		Ok(Channel {
 			user_id,
-			config: config.channel_options.clone(),
+			config: channel_options,
+			announced: config.own_channel_config.announced_channel,
 			inbound_handshake_limits_override: Some(config.peer_channel_config_limits.clone()),
 
 			channel_id: keys_provider.get_secure_random_bytes(),
@@ -1117,7 +1126,6 @@ impl<Signer: Sign> Channel<Signer> {
 			delayed_payment_basepoint: msg.delayed_payment_basepoint,
 			htlc_basepoint: msg.htlc_basepoint
 		};
-		let mut local_config = (*config).channel_options.clone();
 
 		if config.own_channel_config.our_to_self_delay < BREAKDOWN_TIMEOUT {
 			return Err(ChannelError::Close(format!("Configured with an unreasonable our_to_self_delay ({}) putting user funds at risks. It must be greater than {}", config.own_channel_config.our_to_self_delay, BREAKDOWN_TIMEOUT)));
@@ -1181,13 +1189,18 @@ impl<Signer: Sign> Channel<Signer> {
 
 		// Convert things into internal flags and prep our state:
 
+		// We either accept their preference or the preferences match.
 		if config.peer_channel_config_limits.force_announced_channel_preference {
-			if local_config.announced_channel != announced_channel {
+			if config.own_channel_config.announced_channel != announced_channel {
 				return Err(ChannelError::Close("Peer tried to open channel but their announcement preference is different from ours".to_owned()));
 			}
 		}
-		// we either accept their preference or the preferences match
-		local_config.announced_channel = announced_channel;
+		// Also update `ChannelConfig::announced_channel` to make sure we still allow users to
+		// downgrade versions after the fact.
+		//
+		// TODO: This can be removed once we prevent downgrades to v0.0.107.
+		let mut channel_options = config.channel_options.clone();
+		channel_options.announced_channel = announced_channel;
 
 		let holder_selected_channel_reserve_satoshis = Channel::<Signer>::get_holder_selected_channel_reserve_satoshis(msg.funding_satoshis);
 		if holder_selected_channel_reserve_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
@@ -1254,7 +1267,8 @@ impl<Signer: Sign> Channel<Signer> {
 
 		let chan = Channel {
 			user_id,
-			config: local_config,
+			config: channel_options,
+			announced: announced_channel,
 			inbound_handshake_limits_override: None,
 
 			channel_id: msg.temporary_channel_id,
@@ -4556,7 +4570,7 @@ impl<Signer: Sign> Channel<Signer> {
 	}
 
 	pub fn should_announce(&self) -> bool {
-		self.config.announced_channel
+		self.announced
 	}
 
 	pub fn is_outbound(&self) -> bool {
@@ -4896,7 +4910,7 @@ impl<Signer: Sign> Channel<Signer> {
 			delayed_payment_basepoint: keys.delayed_payment_basepoint,
 			htlc_basepoint: keys.htlc_basepoint,
 			first_per_commitment_point,
-			channel_flags: if self.config.announced_channel {1} else {0},
+			channel_flags: if self.announced {1} else {0},
 			shutdown_scriptpubkey: OptionalField::Present(match &self.shutdown_scriptpubkey {
 				Some(script) => script.clone().into_inner(),
 				None => Builder::new().into_script(),
@@ -5046,7 +5060,7 @@ impl<Signer: Sign> Channel<Signer> {
 	///
 	/// This will only return ChannelError::Ignore upon failure.
 	fn get_channel_announcement(&self, node_id: PublicKey, chain_hash: BlockHash) -> Result<msgs::UnsignedChannelAnnouncement, ChannelError> {
-		if !self.config.announced_channel {
+		if !self.announced {
 			return Err(ChannelError::Ignore("Channel is not available for public announcements".to_owned()));
 		}
 		if !self.is_usable() {
@@ -6007,6 +6021,7 @@ impl<Signer: Sign> Writeable for Channel<Signer> {
 			(17, self.announcement_sigs_state, required),
 			(19, self.latest_inbound_scid_alias, option),
 			(21, self.outbound_scid_alias, required),
+			(23, self.announced, required),
 		});
 
 		Ok(())
@@ -6264,6 +6279,7 @@ impl<'a, Signer: Sign, K: Deref> ReadableArgs<(&'a K, u32)> for Channel<Signer>
 		let mut announcement_sigs_state = Some(AnnouncementSigsState::NotSent);
 		let mut latest_inbound_scid_alias = None;
 		let mut outbound_scid_alias = None;
+		let mut announced = None;
 
 		read_tlv_fields!(reader, {
 			(0, announcement_sigs, option),
@@ -6281,6 +6297,7 @@ impl<'a, Signer: Sign, K: Deref> ReadableArgs<(&'a K, u32)> for Channel<Signer>
 			(17, announcement_sigs_state, option),
 			(19, latest_inbound_scid_alias, option),
 			(21, outbound_scid_alias, option),
+			(23, announced, option),
 		});
 
 		if let Some(preimages) = preimages_opt {
@@ -6321,6 +6338,7 @@ impl<'a, Signer: Sign, K: Deref> ReadableArgs<(&'a K, u32)> for Channel<Signer>
 			user_id,
 
 			config: config.unwrap(),
+			announced: announced.unwrap_or(config.unwrap().announced_channel),
 
 			// Note that we don't care about serializing handshake limits as we only ever serialize
 			// channel data after the handshake has completed.
@@ -6918,7 +6936,7 @@ mod tests {
 
 		let counterparty_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
 		let mut config = UserConfig::default();
-		config.channel_options.announced_channel = false;
+		config.own_channel_config.announced_channel = false;
 		let mut chan = Channel::<InMemorySigner>::new_outbound(&&feeest, &&keys_provider, counterparty_node_id, &InitFeatures::known(), 10_000_000, 100000, 42, &config, 0, 42).unwrap(); // Nothing uses their network key in this test
 		chan.holder_dust_limit_satoshis = 546;
 		chan.counterparty_selected_channel_reserve_satoshis = Some(0); // Filled in in accept_channel

lightning/src/ln/functional_test_utils.rs

@@ -772,7 +772,7 @@ pub fn create_announced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(nodes: &'a
 
 pub fn create_unannounced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(nodes: &'a Vec<Node<'b, 'c, 'd>>, a: usize, b: usize, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> (msgs::ChannelReady, Transaction) {
 	let mut no_announce_cfg = test_default_channel_config();
-	no_announce_cfg.channel_options.announced_channel = false;
+	no_announce_cfg.own_channel_config.announced_channel = false;
 	nodes[a].node.create_channel(nodes[b].node.get_our_node_id(), channel_value, push_msat, 42, Some(no_announce_cfg)).unwrap();
 	let open_channel = get_event_msg!(nodes[a], MessageSendEvent::SendOpenChannel, nodes[b].node.get_our_node_id());
 	nodes[b].node.handle_open_channel(&nodes[a].node.get_our_node_id(), a_flags, &open_channel);
@@ -1956,7 +1956,7 @@ pub fn test_default_channel_config() -> UserConfig {
 	// Set cltv_expiry_delta slightly lower to keep the final CLTV values inside one byte in our
 	// tests so that our script-length checks don't fail (see ACCEPTED_HTLC_SCRIPT_WEIGHT).
 	default_config.channel_options.cltv_expiry_delta = MIN_CLTV_EXPIRY_DELTA;
-	default_config.channel_options.announced_channel = true;
+	default_config.own_channel_config.announced_channel = true;
 	default_config.peer_channel_config_limits.force_announced_channel_preference = false;
 	// When most of our tests were written, the default HTLC minimum was fixed at 1000.
 	// It now defaults to 1, so we simply set it to the expected value here.

lightning/src/ln/functional_tests.rs

@@ -2362,11 +2362,11 @@ fn channel_monitor_network_test() {
 fn test_justice_tx() {
 	// Test justice txn built on revoked HTLC-Success tx, against both sides
 	let mut alice_config = UserConfig::default();
-	alice_config.channel_options.announced_channel = true;
+	alice_config.own_channel_config.announced_channel = true;
 	alice_config.peer_channel_config_limits.force_announced_channel_preference = false;
 	alice_config.own_channel_config.our_to_self_delay = 6 * 24 * 5;
 	let mut bob_config = UserConfig::default();
-	bob_config.channel_options.announced_channel = true;
+	bob_config.own_channel_config.announced_channel = true;
 	bob_config.peer_channel_config_limits.force_announced_channel_preference = false;
 	bob_config.own_channel_config.our_to_self_delay = 6 * 24 * 3;
 	let user_cfgs = [Some(alice_config), Some(bob_config)];
@@ -8282,16 +8282,16 @@ fn test_channel_update_has_correct_htlc_maximum_msat() {
 	// 2. MUST be set to less than or equal to the `max_htlc_value_in_flight_msat` received from the peer.
 
 	let mut config_30_percent = UserConfig::default();
-	config_30_percent.channel_options.announced_channel = true;
+	config_30_percent.own_channel_config.announced_channel = true;
 	config_30_percent.own_channel_config.max_inbound_htlc_value_in_flight_percent_of_channel = 30;
 	let mut config_50_percent = UserConfig::default();
-	config_50_percent.channel_options.announced_channel = true;
+	config_50_percent.own_channel_config.announced_channel = true;
 	config_50_percent.own_channel_config.max_inbound_htlc_value_in_flight_percent_of_channel = 50;
 	let mut config_95_percent = UserConfig::default();
-	config_95_percent.channel_options.announced_channel = true;
+	config_95_percent.own_channel_config.announced_channel = true;
 	config_95_percent.own_channel_config.max_inbound_htlc_value_in_flight_percent_of_channel = 95;
 	let mut config_100_percent = UserConfig::default();
-	config_100_percent.channel_options.announced_channel = true;
+	config_100_percent.own_channel_config.announced_channel = true;
 	config_100_percent.own_channel_config.max_inbound_htlc_value_in_flight_percent_of_channel = 100;
 
 	let chanmon_cfgs = create_chanmon_cfgs(4);

lightning/src/ln/onion_route_tests.rs

@@ -308,7 +308,7 @@ fn test_onion_failure() {
 	// Channel::get_counterparty_htlc_minimum_msat().
 	let mut node_2_cfg: UserConfig = Default::default();
 	node_2_cfg.own_channel_config.our_htlc_minimum_msat = 2000;
-	node_2_cfg.channel_options.announced_channel = true;
+	node_2_cfg.own_channel_config.announced_channel = true;
 	node_2_cfg.peer_channel_config_limits.force_announced_channel_preference = false;
 
 	// When this test was written, the default base fee floated based on the HTLC count.
@@ -600,7 +600,7 @@ fn test_default_to_onion_payload_tlv_format() {
 	// `features` for a node in the `network_graph` exists, or when the node isn't in the
 	// `network_graph`, and no other known `features` for the node exists.
 	let mut priv_channels_conf = UserConfig::default();
-	priv_channels_conf.channel_options.announced_channel = false;
+	priv_channels_conf.own_channel_config.announced_channel = false;
 	let chanmon_cfgs = create_chanmon_cfgs(5);
 	let node_cfgs = create_node_cfgs(5, &chanmon_cfgs);
 	let node_chanmgrs = create_node_chanmgrs(5, &node_cfgs, &[None, None, None, None, Some(priv_channels_conf)]);
@@ -1085,7 +1085,7 @@ fn test_phantom_dust_exposure_failure() {
 	let max_dust_exposure = 546;
 	let mut receiver_config = UserConfig::default();
 	receiver_config.channel_options.max_dust_htlc_exposure_msat = max_dust_exposure;
-	receiver_config.channel_options.announced_channel = true;
+	receiver_config.own_channel_config.announced_channel = true;
 
 	let chanmon_cfgs = create_chanmon_cfgs(2);
 	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);

lightning/src/ln/priv_short_conf_tests.rs

@@ -171,11 +171,11 @@ fn do_test_1_conf_open(connect_style: ConnectStyle) {
 	// tests that we properly send one in that case.
 	let mut alice_config = UserConfig::default();
 	alice_config.own_channel_config.minimum_depth = 1;
-	alice_config.channel_options.announced_channel = true;
+	alice_config.own_channel_config.announced_channel = true;
 	alice_config.peer_channel_config_limits.force_announced_channel_preference = false;
 	let mut bob_config = UserConfig::default();
 	bob_config.own_channel_config.minimum_depth = 1;
-	bob_config.channel_options.announced_channel = true;
+	bob_config.own_channel_config.announced_channel = true;
 	bob_config.peer_channel_config_limits.force_announced_channel_preference = false;
 	let chanmon_cfgs = create_chanmon_cfgs(2);
 	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
@@ -308,7 +308,7 @@ fn test_scid_privacy_on_pub_channel() {
 	let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 
 	let mut scid_privacy_cfg = test_default_channel_config();
-	scid_privacy_cfg.channel_options.announced_channel = true;
+	scid_privacy_cfg.own_channel_config.announced_channel = true;
 	scid_privacy_cfg.own_channel_config.negotiate_scid_privacy = true;
 	nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, Some(scid_privacy_cfg)).unwrap();
 	let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
@@ -332,7 +332,7 @@ fn test_scid_privacy_negotiation() {
 	let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 
 	let mut scid_privacy_cfg = test_default_channel_config();
-	scid_privacy_cfg.channel_options.announced_channel = false;
+	scid_privacy_cfg.own_channel_config.announced_channel = false;
 	scid_privacy_cfg.own_channel_config.negotiate_scid_privacy = true;
 	nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, Some(scid_privacy_cfg)).unwrap();
 
@@ -378,7 +378,7 @@ fn test_inbound_scid_privacy() {
 	create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, InitFeatures::known(), InitFeatures::known());
 
 	let mut no_announce_cfg = test_default_channel_config();
-	no_announce_cfg.channel_options.announced_channel = false;
+	no_announce_cfg.own_channel_config.announced_channel = false;
 	no_announce_cfg.own_channel_config.negotiate_scid_privacy = true;
 	nodes[1].node.create_channel(nodes[2].node.get_our_node_id(), 100_000, 10_000, 42, Some(no_announce_cfg)).unwrap();
 	let mut open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[2].node.get_our_node_id());
@@ -665,7 +665,7 @@ fn test_0conf_channel_with_async_monitor() {
 
 	create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0, InitFeatures::known(), InitFeatures::known());
 
-	chan_config.channel_options.announced_channel = false;
+	chan_config.own_channel_config.announced_channel = false;
 	nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, Some(chan_config)).unwrap();
 	let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
 
@@ -811,7 +811,7 @@ fn test_0conf_close_no_early_chan_update() {
 	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 
 	// This is the default but we force it on anyway
-	chan_config.channel_options.announced_channel = true;
+	chan_config.own_channel_config.announced_channel = true;
 	open_zero_conf_channel(&nodes[0], &nodes[1], Some(chan_config));
 
 	// We can use the channel immediately, but won't generate a channel_update until we get confs
@@ -835,7 +835,7 @@ fn test_public_0conf_channel() {
 	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 
 	// This is the default but we force it on anyway
-	chan_config.channel_options.announced_channel = true;
+	chan_config.own_channel_config.announced_channel = true;
 	let tx = open_zero_conf_channel(&nodes[0], &nodes[1], Some(chan_config));
 
 	// We can use the channel immediately, but we can't announce it until we get 6+ confirmations
@@ -888,7 +888,7 @@ fn test_0conf_channel_reorg() {
 	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 
 	// This is the default but we force it on anyway
-	chan_config.channel_options.announced_channel = true;
+	chan_config.own_channel_config.announced_channel = true;
 	let tx = open_zero_conf_channel(&nodes[0], &nodes[1], Some(chan_config));
 
 	// We can use the channel immediately, but we can't announce it until we get 6+ confirmations

lightning/src/ln/shutdown_tests.rs

@@ -409,7 +409,7 @@ fn test_upfront_shutdown_script() {
 	// enforce it at shutdown message
 
 	let mut config = UserConfig::default();
-	config.channel_options.announced_channel = true;
+	config.own_channel_config.announced_channel = true;
 	config.peer_channel_config_limits.force_announced_channel_preference = false;
 	config.channel_options.commit_upfront_shutdown_pubkey = false;
 	let user_cfgs = [None, Some(config), None];
@@ -574,7 +574,7 @@ fn test_invalid_upfront_shutdown_script() {
 #[test]
 fn test_segwit_v0_shutdown_script() {
 	let mut config = UserConfig::default();
-	config.channel_options.announced_channel = true;
+	config.own_channel_config.announced_channel = true;
 	config.peer_channel_config_limits.force_announced_channel_preference = false;
 	config.channel_options.commit_upfront_shutdown_pubkey = false;
 	let user_cfgs = [None, Some(config), None];
@@ -609,7 +609,7 @@ fn test_segwit_v0_shutdown_script() {
 #[test]
 fn test_anysegwit_shutdown_script() {
 	let mut config = UserConfig::default();
-	config.channel_options.announced_channel = true;
+	config.own_channel_config.announced_channel = true;
 	config.peer_channel_config_limits.force_announced_channel_preference = false;
 	config.channel_options.commit_upfront_shutdown_pubkey = false;
 	let user_cfgs = [None, Some(config), None];
@@ -644,7 +644,7 @@ fn test_anysegwit_shutdown_script() {
 #[test]
 fn test_unsupported_anysegwit_shutdown_script() {
 	let mut config = UserConfig::default();
-	config.channel_options.announced_channel = true;
+	config.own_channel_config.announced_channel = true;
 	config.peer_channel_config_limits.force_announced_channel_preference = false;
 	config.channel_options.commit_upfront_shutdown_pubkey = false;
 	let user_cfgs = [None, Some(config), None];
@@ -686,7 +686,7 @@ fn test_unsupported_anysegwit_shutdown_script() {
 #[test]
 fn test_invalid_shutdown_script() {
 	let mut config = UserConfig::default();
-	config.channel_options.announced_channel = true;
+	config.own_channel_config.announced_channel = true;
 	config.peer_channel_config_limits.force_announced_channel_preference = false;
 	config.channel_options.commit_upfront_shutdown_pubkey = false;
 	let user_cfgs = [None, Some(config), None];