refactor require announce and local announce of channels

Author: SWvheerden

fuzz/fuzz_targets/channel_target.rs

@@ -195,7 +195,7 @@ pub fn do_test(data: &[u8]) {
 		let chan_value = slice_to_be24(get_slice!(3));
 		let push_msat = slice_to_be24(get_slice!(3));
 		let mut config = UserConfigurations::new();
-		config.channel_options.annouce_channel = (get_slice!(1)[0] == 0);
+		config.channel_options.announced_channel = (get_slice!(1)[0] == 0);
 		let mut chan = match Channel::new_outbound(&fee_est, chan_keys!(), their_pubkey, chan_value, push_msat, slice_to_be64(get_slice!(8)), Arc::clone(&logger), &config) {
 			Ok(chan) => chan,
 			Err(_) => return,
@@ -222,8 +222,8 @@ pub fn do_test(data: &[u8]) {
 			decode_msg!(msgs::OpenChannel, 2*32+6*8+4+2*2+6*33+1)
 		};
 		let mut chan_config = UserConfigurations::new();
-		chan_config.channel_options.allow_annouce_channel = false;
-		chan_config.channel_options.annouce_channel = get_slice!(1)[0] == 0;
+		chan_config.channel_options.force_announced_channel_preference = false;
+		chan_config.channel_options.announced_channel = get_slice!(1)[0] == 0;
 		let mut chan = match Channel::new_from_req(&fee_est, chan_keys!(), their_pubkey, &open_chan, slice_to_be64(get_slice!(8)), Arc::clone(&logger),&chan_config) {
 			Ok(chan) => chan,
 			Err(_) => return,

fuzz/fuzz_targets/full_stack_target.rs

@@ -238,7 +238,7 @@ pub fn do_test(data: &[u8], logger: &Arc<Logger>) {
 	let monitor = channelmonitor::SimpleManyChannelMonitor::new(watch.clone(), broadcast.clone());
 	let mut config = UserConfigurations::new();
 	config.channel_options.fee_proportional_millionths =  slice_to_be32(get_slice!(4));
-	config.channel_options.annouce_channel = (get_slice!(1)[0] != 0);
+	config.channel_options.announced_channel = (get_slice!(1)[0] != 0);
 	let channelmanager = ChannelManager::new(our_network_key,Network::Bitcoin, fee_est.clone(), monitor.clone(), watch.clone(), broadcast.clone(), Arc::clone(&logger), config).unwrap();
 	let router = Arc::new(Router::new(PublicKey::from_secret_key(&secp_ctx, &our_network_key), watch.clone(), Arc::clone(&logger)));
 

src/ln/channel.rs

@@ -506,6 +506,7 @@ impl Channel {
 				return Err(HandleError{err: $msg, action: Some(msgs::ErrorAction::SendErrorMessage{ msg: msgs::ErrorMessage { channel_id: msg.temporary_channel_id, data: $msg.to_string() }})});
 			}
 		}
+		let mut local_config = (*configurations).clone();
 
 		// Check sanity of message fields:
 		if msg.funding_satoshis >= MAX_FUNDING_SATOSHIS {
@@ -563,12 +564,16 @@ impl Channel {
 		// Convert things into internal flags and prep our state:
 
 		let their_announce = if (msg.channel_flags & 1) == 1 { true } else { false };
-		if configurations.channel_options.annouce_channel && !their_announce {
-			return_error_message!("Peer tried to open unannounced channel, but we require public ones");
-		}
-		if !configurations.channel_options.allow_annouce_channel && their_announce {
-			return_error_message!("Peer tried to open announced channel, but we require private ones");
+		if local_config.channel_options.force_announced_channel_preference{
+			if local_config.channel_options.announced_channel && !their_announce {
+				return_error_message!("Peer tried to open unannounced channel, but we require public ones");
+			}
+			if !local_config.channel_options.announced_channel && their_announce {
+				return_error_message!("Peer tried to open announced channel, but we require private ones");
+			}
 		}
+		//we either accept their preference or the preferences match
+		local_config.channel_options.announced_channel = their_announce;
 
 		let background_feerate = fee_estimator.get_est_sat_per_1000_weight(ConfirmationTarget::Background);
 
@@ -609,7 +614,7 @@ impl Channel {
 
 		let mut chan = Channel {
 			user_id: user_id,
-			config: (*configurations).clone(),
+			config: local_config,
 			channel_id: msg.temporary_channel_id,
 			channel_state: (ChannelState::OurInitSent as u32) | (ChannelState::TheirInitSent as u32),
 			channel_outbound: false,
@@ -2250,7 +2255,7 @@ impl Channel {
 	}
 
 	pub fn should_announce(&self) -> bool {
-		self.config.channel_options.annouce_channel
+		self.config.channel_options.announced_channel
 	}
 
 	/// Gets the fee we'd want to charge for adding an HTLC output to this Channel
@@ -2436,7 +2441,7 @@ impl Channel {
 			delayed_payment_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.delayed_payment_base_key),
 			htlc_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key),
 			first_per_commitment_point: PublicKey::from_secret_key(&self.secp_ctx, &local_commitment_secret),
-			channel_flags: if self.config.channel_options.allow_annouce_channel {1} else {0},
+			channel_flags: if self.config.channel_options.announced_channel {1} else {0},
 			shutdown_scriptpubkey: None,
 		}
 	}
@@ -2540,7 +2545,7 @@ impl Channel {
 	/// Note that the "channel must be funded" requirement is stricter than BOLT 7 requires - see
 	/// https://github.com/lightningnetwork/lightning-rfc/issues/468
 	pub fn get_channel_announcement(&self, our_node_id: PublicKey, chain_hash: Sha256dHash) -> Result<(msgs::UnsignedChannelAnnouncement, Signature), HandleError> {
-		if !self.config.channel_options.allow_annouce_channel {
+		if !self.config.channel_options.force_announced_channel_preference {
 			return Err(HandleError{err: "Channel is not available for public announcements", action: Some(msgs::ErrorAction::IgnoreError)});
 		}
 		if self.channel_state & (ChannelState::ChannelFunded as u32) == 0 {
@@ -2903,7 +2908,7 @@ mod tests {
 
 		let their_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap());
 		let mut config = UserConfigurations::new();
-		config.channel_options.annouce_channel= false;
+		config.channel_options.announced_channel= false;
 		let mut chan = Channel::new_outbound(&feeest, chan_keys, their_node_id, 10000000, 100000, 42, Arc::clone(&logger), &config).unwrap(); // Nothing uses their network key in this test
 		chan.their_to_self_delay = 144;
 		chan.our_dust_limit_satoshis = 546;

src/ln/channelmanager.rs

@@ -3009,8 +3009,9 @@ mod tests {
 				SecretKey::from_slice(&secp_ctx, &key_slice).unwrap()
 			};
 			let mut config = UserConfigurations::new();
-			config.channel_options.annouce_channel = true;
+			config.channel_options.announced_channel = true;
 			config.channel_options.fee_proportional_millionths = 0;
+			config.channel_options.force_announced_channel_preference = true;
 			let node = ChannelManager::new(node_id.clone(), Network::Testnet, feeest.clone(), chan_monitor.clone(), chain_monitor.clone(), tx_broadcaster.clone(), Arc::clone(&logger), config).unwrap();
 			let router = Router::new(PublicKey::from_secret_key(&secp_ctx, &node_id), chain_monitor.clone(), Arc::clone(&logger));
 			nodes.push(Node { chain_monitor, tx_broadcaster, chan_monitor, node, router,

src/util/configurations.rs

@@ -58,19 +58,19 @@ impl ChannelLimits {
 pub struct ChannelOptions{
 	/// Amount (in millionths of a satoshi) channel will charge per transferred satoshi.
 	pub fee_proportional_millionths : u32,
-	///should we require the channel be annouced or not
-	pub annouce_channel : bool,
-	///do we allow incomming channel to be announced
-	pub allow_annouce_channel : bool,
+	///Is this channel an annouced channe;
+	pub announced_channel : bool,
+	///do we force the incomming channel to match our announced channel preference
+	pub force_announced_channel_preference : bool,
 }
 impl ChannelOptions {
 	/// creating a struct with values.
 	/// fee_proportional_millionths should be changed afterwords
 	pub fn new() -> Self{
 		ChannelOptions {
 			fee_proportional_millionths : 0,
-			annouce_channel : true,
-			allow_annouce_channel : true,
+			announced_channel : true,
+			force_announced_channel_preference : false,
 		}
 	}
 }