Added config file to allow users to specify channel limits as per bolt 2

Author: SWvheerden

fuzz/fuzz_targets/full_stack_target.rs

@@ -22,6 +22,7 @@ use lightning::util::events::{EventsProvider,Event};
 use lightning::util::reset_rng_state;
 use lightning::util::logger::Logger;
 use lightning::util::sha2::Sha256;
+use lightning::util::configurations::UserConfig;
 
 mod utils;
 
@@ -235,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 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)).unwrap();
+	let mut config = UserConfig::new();
+	config.channel_options.fee_proportional_millionths =  slice_to_be32(get_slice!(4));
+	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)));
 
 	let peers = RefCell::new([false; 256]);

src/ln/channel.rs

@@ -26,6 +26,7 @@ use util::ser::Writeable;
 use util::sha2::Sha256;
 use util::logger::Logger;
 use util::errors::APIError;
+use util::configurations::{UserConfig,ChannelConfig};
 
 use std;
 use std::default::Default;
@@ -277,18 +278,20 @@ const MULTI_STATE_FLAGS: u32 = (BOTH_SIDES_SHUTDOWN_MASK | ChannelState::PeerDis
 
 const INITIAL_COMMITMENT_NUMBER: u64 = (1 << 48) - 1;
 
+
 // TODO: We should refactor this to be an Inbound/OutboundChannel until initial setup handshaking
 // has been completed, and then turn into a Channel to get compiler-time enforcement of things like
 // calling channel_id() before we're set up or things like get_outbound_funding_signed on an
 // inbound channel.
 pub(super) struct Channel {
+	config :  ChannelConfig,
+
 	user_id: u64,
 
 	channel_id: [u8; 32],
 	channel_state: u32,
 	channel_outbound: bool,
 	secp_ctx: Secp256k1<secp256k1::All>,
-	announce_publicly: bool,
 	channel_value_satoshis: u64,
 
 	local_keys: ChannelKeys,
@@ -441,15 +444,21 @@ impl Channel {
 	}
 
 	/// Returns a minimum channel reserve value **they** need to maintain
-	///
 	/// Guaranteed to return a value no larger than channel_value_satoshis
 	fn get_our_channel_reserve_satoshis(channel_value_satoshis: u64) -> u64 {
 		let (q, _) = channel_value_satoshis.overflowing_div(100);
 		cmp::min(channel_value_satoshis, cmp::max(q, 1000)) //TODO
 	}
 
 	fn derive_our_dust_limit_satoshis(at_open_background_feerate: u64) -> u64 {
-		at_open_background_feerate * B_OUTPUT_PLUS_SPENDING_INPUT_WEIGHT / 1000 //TODO
+		#[cfg(test)]
+		{
+			547
+		}
+		#[cfg(not(test))]
+		{
+			at_open_background_feerate * B_OUTPUT_PLUS_SPENDING_INPUT_WEIGHT / 1000 //TODO
+		}
 	}
 
 	fn derive_our_htlc_minimum_msat(_at_open_channel_feerate_per_kw: u64) -> u64 {
@@ -469,11 +478,10 @@ 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>) -> 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>, config: &UserConfig) -> Result<Channel, APIError> {
 		if channel_value_satoshis >= MAX_FUNDING_SATOSHIS {
 			return Err(APIError::APIMisuseError{err: "funding value > 2^24"});
 		}
-
 		if push_msat > channel_value_satoshis * 1000 {
 			return Err(APIError::APIMisuseError{err: "push value > channel value"});
 		}
@@ -493,15 +501,15 @@ impl Channel {
 		                                          &PublicKey::from_secret_key(&secp_ctx, &chan_keys.delayed_payment_base_key),
 		                                          &chan_keys.htlc_base_key,
 		                                          BREAKDOWN_TIMEOUT, our_channel_monitor_claim_script);
-
+		
 		Ok(Channel {
 			user_id: user_id,
+			config: config.channel_options.clone(),
 
 			channel_id: rng::rand_u832(),
 			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,
@@ -579,7 +587,8 @@ impl Channel {
 
 	/// Creates a new channel from a remote sides' request for one.
 	/// Assumes chain_hash has already been checked and corresponds with what we expect!
-	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>) -> Result<Channel, ChannelError> {
+		pub fn new_from_req(fee_estimator: &FeeEstimator, chan_keys: ChannelKeys, their_node_id: PublicKey, msg: &msgs::OpenChannel, user_id: u64, logger: Arc<Logger>, config : &UserConfig) -> Result<Channel, ChannelError> {
+		let mut local_config = (*config).channel_options.clone();
 		// Check sanity of message fields:
 		if msg.funding_satoshis >= MAX_FUNDING_SATOSHIS {
 			return Err(ChannelError::Close("funding value > 2^24"));
@@ -610,23 +619,48 @@ impl Channel {
 		if msg.max_accepted_htlcs > 483 {
 			return Err(ChannelError::Close("max_accpted_htlcs > 483"));
 		}
+		//optional parameter checking
+		// MAY fail the channel if
+		if msg.funding_satoshis < config.channel_limits.min_funding_satoshis {
+			return Err(ChannelError::Close("funding satoshis is less than the user specified limit"));
+		}
+		if msg.htlc_minimum_msat > config.channel_limits.max_htlc_minimum_msat {
+			return Err(ChannelError::Close("htlc minimum msat is higher than the user specified limit"));
+		}
+		if msg.max_htlc_value_in_flight_msat < config.channel_limits.min_max_htlc_value_in_flight_msat {
+			return Err(ChannelError::Close("max htlc value in flight msat is less than the user specified limit"));
+		}
+		if msg.channel_reserve_satoshis > config.channel_limits.max_channel_reserve_satoshis {
+			return Err(ChannelError::Close("channel reserve satoshis is higher than the user specified limit"));
+		}
+		if msg.max_accepted_htlcs < config.channel_limits.min_max_accepted_htlcs {
+			return Err(ChannelError::Close("max accepted htlcs is less than the user specified limit"));
+		}
+		if msg.dust_limit_satoshis < config.channel_limits.min_dust_limit_satoshis {
+			println!("{:?}", msg.dust_limit_satoshis);
+			return Err(ChannelError::Close("dust limit satoshis is less than the user specified limit"));
+		}
+		if msg.dust_limit_satoshis > config.channel_limits.max_dust_limit_satoshis {
+			return Err(ChannelError::Close("dust limit satoshis is greater than the user specified limit"));
+		}
 
 		// 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 {
-			return Err(ChannelError::Close("Peer tried to open unannounced channel, but we require public ones"));
-		}
-		if !allow_announce && their_announce {
-			return Err(ChannelError::Close("Peer tried to open announced channel, but we require private ones"));
+		if config.channel_limits.force_announced_channel_preference{
+			if local_config.announced_channel != their_announce {
+				return Err(ChannelError::Close("Peer tried to open channel but their announcement preference is different from ours"));
+			}
 		}
+		//we either accept their preference or the preferences match
+		local_config.announced_channel = their_announce;
 
 		let background_feerate = fee_estimator.get_est_sat_per_1000_weight(ConfirmationTarget::Background);
 
 		let our_dust_limit_satoshis = Channel::derive_our_dust_limit_satoshis(background_feerate);
 		let our_channel_reserve_satoshis = Channel::get_our_channel_reserve_satoshis(msg.funding_satoshis);
 		if our_channel_reserve_satoshis < our_dust_limit_satoshis {
-			return Err(ChannelError::Close("Suitalbe channel reserve not found. aborting"));
+			return Err(ChannelError::Close("Suitable channel reserve not found. aborting"));
 		}
 		if msg.channel_reserve_satoshis < our_dust_limit_satoshis {
 			return Err(ChannelError::Close("channel_reserve_satoshis too small"));
@@ -660,12 +694,12 @@ impl Channel {
 
 		let mut chan = Channel {
 			user_id: user_id,
+			config: local_config,
 
 			channel_id: msg.temporary_channel_id,
 			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,
@@ -1314,7 +1348,7 @@ impl Channel {
 
 	// Message handlers:
 
-	pub fn accept_channel(&mut self, msg: &msgs::AcceptChannel) -> Result<(), ChannelError> {
+	pub fn accept_channel(&mut self, msg: &msgs::AcceptChannel, config : &UserConfig) -> Result<(), ChannelError> {
 		// Check sanity of message fields:
 		if !self.channel_outbound {
 			return Err(ChannelError::Close("Got an accept_channel message from an inbound peer"));
@@ -1352,16 +1386,10 @@ impl Channel {
 		if msg.max_accepted_htlcs > 483 {
 			return Err(ChannelError::Close("max_accpted_htlcs > 483"));
 		}
-
-		// TODO: Optional additional constraints mentioned in the spec
-		// MAY fail the channel if
-		// funding_satoshi is too small
-		// htlc_minimum_msat too large
-		// max_htlc_value_in_flight_msat too small
-		// channel_reserve_satoshis too large
-		// max_accepted_htlcs too small
-		// dust_limit_satoshis too small
-
+		//Optional user definined limits
+		if msg.minimum_depth > config.channel_limits.minimum_depth {
+			return Err(ChannelError::Close("We consider the minimum depth to be unreasonably large"));
+		}
 		self.channel_monitor.set_their_base_keys(&msg.htlc_basepoint, &msg.delayed_payment_basepoint);
 
 		self.their_dust_limit_satoshis = msg.dust_limit_satoshis;
@@ -2607,6 +2635,10 @@ impl Channel {
 		self.channel_value_satoshis
 	}
 
+	pub fn get_fee_proportional_millionths(&self) -> u32{
+		self.config.fee_proportional_millionths
+	}
+
 	#[cfg(test)]
 	pub fn get_feerate(&self) -> u64 {
 		self.feerate_per_kw
@@ -2648,7 +2680,7 @@ impl Channel {
 	}
 
 	pub fn should_announce(&self) -> bool {
-		self.announce_publicly
+		self.config.announced_channel
 	}
 
 	pub fn is_outbound(&self) -> bool {
@@ -2844,7 +2876,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.announced_channel {1} else {0},
 			shutdown_scriptpubkey: None,
 		}
 	}
@@ -2948,7 +2980,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), ChannelError> {
-		if !self.announce_publicly {
+		if !self.config.announced_channel {
 			return Err(ChannelError::Ignore("Channel is not available for public announcements"));
 		}
 		if self.channel_state & (ChannelState::ChannelFunded as u32) == 0 {
@@ -3318,6 +3350,7 @@ mod tests {
 
 	#[test]
 	fn outbound_commitment_test() {
+		use util::configurations::UserConfig;
 		// Test vectors from BOLT 3 Appendix C:
 		let feeest = TestFeeEstimator{fee_est: 15000};
 		let logger : Arc<Logger> = Arc::new(test_utils::TestLogger::new());
@@ -3339,7 +3372,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)).unwrap(); // Nothing uses their network key in this test
+		let mut config = UserConfig::new();
+		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

@@ -27,6 +27,7 @@ use ln::channelmonitor::{ChannelMonitorUpdateErr, ManyChannelMonitor, CLTV_CLAIM
 use ln::router::{Route,RouteHop};
 use ln::msgs;
 use ln::msgs::{ChannelMessageHandler, HandleError, RAACommitmentOrder};
+use util::configurations::UserConfig;
 use util::{byte_utils, events, internal_traits, rng};
 use util::sha2::Sha256;
 use util::ser::{Readable, Writeable};
@@ -275,14 +276,13 @@ const ERR: () = "You need at least 32 bit pointers (well, usize, but we'll assum
 /// Implements ChannelMessageHandler, handling the multi-channel parts and passing things through
 /// to individual Channels.
 pub struct ChannelManager {
+	default_configuration : UserConfig,
 	genesis_hash: Sha256dHash,
 	fee_estimator: Arc<FeeEstimator>,
 	monitor: Arc<ManyChannelMonitor>,
 	chain_monitor: Arc<ChainWatchInterface>,
 	tx_broadcaster: Arc<BroadcasterInterface>,
 
-	announce_channels_publicly: bool,
-	fee_proportional_millionths: u32,
 	latest_block_height: AtomicUsize,
 	secp_ctx: Secp256k1<secp256k1::All>,
 
@@ -359,22 +359,19 @@ impl ChannelManager {
 	/// This is the main "logic hub" for all channel-related actions, and implements
 	/// ChannelMessageHandler.
 	///
-	/// fee_proportional_millionths is an optional fee to charge any payments routed through us.
 	/// 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>) -> 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 : UserConfig) -> Result<Arc<ChannelManager>, secp256k1::Error> {
 		let secp_ctx = Secp256k1::new();
-
 		let res = Arc::new(ChannelManager {
+			default_configuration : config.clone(),
 			genesis_hash: genesis_block(network).header.bitcoin_hash(),
 			fee_estimator: feeest.clone(),
 			monitor: monitor.clone(),
 			chain_monitor,
 			tx_broadcaster,
 
-			announce_channels_publicly,
-			fee_proportional_millionths,
 			latest_block_height: AtomicUsize::new(0), //TODO: Get an init value (generally need to replay recent chain on chain_monitor registration)
 			secp_ctx,
 
@@ -427,8 +424,7 @@ impl ChannelManager {
 				Err(_) => panic!("RNG is busted!")
 			}
 		};
-
-		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))?;
+		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.default_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.entry(channel.channel_id()) {
@@ -1022,7 +1018,7 @@ impl ChannelManager {
 					if *amt_to_forward < chan.get_their_htlc_minimum_msat() { // amount_below_minimum
 						break Some(("HTLC amount was below the htlc_minimum_msat", 0x1000 | 11, Some(self.get_channel_update(chan).unwrap())));
 					}
-					let fee = amt_to_forward.checked_mul(self.fee_proportional_millionths as u64).and_then(|prop_fee| { (prop_fee / 1000000).checked_add(chan.get_our_fee_base_msat(&*self.fee_estimator) as u64) });
+					let fee = amt_to_forward.checked_mul(chan.get_fee_proportional_millionths() as u64).and_then(|prop_fee| { (prop_fee / 1000000).checked_add(chan.get_our_fee_base_msat(&*self.fee_estimator) as u64) });
 					if fee.is_none() || msg.amount_msat < fee.unwrap() || (msg.amount_msat - fee.unwrap()) < *amt_to_forward { // fee_insufficient
 						break Some(("Prior hop has deviated from specified fees parameters or origin node has obsolete ones", 0x1000 | 12, Some(self.get_channel_update(chan).unwrap())));
 					}
@@ -1076,7 +1072,7 @@ impl ChannelManager {
 			cltv_expiry_delta: CLTV_EXPIRY_DELTA,
 			htlc_minimum_msat: chan.get_our_htlc_minimum_msat(),
 			fee_base_msat: chan.get_our_fee_base_msat(&*self.fee_estimator),
-			fee_proportional_millionths: self.fee_proportional_millionths,
+			fee_proportional_millionths: chan.get_fee_proportional_millionths(),
 			excess_data: Vec::new(),
 		};
 
@@ -1687,7 +1683,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))
+		let channel = Channel::new_from_req(&*self.fee_estimator, chan_keys, their_node_id.clone(), msg, 0, Arc::clone(&self.logger), &self.default_configuration)
 			.map_err(|e| MsgHandleErrInternal::from_chan_no_close(e, msg.temporary_channel_id))?;
 		let accept_msg = channel.get_accept_channel();
 		channel_state.by_id.insert(channel.channel_id(), channel);
@@ -1703,7 +1699,7 @@ impl ChannelManager {
 						//TODO: see issue #153, need a consistent behavior on obnoxious behavior from random node
 						return Err(MsgHandleErrInternal::send_err_msg_no_close("Got a message for a channel from the wrong node!", msg.temporary_channel_id));
 					}
-					chan.accept_channel(&msg)
+					chan.accept_channel(&msg, &self.default_configuration)
 						.map_err(|e| MsgHandleErrInternal::from_chan_maybe_close(e, msg.temporary_channel_id))?;
 					(chan.get_value_satoshis(), chan.get_funding_redeemscript().to_v0_p2wsh(), chan.get_user_id())
 				},
@@ -3437,6 +3433,8 @@ mod tests {
 	}
 
 	fn create_network(node_count: usize) -> Vec<Node> {
+		use util::configurations::UserConfig;
+
 		let mut nodes = Vec::new();
 		let mut rng = thread_rng();
 		let secp_ctx = Secp256k1::new();
@@ -3455,7 +3453,11 @@ mod tests {
 				rng.fill_bytes(&mut key_slice);
 				SecretKey::from_slice(&secp_ctx, &key_slice).unwrap()
 			};
-			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)).unwrap();
+			let mut config = UserConfig::new();
+			config.channel_options.announced_channel = true;
+			config.channel_options.fee_proportional_millionths = 0;
+			config.channel_limits.force_announced_channel_preference = false;
+			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(),