rebase to new master

Author: SWvheerden

fuzz/fuzz_targets/channel_target.rs

@@ -16,11 +16,12 @@ use lightning::chain::transaction::OutPoint;
 use lightning::util::reset_rng_state;
 use lightning::util::logger::Logger;
 use lightning::util::ser::{Readable, Reader};
+use lightning::util::configurations::UserConfigurations;
+
 
 mod utils;
 
 use utils::test_logger;
-
 use secp256k1::key::{PublicKey, SecretKey};
 use secp256k1::Secp256k1;
 
@@ -193,7 +194,7 @@ 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)) {
+		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()) {
 			Ok(chan) => chan,
 			Err(_) => return,
 		};
@@ -218,7 +219,7 @@ 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)) {
+		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()) {
 			Ok(chan) => chan,
 			Err(_) => return,
 		};

src/ln/channel.rs

@@ -25,6 +25,7 @@ use util::{transaction_utils,rng};
 use util::sha2::Sha256;
 use util::logger::Logger;
 use util::errors::APIError;
+use util::configurations::UserConfigurations;
 
 use std;
 use std::default::Default;
@@ -258,11 +259,14 @@ const BOTH_SIDES_SHUTDOWN_MASK: u32 = (ChannelState::LocalShutdownSent as u32 |
 
 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 struct Channel {
+
+	config : UserConfigurations,
 	user_id: u64,
 
 	channel_id: [u8; 32],
@@ -402,7 +406,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>) -> Result<Channel, APIError> {
+	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> {
 		if channel_value_satoshis >= MAX_FUNDING_SATOSHIS {
 			return Err(APIError::APIMisuseError{err: "funding value > 2^24"});
 		}
@@ -429,7 +433,7 @@ impl Channel {
 
 		Ok(Channel {
 			user_id: user_id,
-
+			config : configurations.clone(),
 			channel_id: rng::rand_u832(),
 			channel_state: ChannelState::OurInitSent as u32,
 			channel_outbound: true,
@@ -499,7 +503,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>) -> Result<Channel, HandleError> {
+	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> {
 		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() }})});
@@ -538,6 +542,26 @@ impl Channel {
 		if msg.max_accepted_htlcs > 483 {
 			return_error_message!("max_accpted_htlcs > 483");
 		}
+		//optional parameter checking 
+		// MAY fail the channel if
+		if msg.funding_satoshis < configurations.channel_limits.funding_satoshis {
+			return_error_message!("funding satoshis is less than the user specified limit");
+		}
+		if msg.htlc_minimum_msat > configurations.channel_limits.htlc_minimum_msat {
+			return_error_message!("htlc minimum msat is higher than the user specified limit");
+		}
+		if msg.max_htlc_value_in_flight_msat < configurations.channel_limits.max_htlc_value_in_flight_msat {
+			return_error_message!("max htlc value in flight msat is less than the user specified limit");
+		}
+		if msg.channel_reserve_satoshis > configurations.channel_limits.channel_reserve_satoshis {
+			return_error_message!("channel reserve satoshis is higher than the user specified limit");
+		}
+		if msg.max_accepted_htlcs < configurations.channel_limits.max_accepted_htlcs {
+			return_error_message!("max accepted htlcs is less than the user specified limit");
+		}
+		if msg.dust_limit_satoshis < configurations.channel_limits.dust_limit_satoshis {
+			return_error_message!("dust limit satoshis is less than the user specified limit");
+		}
 
 		// Convert things into internal flags and prep our state:
 
@@ -588,7 +612,7 @@ impl Channel {
 
 		let mut chan = Channel {
 			user_id: user_id,
-
+			config: (*configurations).clone(),
 			channel_id: msg.temporary_channel_id,
 			channel_state: (ChannelState::OurInitSent as u32) | (ChannelState::TheirInitSent as u32),
 			channel_outbound: false,
@@ -1244,15 +1268,6 @@ impl Channel {
 			return_error_message!("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
-
 		self.channel_monitor.set_their_base_keys(&msg.htlc_basepoint, &msg.delayed_payment_basepoint);
 
 		self.their_dust_limit_satoshis = msg.dust_limit_satoshis;
@@ -2866,6 +2881,7 @@ mod tests {
 
 	#[test]
 	fn outbound_commitment_test() {
+		use util::configurations::UserConfigurations;
 		// Test vectors from BOLT 3 Appendix C:
 		let feeest = TestFeeEstimator{fee_est: 15000};
 		let logger : Arc<Logger> = Arc::new(test_utils::TestLogger::new());
@@ -2887,7 +2903,7 @@ 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 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
 		chan.their_to_self_delay = 144;
 		chan.our_dust_limit_satoshis = 546;
 

src/ln/channelmanager.rs

@@ -17,6 +17,7 @@ use ln::channelmonitor::ManyChannelMonitor;
 use ln::router::{Route,RouteHop};
 use ln::msgs;
 use ln::msgs::{HandleError,ChannelMessageHandler,MsgEncodable,MsgDecodable};
+use util::configurations::UserConfigurations;
 use util::{byte_utils, events, internal_traits, rng};
 use util::sha2::Sha256;
 use util::chacha20poly1305rfc::ChaCha20;
@@ -245,6 +246,7 @@ 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 {
+	configuration : UserConfigurations,
 	genesis_hash: Sha256dHash,
 	fee_estimator: Arc<FeeEstimator>,
 	monitor: Arc<ManyChannelMonitor>,
@@ -310,6 +312,7 @@ impl ChannelManager {
 		let secp_ctx = Secp256k1::new();
 
 		let res = Arc::new(ChannelManager {
+			configuration : UserConfigurations::new(),
 			genesis_hash: genesis_block(network).header.bitcoin_hash(),
 			fee_estimator: feeest.clone(),
 			monitor: monitor.clone(),
@@ -368,7 +371,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))?;
+		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 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) {
@@ -1455,7 +1458,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)).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, false, self.announce_channels_publicly, 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)
@@ -1481,8 +1484,7 @@ impl ChannelManager {
 		pending_events.push(events::Event::FundingGenerationReady {
 			temporary_channel_id: msg.temporary_channel_id,
 			channel_value_satoshis: value,
-			output_script: output_script,
-			user_channel_id: user_id,
+			output_script: output_script,			user_channel_id: user_id,
 		});
 		Ok(())
 	}

src/ln/msgs.rs

@@ -705,7 +705,7 @@ impl MsgDecodable for OpenChannel {
 		let mut temp_channel_id = [0; 32];
 		temp_channel_id[..].copy_from_slice(&v[32..64]);
 		Ok(OpenChannel {
-			chain_hash: deserialize(&v[0..32]).unwrap(),
+			chain_hash: deserialize(&v[0..32]).unwrap(), //panic should not be possible as we are deseriliazing a hash
 			temporary_channel_id: temp_channel_id,
 			funding_satoshis: byte_utils::slice_to_be64(&v[64..72]),
 			push_msat: byte_utils::slice_to_be64(&v[72..80]),

src/ln/router.rs

@@ -70,6 +70,8 @@ impl std::fmt::Display for ChannelInfo {
 	}
 }
 
+
+
 struct NodeInfo {
 	#[cfg(feature = "non_bitcoin_chain_hash_routing")]
 	channels: Vec<(u64, Sha256dHash)>,

src/util/configurations.rs

@@ -0,0 +1,37 @@
+#[derive(Copy, Clone)]
+pub struct UserConfigurations{
+    pub channel_limits : ChannelLimits,
+}
+
+impl UserConfigurations {
+    pub fn new() -> Self{
+        UserConfigurations {
+            channel_limits : ChannelLimits::new(),
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct ChannelLimits
+{
+	pub funding_satoshis :u64,
+	pub htlc_minimum_msat : u64,
+	pub max_htlc_value_in_flight_msat : u64,
+	pub channel_reserve_satoshis : u64,
+	pub max_accepted_htlcs : u16,
+	pub dust_limit_satoshis : u64,
+}
+
+impl ChannelLimits {
+	//creating max and min possible values because if they are not set, means we should not check them. 
+	pub fn new() -> Self{
+		ChannelLimits {
+			funding_satoshis : 0,
+			htlc_minimum_msat : <u64>::max_value(),
+			max_htlc_value_in_flight_msat : 0,
+			channel_reserve_satoshis : <u64>::max_value(),
+			max_accepted_htlcs : 0,
+			dust_limit_satoshis : 0,
+		}
+	}
+}

src/util/mod.rs

@@ -29,3 +29,6 @@ pub mod ser;
 pub(crate) mod ser;
 
 pub mod logger;
+pub use self::configurations::{UserConfigurations, ChannelLimits};
+pub mod configurations;
+