add announce to config

Author: SWvheerden

fuzz/fuzz_targets/channel_target.rs

@@ -193,8 +193,10 @@ pub fn do_test(data: &[u8]) {
 
 	let mut channel = if get_slice!(1)[0] != 0 {
 		let chan_value = slice_to_be24(get_slice!(3));
-
-		let mut chan = match Channel::new_outbound(&fee_est, chan_keys!(), their_pubkey, chan_value, slice_to_be24(get_slice!(3)), get_slice!(1)[0] == 0, slice_to_be64(get_slice!(8)), Arc::clone(&logger), &UserConfigurations::new()) {
+		let push_msat = slice_to_be24(get_slice!(3));
+		let mut config = UserConfigurations::new();
+		config.channel_options.annouce_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,
 		};
@@ -219,7 +221,9 @@ pub fn do_test(data: &[u8]) {
 		} else {
 			decode_msg!(msgs::OpenChannel, 2*32+6*8+4+2*2+6*33+1)
 		};
-		let mut chan = match Channel::new_from_req(&fee_est, chan_keys!(), their_pubkey, &open_chan, slice_to_be64(get_slice!(8)), false, get_slice!(1)[0] == 0, Arc::clone(&logger),&UserConfigurations::new()) {
+		let mut chan_config = UserConfigurations::new();
+		chan_config.channel_options.annouce_channel = false;
+		let mut chan = match Channel::new_from_req(&fee_est, chan_keys!(), their_pubkey, &open_chan, slice_to_be64(get_slice!(8)), get_slice!(1)[0] == 0, Arc::clone(&logger),&chan_config) {
 			Ok(chan) => chan,
 			Err(_) => return,
 		};

fuzz/fuzz_targets/full_stack_target.rs

@@ -236,8 +236,10 @@ pub fn do_test(data: &[u8], logger: &Arc<Logger>) {
 	let watch = Arc::new(ChainWatchInterfaceUtil::new(Network::Bitcoin, Arc::clone(&logger)));
 	let broadcast = Arc::new(TestBroadcaster{});
 	let monitor = channelmonitor::SimpleManyChannelMonitor::new(watch.clone(), broadcast.clone());
-	let config = UserConfigurations::new();
-	let channelmanager = ChannelManager::new(our_network_key, slice_to_be32(get_slice!(4)), get_slice!(1)[0] != 0, Network::Bitcoin, fee_est.clone(), monitor.clone(), watch.clone(), broadcast.clone(), Arc::clone(&logger), config).unwrap();
+	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);
+	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)));
 
 	let peers = RefCell::new([false; 256]);

src/ln/channel.rs

@@ -276,7 +276,6 @@ pub struct Channel {
 	channel_state: u32,
 	channel_outbound: bool,
 	secp_ctx: Secp256k1<secp256k1::All>,
-	announce_publicly: bool,
 	channel_value_satoshis: u64,
 
 	local_keys: ChannelKeys,
@@ -409,7 +408,7 @@ impl Channel {
 	}
 
 	// Constructors:
-	pub fn new_outbound(fee_estimator: &FeeEstimator, chan_keys: ChannelKeys, their_node_id: PublicKey, channel_value_satoshis: u64, push_msat: u64, announce_publicly: bool, user_id: u64, logger: Arc<Logger>, configurations: &UserConfigurations) -> Result<Channel, APIError> {
+	pub fn new_outbound(fee_estimator: &FeeEstimator, chan_keys: ChannelKeys, their_node_id: PublicKey, channel_value_satoshis: u64, push_msat: u64, user_id: u64, logger: Arc<Logger>, configurations: &UserConfigurations) -> Result<Channel, APIError> {
 		if channel_value_satoshis >= MAX_FUNDING_SATOSHIS {
 			return Err(APIError::APIMisuseError{err: "funding value > 2^24"});
 		}
@@ -441,7 +440,6 @@ impl Channel {
 			channel_state: ChannelState::OurInitSent as u32,
 			channel_outbound: true,
 			secp_ctx: secp_ctx,
-			announce_publicly: announce_publicly,
 			channel_value_satoshis: channel_value_satoshis,
 
 			local_keys: chan_keys,
@@ -506,7 +504,7 @@ impl Channel {
 	/// Assumes chain_hash has already been checked and corresponds with what we expect!
 	/// Generally prefers to take the DisconnectPeer action on failure, as a notice to the sender
 	/// that we're rejecting the new channel.
-	pub fn new_from_req(fee_estimator: &FeeEstimator, chan_keys: ChannelKeys, their_node_id: PublicKey, msg: &msgs::OpenChannel, user_id: u64, require_announce: bool, allow_announce: bool, logger: Arc<Logger>, configurations : &UserConfigurations) -> Result<Channel, HandleError> {
+	pub fn new_from_req(fee_estimator: &FeeEstimator, chan_keys: ChannelKeys, their_node_id: PublicKey, msg: &msgs::OpenChannel, user_id: u64, logger: Arc<Logger>, configurations : &UserConfigurations) -> Result<Channel, HandleError> {
 		macro_rules! return_error_message {
 			( $msg: expr ) => {
 				return Err(HandleError{err: $msg, action: Some(msgs::ErrorAction::SendErrorMessage{ msg: msgs::ErrorMessage { channel_id: msg.temporary_channel_id, data: $msg.to_string() }})});
@@ -569,10 +567,10 @@ impl Channel {
 		// Convert things into internal flags and prep our state:
 
 		let their_announce = if (msg.channel_flags & 1) == 1 { true } else { false };
-		if require_announce && !their_announce {
+		if configurations.channel_options.annouce_channel && !their_announce {
 			return_error_message!("Peer tried to open unannounced channel, but we require public ones");
 		}
-		if !allow_announce && their_announce {
+		if !configurations.channel_options.allow_annouce_channel && their_announce {
 			return_error_message!("Peer tried to open announced channel, but we require private ones");
 		}
 
@@ -620,7 +618,6 @@ impl Channel {
 			channel_state: (ChannelState::OurInitSent as u32) | (ChannelState::TheirInitSent as u32),
 			channel_outbound: false,
 			secp_ctx: secp_ctx,
-			announce_publicly: their_announce,
 
 			local_keys: chan_keys,
 			cur_local_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
@@ -2254,7 +2251,7 @@ impl Channel {
 	}
 
 	pub fn should_announce(&self) -> bool {
-		self.announce_publicly
+		self.config.channel_options.annouce_channel
 	}
 
 	/// Gets the fee we'd want to charge for adding an HTLC output to this Channel
@@ -2440,7 +2437,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.announce_publicly {1} else {0},
+			channel_flags: if self.config.channel_options.allow_annouce_channel {1} else {0},
 			shutdown_scriptpubkey: None,
 		}
 	}
@@ -2544,7 +2541,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.announce_publicly {
+		if !self.self.config.channel_options.allow_annouce_channel {
 			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 {
@@ -2906,7 +2903,9 @@ mod tests {
 				hex::decode("023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb").unwrap()[..]);
 
 		let their_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap());
-		let mut chan = Channel::new_outbound(&feeest, chan_keys, their_node_id, 10000000, 100000, false, 42, Arc::clone(&logger), &UserConfigurations::new()).unwrap(); // Nothing uses their network key in this test
+		let mut config = UserConfigurations::new();
+		config.channel_options.annouce_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

@@ -255,7 +255,6 @@ pub struct ChannelManager {
 	chain_monitor: Arc<ChainWatchInterface>,
 	tx_broadcaster: Arc<BroadcasterInterface>,
 
-	announce_channels_publicly: bool,
 	latest_block_height: AtomicUsize,
 	secp_ctx: Secp256k1<secp256k1::All>,
 
@@ -308,7 +307,7 @@ impl ChannelManager {
 	/// the main "logic hub" for all channel-related actions, and implements ChannelMessageHandler.
 	/// Non-proportional fees are fixed according to our risk using the provided fee estimator.
 	/// panics if channel_value_satoshis is >= `MAX_FUNDING_SATOSHIS`!
-	pub fn new(our_network_key: SecretKey, fee_proportional_millionths: u32, announce_channels_publicly: bool, network: Network, feeest: Arc<FeeEstimator>, monitor: Arc<ManyChannelMonitor>, chain_monitor: Arc<ChainWatchInterface>, tx_broadcaster: Arc<BroadcasterInterface>, logger: Arc<Logger>, config : UserConfigurations) -> Result<Arc<ChannelManager>, secp256k1::Error> {
+	pub fn new(our_network_key: SecretKey, network: Network, feeest: Arc<FeeEstimator>, monitor: Arc<ManyChannelMonitor>, chain_monitor: Arc<ChainWatchInterface>, tx_broadcaster: Arc<BroadcasterInterface>, logger: Arc<Logger>, config : UserConfigurations) -> Result<Arc<ChannelManager>, secp256k1::Error> {
 		let secp_ctx = Secp256k1::new();
 		let res = Arc::new(ChannelManager {
 			configuration : config,
@@ -317,8 +316,7 @@ impl ChannelManager {
 			monitor: monitor.clone(),
 			chain_monitor,
 			tx_broadcaster,
-
-			announce_channels_publicly,			
+		
 			latest_block_height: AtomicUsize::new(0), //TODO: Get an init value (generally need to replay recent chain on chain_monitor registration)
 			secp_ctx,
 
@@ -369,7 +367,7 @@ impl ChannelManager {
 			}
 		};
 
-		let channel = Channel::new_outbound(&*self.fee_estimator, chan_keys, their_network_key, channel_value_satoshis, push_msat, self.announce_channels_publicly, user_id, Arc::clone(&self.logger), &self.configuration)?;
+		let channel = Channel::new_outbound(&*self.fee_estimator, chan_keys, their_network_key, channel_value_satoshis, push_msat, user_id, Arc::clone(&self.logger), &self.configuration)?;
 		let res = channel.get_open_channel(self.genesis_hash.clone(), &*self.fee_estimator);
 		let mut channel_state = self.channel_state.lock().unwrap();
 		match channel_state.by_id.insert(channel.channel_id(), channel) {
@@ -1456,7 +1454,7 @@ impl ChannelManager {
 			}
 		};
 
-		let channel = Channel::new_from_req(&*self.fee_estimator, chan_keys, their_node_id.clone(), msg, 0, false, self.announce_channels_publicly, Arc::clone(&self.logger), &self.configuration).map_err(|e| MsgHandleErrInternal::from_no_close(e))?;
+		let channel = Channel::new_from_req(&*self.fee_estimator, chan_keys, their_node_id.clone(), msg, 0, Arc::clone(&self.logger), &self.configuration).map_err(|e| MsgHandleErrInternal::from_no_close(e))?;
 		let accept_msg = channel.get_accept_channel();
 		channel_state.by_id.insert(channel.channel_id(), channel);
 		Ok(accept_msg)
@@ -2994,7 +2992,7 @@ mod tests {
 
 	fn create_network(node_count: usize) -> Vec<Node> {
 		use util::UserConfigurations;
-		
+
 		let mut nodes = Vec::new();
 		let mut rng = thread_rng();
 		let secp_ctx = Secp256k1::new();
@@ -3013,8 +3011,10 @@ mod tests {
 				rng.fill_bytes(&mut key_slice);
 				SecretKey::from_slice(&secp_ctx, &key_slice).unwrap()
 			};
-			let config = UserConfigurations::new();
-			let node = ChannelManager::new(node_id.clone(), 0, true, Network::Testnet, feeest.clone(), chan_monitor.clone(), chain_monitor.clone(), tx_broadcaster.clone(), Arc::clone(&logger), config).unwrap();
+			let mut config = UserConfigurations::new();
+			config.channel_options.annouce_channel = true;
+			config.channel_options.fee_proportional_millionths = 0;
+			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,
 				network_payment_count: payment_count.clone(),

src/util/configurations.rs

@@ -1,6 +1,6 @@
 /// This is the main user configuration
 /// This struct should contain all user customizable options as this is passed to the channel to be accessed
-#[derive(Copy, Clone)] 
+#[derive(Copy, Clone, Debug)] 
 pub struct UserConfigurations{
 	/// optional user spesefied channel limits
 	/// These should stay the same for a channel and cannot change during the life of a channel
@@ -20,7 +20,7 @@ impl UserConfigurations {
 
 /// This struct contains all the optional bolt 2 channel limits.
 /// If the user wants to check a value, the value needs to be filled in, as by default they are not checked
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Debug)]
 pub struct ChannelLimits{
 	/// minimum allowed funding_satoshis
 	pub funding_satoshis :u64,
@@ -51,12 +51,14 @@ impl ChannelLimits {
 }
 
 /// This struct contains all the custom channel options.
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Debug)]
 pub struct ChannelOptions{
 	/// Amount (in millionths of a satoshi) channel will charge per transferred satoshi.
 	pub fee_proportional_millionths : u32, 	
-	///should the channel be annouced or not
+	///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,
 }
 impl ChannelOptions {
 	/// creating a struct with values. 
@@ -65,6 +67,7 @@ impl ChannelOptions {
 		ChannelOptions {
 			fee_proportional_millionths : 0,
 			annouce_channel : true,
+			allow_annouce_channel : true,
 		}
 	}
 }