Added tests to check the bolt 2 specs for Sending Node Channel establishment - open_channel

Author: Yuko Roodt

src/ln/channel.rs

@@ -21,7 +21,7 @@ use ln::chan_utils;
 use chain::chaininterface::{FeeEstimator,ConfirmationTarget};
 use chain::transaction::OutPoint;
 use chain::keysinterface::{ChannelKeys, KeysInterface};
-use util::{transaction_utils,rng};
+use util::transaction_utils;
 use util::ser::{Readable, ReadableArgs, Writeable, Writer, WriterWriteAdaptor};
 use util::sha2::Sha256;
 use util::logger::Logger;
@@ -412,7 +412,7 @@ impl Channel {
 	}
 
 	// Constructors:
-	pub fn new_outbound(fee_estimator: &FeeEstimator, keys_provider: &Arc<KeysInterface>, their_node_id: PublicKey, channel_value_satoshis: u64, push_msat: u64, user_id: u64, logger: Arc<Logger>, config: &UserConfig) -> Result<Channel, APIError> {
+	pub fn new_outbound(fee_estimator: &FeeEstimator, keys_provider: &Arc<KeysInterface>, their_node_id: PublicKey,channel_id: [u8; 32], channel_value_satoshis: u64, push_msat: u64, user_id: u64, logger: Arc<Logger>, config: &UserConfig) -> Result<Channel, APIError> {
 		let chan_keys = keys_provider.get_channel_keys(false);
 
 		if channel_value_satoshis >= MAX_FUNDING_SATOSHIS {
@@ -440,11 +440,11 @@ impl Channel {
 			user_id: user_id,
 			config: config.channel_options.clone(),
 
-			channel_id: rng::rand_u832(),
+			channel_id,
 			channel_state: ChannelState::OurInitSent as u32,
 			channel_outbound: true,
 			secp_ctx: secp_ctx,
-			channel_value_satoshis: channel_value_satoshis,
+			channel_value_satoshis,
 
 			local_keys: chan_keys,
 			shutdown_pubkey: keys_provider.get_shutdown_pubkey(),
@@ -3861,6 +3861,7 @@ mod tests {
 	use util::config::UserConfig;
 	use util::test_utils;
 	use util::logger::Logger;
+	use util::rng;
 	use secp256k1::{Secp256k1,Message,Signature};
 	use secp256k1::key::{SecretKey,PublicKey};
 	use crypto::sha2::Sha256;
@@ -3928,7 +3929,7 @@ mod tests {
 		let their_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap());
 		let mut config = UserConfig::new();
 		config.channel_options.announced_channel = false;
-		let mut chan = Channel::new_outbound(&feeest, &keys_provider, their_node_id, 10000000, 100000, 42, Arc::clone(&logger), &config).unwrap(); // Nothing uses their network key in this test
+		let mut chan = Channel::new_outbound(&feeest, &keys_provider, their_node_id,rng::rand_u832(), 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

@@ -501,11 +501,27 @@ impl ChannelManager {
 	/// Raises APIError::APIMisuseError when channel_value_satoshis > 2**24 or push_msat is
 	/// greater than channel_value_satoshis * 1k or channel_value_satoshis is < 1000.
 	pub fn create_channel(&self, their_network_key: PublicKey, channel_value_satoshis: u64, push_msat: u64, user_id: u64) -> Result<(), APIError> {
+		self.create_channel_with_id(their_network_key,rng::rand_u832(),channel_value_satoshis,push_msat,user_id)
+	}
+
+	/// Creates a new outbound channel to the given remote node and with the given value.
+	///
+	/// user_id will be provided back as user_channel_id in FundingGenerationReady and
+	/// FundingBroadcastSafe events to allow tracking of which events correspond with which
+	/// create_channel call. Note that user_channel_id defaults to 0 for inbound channels, so you
+	/// may wish to avoid using 0 for user_id here.
+	///
+	/// If successful, will generate a SendOpenChannel message event, so you should probably poll
+	/// PeerManager::process_events afterwards.
+	///
+	/// Raises APIError::APIMisuseError when channel_value_satoshis > 2**24 or push_msat is
+	/// greater than channel_value_satoshis * 1k or channel_value_satoshis is < 1000.
+	pub fn create_channel_with_id(&self, their_network_key: PublicKey, channel_id: [u8; 32], channel_value_satoshis: u64, push_msat: u64, user_id: u64) -> Result<(), APIError> {
 		if channel_value_satoshis < 1000 {
 			return Err(APIError::APIMisuseError { err: "channel_value must be at least 1000 satoshis" });
 		}
 
-		let channel = Channel::new_outbound(&*self.fee_estimator, &self.keys_manager, their_network_key, channel_value_satoshis, push_msat, user_id, Arc::clone(&self.logger), &self.default_configuration)?;
+		let channel = Channel::new_outbound(&*self.fee_estimator, &self.keys_manager, their_network_key, channel_id, 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 _ = self.total_consistency_lock.read().unwrap();
@@ -5119,6 +5135,63 @@ mod tests {
 		assert!(nodes[2].node.list_channels().is_empty());
 	}
 
+	#[test]
+	#[should_panic]
+	fn bolt2_open_channel_sending_node_checks1() { //This test needs to be on its own as we are catching a panic
+		let nodes = create_network(2);
+
+		// BOLT #2 spec: Sending node must ensure temporary_channel_id is unique from any other channel ID with the same peer.
+		// Note: currently a collision on a channel id will panic, not creating the channel with an error will be better as the system can still continue to function
+		let channel_value_satoshis=10000;
+		let push_msat=10001;
+		nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, push_msat, 42).unwrap();
+		let node0_to_1_send_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
+		nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), &node0_to_1_send_open_channel).unwrap();
+
+		//Create a second channel with a channel_id collision
+		let channel_id=node0_to_1_send_open_channel.temporary_channel_id;
+		assert!(nodes[0].node.create_channel_with_id(nodes[0].node.get_our_node_id(),channel_id, channel_value_satoshis, push_msat, 42).is_err());
+	}
+
+	#[test]
+	fn bolt2_open_channel_sending_node_checks2() {
+		let nodes = create_network(2);
+
+		// BOLT #2 spec: Sending node must set funding_satoshis to less than 2^24 satoshis
+		let channel_value_satoshis=2^24;
+		let push_msat=10001;
+		assert!(nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, push_msat, 42).is_err());
+
+		// BOLT #2 spec: Sending node must set push_msat to equal or less than 1000 * funding_satoshis
+		let channel_value_satoshis=10000;
+		// Test when push_msat is equal to 1000 * funding_satoshis.
+		let push_msat=1000*channel_value_satoshis+1;
+		assert!(nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, push_msat, 42).is_err());
+
+		// BOLT #2 spec: Sending node must set set channel_reserve_satoshis greater than or equal to dust_limit_satoshis
+		let channel_value_satoshis=10000;
+		let push_msat=10001;
+		assert!(nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, push_msat, 42).is_ok()); //Create a valid channel
+		let node0_to_1_send_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
+		assert!(node0_to_1_send_open_channel.channel_reserve_satoshis>=node0_to_1_send_open_channel.dust_limit_satoshis);
+
+		// BOLT #2 spec: Sending node must set undefined bits in channel_flags to 0
+		// Only the least-significant bit of channel_flags is currently defined resulting in channel_flags only having one of two possible states 0 or 1
+		assert!(node0_to_1_send_open_channel.channel_flags<=1);
+
+		// BOLT #2 spec: Sending node must ensure the chain_hash value identifies the chain it wishes to open the channel within.
+		let chain_hash=genesis_block(Network::Testnet).header.bitcoin_hash();
+		assert_eq!(node0_to_1_send_open_channel.chain_hash,chain_hash);
+
+		// BOLT #2 spec: Sending node must set funding_pubkey, revocation_basepoint, htlc_basepoint, payment_basepoint, and delayed_payment_basepoint to valid DER-encoded, compressed, secp256k1 pubkeys.
+		let secp  = Secp256k1::new();
+		assert!(PublicKey::from_slice(&secp, &node0_to_1_send_open_channel.funding_pubkey.serialize()).is_ok());
+		assert!(PublicKey::from_slice(&secp, &node0_to_1_send_open_channel.revocation_basepoint.serialize()).is_ok());
+		assert!(PublicKey::from_slice(&secp, &node0_to_1_send_open_channel.htlc_basepoint.serialize()).is_ok());
+		assert!(PublicKey::from_slice(&secp, &node0_to_1_send_open_channel.payment_basepoint.serialize()).is_ok());
+		assert!(PublicKey::from_slice(&secp, &node0_to_1_send_open_channel.delayed_payment_basepoint.serialize()).is_ok());
+	}
+
 	#[test]
 	fn test_shutdown_rebroadcast() {
 		do_test_shutdown_rebroadcast(0);